Merge branch 'improve-collection-specifications'

Author: keathley

lib/norm.ex

@@ -548,7 +548,19 @@ defmodule Norm do
       iex> conform!([:a, :b, :c], coll_of(spec(is_atom())))
       [:a, :b, :c]
   """
+  @default_opts [
+    distinct: false,
+    min_count: 0,
+    max_count: :infinity,
+    into: [],
+  ]
+
   def coll_of(spec, opts \\ []) do
+    opts = Keyword.merge(@default_opts, opts)
+    if opts[:min_count] > opts[:max_count] do
+      raise ArgumentError, "min_count cannot be larger than max_count"
+    end
+
     Collection.new(spec, opts)
   end
 
@@ -561,8 +573,8 @@ defmodule Norm do
       %{a: 1, b: 2, c: 3}
   """
   def map_of(kpred, vpred, opts \\ []) do
-    opts = Keyword.merge(opts, kind: :map)
-    Collection.new({kpred, vpred}, opts)
+    opts = Keyword.merge(opts, into: %{})
+    coll_of({kpred, vpred}, opts)
   end
 
   # @doc ~S"""

lib/norm/conformer.ex

@@ -47,6 +47,7 @@ defmodule Norm.Conformer do
   defp format_val(val) when is_map(val), do: inspect(val)
   defp format_val({:index, i}), do: "[#{i}]"
   defp format_val(t) when is_tuple(t), do: "#{inspect(t)}"
+  defp format_val(l) when is_list(l), do: "#{inspect(l)}"
   defp format_val(msg), do: "#{msg}"
 
   defprotocol Conformable do

lib/norm/spec/collection.ex

@@ -1,7 +1,7 @@
 defmodule Norm.Spec.Collection do
   @moduledoc false
 
-  defstruct spec: nil, opts: [kind: :list]
+  defstruct spec: nil, opts: []
 
   def new(spec, opts) do
     %__MODULE__{spec: spec, opts: opts}
@@ -12,24 +12,85 @@ defmodule Norm.Spec.Collection do
     alias Norm.Conformer.Conformable
 
     def conform(%{spec: spec, opts: opts}, input, path) do
-      results =
-        input
-        |> Enum.map(&Conformable.conform(spec, &1, path))
-        |> Conformer.group_results()
+      with :ok <- check_distinct(input, path, opts),
+           :ok <- check_counts(input, path, opts) do
+        results =
+          input
+          |> Enum.with_index()
+          |> Enum.map(fn {elem, i} -> Conformable.conform(spec, elem, path ++ [i]) end)
+          |> Conformer.group_results()
 
-      if Enum.any?(results.error) do
-        {:error, results.error}
-      else
-        {:ok, convert(results.ok, opts[:kind])}
+        if Enum.any?(results.error) do
+          {:error, results.error}
+        else
+          {:ok, convert(results.ok, opts[:into])}
+        end
       end
     end
 
-    defp convert(results, :map) do
-      Enum.into(results, %{})
+    defp convert(results, type) do
+      Enum.into(results, type)
+    end
+
+    defp check_counts(input, path, opts) do
+      min = opts[:min_count]
+      max = opts[:max_count]
+      length = Enum.count(input)
+
+      cond do
+        min > length ->
+          {:error, [Conformer.error(path, input, "min_count: #{min}")]}
+
+        max < length ->
+          {:error, [Conformer.error(path, input, "max_count: #{max}")]}
+
+        true ->
+          :ok
+      end
     end
 
-    defp convert(results, _) do
-      results
+    defp check_distinct(input, path, opts) do
+      if opts[:distinct] do
+        if Enum.uniq(input) == input do
+          :ok
+        else
+          {:error, [Conformer.error(path, input, "distinct?")]}
+        end
+      else
+        :ok
+      end
+    end
+  end
+
+  if Code.ensure_loaded?(StreamData) do
+    defimpl Norm.Generatable do
+      def gen(%{spec: spec, opts: opts}) do
+        with {:ok, g} <- Norm.Generatable.gen(spec) do
+          generator =
+            g
+            |> sequence(opts)
+            |> into(opts)
+
+          {:ok, generator}
+        end
+      end
+
+      def sequence(g, opts) do
+        min = opts[:min_count]
+        max = opts[:max_count]
+
+        if opts[:distinct] do
+          StreamData.uniq_list_of(g, [min_length: min, max_length: max])
+        else
+          StreamData.list_of(g, [min_length: min, max_length: max])
+        end
+      end
+
+      def into(list_gen, opts) do
+        StreamData.bind(list_gen, fn list ->
+          StreamData.constant(Enum.into(list, opts[:into]))
+        end)
+      end
     end
   end
 end

