Date generators

This is a reimplementation of the date generators by @Qqwy in whatyouhide#161. As such, it
is a (partial) implementation for whatyouhide#129.

The tests and documentation are entirely copy-pasted from his PR,
but the actual implementation is entirely new. As noted by @whatyouhide in a
comment to the original PR, I've opted to use the new `Date.add` function for
most of the cases.

I think the resulting implementation is a bit easier to follow. I have not added
Time, DateTime or NaiveDateTime, though I think we could probably do something
for those that follow this skeleton.

Co-authored-by: Qqwy / Marten <[email protected]>

Author: Munksgaard

lib/stream_data.ex

@@ -2094,6 +2094,85 @@ defmodule StreamData do
     end)
   end
 
+  @doc """
+  Generates arbitrary (past and future) dates.
+
+  Generated values shrink towards `Date.utc_today/0`.
+  """
+  @spec date() :: t(Date.t())
+  def date do
+    date([])
+  end
+
+  @doc """
+  Generates dates according to the given `options` or `date_range`.
+
+  ## Options
+
+  * `:origin` - (`Date`) if present, generated values will shrink towards this date. Cannot be combined with `:min` or `:max`.
+
+  * `:min` - (`Date`) if present, only dates _after_ this date will be generated. Values will shrink towards this date.
+
+  * `:max` - (`Date`) if present, only dates _before_ this date will be generated. Values will shrink towards this date.
+
+  If both `:min` and `:max` are provided, dates between the two mentioned dates will be generated.
+  Values will shrink towards `:min`.
+
+  If no options are provided, will work just like `date/0`.
+
+  ## `Date.Range`
+
+  Alternatively a `Date.Range` can be given. This will generate dates in the given range,
+  and with the supplied `date_range.step`.
+
+  Values will shrink towards `date_range.first`.
+
+  ## Calendar support
+
+  This generator works with `Calendar.ISO` and any other calendar
+  which implements the callbacks
+  `c:Calendar.naive_datetime_to_iso_days/7` and `c:Calendar.naive_datetime_from_iso_days/2`.
+  """
+  @spec date(Date.Range.t() | keyword()) :: t(Date.t())
+  def date(options_or_date_range)
+
+  def date(date_range = %Date.Range{}) do
+    Date.to_gregorian_days(date_range.first)..Date.to_gregorian_days(date_range.last)//date_range.step
+    |> StreamData.integer()
+    |> StreamData.map(&Date.from_gregorian_days(&1))
+  end
+
+  def date(options) when is_list(options) do
+    min = Keyword.get(options, :min, nil)
+    max = Keyword.get(options, :max, nil)
+    origin = Keyword.get(options, :origin)
+
+    case {min, max, origin} do
+      {nil, nil, nil} ->
+        StreamData.integer() |> StreamData.map(&Date.add(Date.utc_today(), &1))
+
+      {nil, nil, origin = %Date{}} ->
+        StreamData.integer() |> StreamData.map(&Date.add(origin, &1))
+
+      {nil, max = %Date{}, nil} ->
+        StreamData.positive_integer() |> StreamData.map(&Date.add(max, -&1))
+
+      {min = %Date{}, nil, nil} ->
+        StreamData.positive_integer() |> StreamData.map(&Date.add(min, &1))
+
+      {min = %Date{}, max = %Date{}, nil} ->
+        if Date.before?(max, min) do
+          raise ArgumentError, "max must not be before min"
+        end
+
+        diff = Date.diff(max, min)
+        StreamData.integer(0..diff) |> StreamData.map(&Date.add(min, &1))
+
+      _ ->
+        raise ArgumentError, "invalid arguments"
+    end
+  end
+
   @doc """
   Generates iolists.
 

test/stream_data_test.exs

@@ -332,6 +332,53 @@ defmodule StreamDataTest do
     end
   end
 
+  describe "date/0" do
+    property "generates any dates" do
+      check all date <- date() do
+        assert %Date{} = date
+      end
+    end
+  end
+
+  describe "date/1" do
+    property "without options, generates any dates" do
+      check all date <- date([]) do
+        assert %Date{} = date
+      end
+    end
+
+    property "with a :min option, generates dates after it" do
+      check all minimum <- date(),
+                date <- date(min: minimum) do
+        assert Date.compare(date, minimum) in [:eq, :gt]
+      end
+    end
+
+    property "with a :max option, generates dates before it" do
+      check all maximum <- date(),
+                date <- date(max: maximum) do
+        assert Date.compare(date, maximum) in [:lt, :eq]
+      end
+    end
+
+    property "with both a :min and a :max option, generates dates in-between the bounds" do
+      check all minimum <- date(),
+                maximum <- date(min: minimum),
+                date <- date(min: minimum, max: maximum) do
+        assert Enum.member?(Date.range(minimum, maximum), date)
+      end
+    end
+
+    property "with a Date.Range, generates dates in-between the bounds" do
+      check all minimum <- date(),
+                maximum <- date(min: minimum),
+                range = Date.range(minimum, maximum),
+                date <- date(range) do
+        assert Enum.member?(range, date)
+      end
+    end
+  end
+
   property "byte/0" do
     check all value <- byte() do
       assert value in 0..255