Date generators (#218)

This is a reimplementation of the date generators by @Qqwy in #161. As such, it
is a (partial) implementation for #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 <w-m@wmcode.nl>
Co-authored-by: Andrea Leopardi <an.leopardi@gmail.com>

Author: 3 people

lib/stream_data.ex

@@ -2094,6 +2094,90 @@ defmodule StreamData do
     end)
   end
 
+  @doc """
+  Generates dates according to the given `options` or `date_range`.
+
+  ## Options
+
+    * `:origin` - (`t:Date.t/0`) if present, generated values will shrink towards this date.
+      Cannot be combined with `:min` or `:max`.
+
+    * `:min` - (`t:Date.t/0`) if present, only dates *after* this date will be
+      generated. Values will shrink towards this date.
+
+    * `:max` - (`t:Date.t/0`) 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, `:origin` will default to the current date (that is,
+  `Date.utc_today/0`).
+
+  ## `t:Date.Range.t/0`
+
+  Alternatively a `t:Date.Range.t/0` 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 `m: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 \\ [origin: Date.utc_today()])
+
+  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, """
+          expected :max to be after or equal to :min, got:
+
+            * min: #{inspect(min)}
+            * max: #{inspect(max)}
+          """
+        end
+
+        diff = Date.diff(max, min)
+        StreamData.integer(0..diff) |> StreamData.map(&Date.add(min, &1))
+
+      _ ->
+        raise ArgumentError, """
+        :origin cannot be specified together with either :min or :max, got:
+
+          * origin: #{inspect(origin)}
+          * min: #{inspect(min)}
+          * max: #{inspect(max)}
+        """
+    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