test/norm_test.exs

@@ -160,5 +160,99 @@ defmodule NormTest do
       spec = map_of(spec(is_integer()), spec(is_atom()))
       assert %{1 => :foo, 2 => :bar} == conform!(%{1 => :foo, 2 => :bar}, spec)
     end
+
+    property "can be generated" do
+      check all m <- gen(map_of(spec(is_integer()), spec(is_atom()))) do
+        assert is_map(m)
+        for k <- Map.keys(m), do: assert is_integer(k)
+        for v <- Map.values(m), do: assert is_atom(v)
+      end
+    end
+  end
+
+  describe "coll_of/2" do
+    test "can spec collections" do
+      spec = coll_of(spec(is_atom()))
+      assert [:foo, :bar, :baz] == conform!([:foo, :bar, :baz], spec)
+      assert {:error, errors} = conform([:foo, 1, "test"], spec)
+      assert errors == [
+        "val: 1 in: 1 fails: is_atom()",
+        "val: \"test\" in: 2 fails: is_atom()"
+      ]
+    end
+
+    test "conforming returns the conformed values" do
+      spec = coll_of(schema(%{name: spec(is_binary())}))
+      input = [
+        %{name: "chris", age: 31, email: "c@keathley.io"},
+        %{name: "andra", age: 30}
+      ]
+
+      assert [%{name: "chris"}, %{name: "andra"}] == conform!(input, spec)
+
+      input = [
+        %{age: 31, email: "c@keathley.io"},
+        %{name: :andra, age: 30},
+      ]
+      assert {:error, errors} = conform(input, spec)
+      assert errors == [
+        "val: %{age: 31, email: \"c@keathley.io\"} in: 0/:name fails: :required",
+        "val: :andra in: 1/:name fails: is_binary()"
+      ]
+    end
+
+    test "can enforce distinct elements" do
+      spec = coll_of(spec(is_integer()), distinct: true)
+
+      assert {:error, errors} = conform([1,1,1], spec)
+      assert errors == ["val: [1, 1, 1] fails: distinct?"]
+    end
+
+    test "can enforce min and max counts" do
+      spec = coll_of(spec(is_integer()), min_count: 2, max_count: 3)
+      assert [1, 1] == conform!([1, 1], spec)
+      assert [1, 1, 1] == conform!([1, 1, 1], spec)
+      assert {:error, ["val: [1] fails: min_count: 2"]} == conform([1], spec)
+      assert {:error, ["val: [1, 1, 1, 1] fails: max_count: 3"]} == conform([1, 1, 1, 1], spec)
+
+      spec = coll_of(spec(is_integer()), min_count: 3, max_count: 3)
+      assert [1, 1, 1] == conform!([1, 1, 1], spec)
+    end
+
+    test "min count must be less than or equal to max count" do
+      assert_raise ArgumentError, fn ->
+        coll_of(spec(is_integer()), min_count: 3, max_count: 2)
+      end
+    end
+
+    test "can be used to spec keyword lists" do
+      opts = one_of([
+        {:name, spec(is_atom())},
+        {:timeout, spec(is_integer())}
+      ])
+      spec = coll_of(opts)
+      list = [name: :storage, timeout: 3_000]
+
+      assert list == conform!(list, spec)
+      assert {:error, _errors} = conform([{:foo, :bar} | list], spec)
+
+      assert list == conform!(list, coll_of(opts, [min_count: 2, distinct: true]))
+      assert {:error, errors} = conform([], coll_of(opts, [min_count: 2, distinct: true]))
+    end
+
+    property "can be generated" do
+      check all is <- gen(coll_of(spec(is_integer()))) do
+        for i <- is, do: assert is_integer(i)
+      end
+
+      check all is <- gen(coll_of(spec(is_integer()), min_count: 3, max_count: 6)) do
+        length = Enum.count(is)
+        assert 3 <= length and length <= 6
+      end
+
+      check all is <- gen(coll_of(spec(is_integer()), distinct: true)) do
+        assert Enum.uniq(is) == is
+      end
+    end
   end
 end