Merge branch 'fix-schema-with-alt'

Author: keathley

lib/norm.ex

@@ -450,7 +450,7 @@ defmodule Norm do
       ...> )
       %{age: 31, name: "chris"}
   """
-  def schema(input) do
+  def schema(input) when is_map(input) do
     Schema.build(input)
   end
 

lib/norm/schema.ex

@@ -40,12 +40,15 @@ defmodule Norm.Schema do
       {:error, [error(path, input, "not a map")]}
     end
 
-    def conform(%{specs: specs, struct: struct}, input, path) when not is_nil(struct) do
-      if Map.get(input, :__struct__) == struct do
-        check_specs(specs, input, path)
+    def conform(%{specs: specs, struct: target}, input, path) when not is_nil(target) do
+      # Ensure we're mapping the correct struct
+      if Map.get(input, :__struct__) == target do
+        with {:ok, conformed} <- check_specs(specs, input, path) do
+          {:ok, struct(target, conformed)}
+        end
       else
         short_name =
-          struct
+          target
           |> Atom.to_string
           |> String.replace("Elixir.", "")
 
@@ -71,18 +74,22 @@ defmodule Norm.Schema do
         (actual_keys -- expected_keys)
         |> Enum.map(fn key -> error(path ++ [key], input, ":unexpected") end)
 
-      errors =
+      results =
         specs
         |> Enum.map(& check_spec(&1, input, path))
-        |> Enum.filter(fn {_, {result, _}} -> result == :error end)
-        |> Enum.flat_map(fn {_, {_, errors}} -> errors end)
+        |> Enum.reduce(%{ok: [], error: []}, fn {key, {result, conformed}}, acc ->
+          Map.put(acc, result, acc[result] ++ [{key, conformed}])
+        end)
 
-      errors = errors ++ unexpected_key_errors
+      errors =
+        results.error
+        |> Enum.flat_map(fn {_, error} -> error end)
+        |> Enum.concat(unexpected_key_errors)
 
       if Enum.any?(errors) do
         {:error, errors}
       else
-        {:ok, input}
+        {:ok, Enum.into(results.ok, %{})}
       end
     end
 

lib/norm/spec/alt.ex

@@ -10,7 +10,7 @@ defmodule Norm.Spec.Alt do
       result =
         specs
         |> Enum.map(fn {name, spec} ->
-          case Conformable.conform(spec, input, [name | path]) do
+          case Conformable.conform(spec, input, path ++ [name]) do
             {:ok, i} ->
               {:ok, {name, i}}
 

test/norm/schema_test.exs

@@ -99,6 +99,19 @@ defmodule Norm.SchemaTest do
     ]
   end
 
+  test "can have nested alts" do
+    s = schema(%{a: alt(bool: spec(is_boolean()), int: spec(is_integer()))})
+
+    assert %{a: {:bool, true}} == conform!(%{a: true}, s)
+    assert %{a: {:bool, false}} == conform!(%{a: false}, s)
+    assert %{a: {:int, 123}} == conform!(%{a: 123}, s)
+    assert {:error, errors} = conform(%{a: "test"}, s)
+    assert errors == [
+      "val: \"test\" fails: is_boolean() in: :a/:bool",
+      "val: \"test\" fails: is_integer() in: :a/:int"
+    ]
+  end
+
   test "breaks if the input has more keys then we've specified" do
     user_schema = schema(%{
       name: spec(is_binary())