Merge branch 'master' of github.com:vic/params

Author: vic

README.md

@@ -192,10 +192,6 @@ required fields by ending them with a `!`, of course
 the bang is removed from the field definition and is
 only used to mark which fields are required by default.
 
-The [Params.data](http://hexdocs.pm/params/Params.html#data/1)
-and [Params.changes](http://hexdocs.pm/params/Params.html#changes/1) can be useful
-for obtaining an struct or map from a changeset.
-
 You can also create a module and define
 your schema or custom changesets in it:
 
@@ -220,6 +216,29 @@ defmodule MyApp.UserController do
 end
 ```
 
+The [Params.data](http://hexdocs.pm/params/Params.html#data/1)
+and [Params.to_map](http://hexdocs.pm/params/Params.html#to_map/1) can be useful
+for obtaining a struct or map from a changeset.
+
+Note that `Params.data` and `Params.to_map` have different behaviour: `data`
+returns a struct which will include all valid params. `to_map` returns a map
+that only includes the submitted keys and keys with default values:
+
+```elixir
+defmodule UserUpdateParams do
+  use Params.Schema, %{
+    name: :string,
+    age: :integer,
+    auditlog: [field: :boolean, default: true]
+  }
+end
+
+changeset = UserUpdateParams.from(%{name: "John"})
+
+Params.data(changeset) # => %UserUpdateParams{name: "John", age: nil, auditlog: true}
+Params.to_map(changeset) # => %{name: "John", auditlog: true}
+```
+
 ## API Documentation
 
 [API Documentation](https://hexdocs.pm/params/)

lib/params.ex

@@ -40,15 +40,15 @@ defmodule Params do
   @doc """
   Transforms an Ecto.Changeset into a Map with atom keys.
 
-  Recursively traverses and transforms embedded changesets and skips the _id
-  primary key field.
+  Recursively traverses and transforms embedded changesets and skips keys that
+  was not part of params given to changeset
   """
   @spec to_map(Changeset.t) :: map
-  def to_map(%Changeset{} = ch) do
-    ch
-    |> data
-    |> Map.from_struct
-    |> sanitize_map
+  def to_map(%Changeset{data: %{__struct__: module}} = ch) do
+    default = module |> schema |> defaults
+    change = changes(ch)
+
+    deep_merge(default, change)
   end
 
   @doc """
@@ -183,14 +183,49 @@ defmodule Params do
     end)
   end
 
-  defp sanitize_map(%{} = map) do
-    Enum.reduce(map, %{}, fn {k, v}, m ->
-      case {k, v} do
-        {:__meta__, _} -> m
-        {:_id, _} -> m
-        {k, %{__struct__: _} = struct} -> Map.put(m, k, struct |> Map.from_struct |> sanitize_map)
-        {k, %{} = nested} -> Map.put(m, k, sanitize_map(nested))
-        {k, v} -> Map.put(m, k, v)
+  defp deep_merge(%{} = map_1, %{} = map_2) do
+    Map.merge(map_1, map_2, &deep_merge_conflict/3)
+  end
+
+  defp deep_merge_conflict(_k, %{} = m1, %{} = m2) do
+    deep_merge(m1, m2)
+  end
+  defp deep_merge_conflict(_k, _v1, v2), do: v2
+
+  defp defaults(params, acc \\ %{}, path \\ [])
+  defp defaults([], acc, _path), do: acc
+  defp defaults(nil, _acc, _path), do: %{}
+  defp defaults([opts | rest], acc, path) when is_list(opts) do
+    defaults([Enum.into(opts, %{}) | rest], acc, path)
+  end
+  defp defaults([%{name: name, embeds: embeds} | rest], acc, path) do
+    acc = defaults(embeds, acc, [name | path])
+    defaults(rest, acc, path)
+  end
+  defp defaults([%{name: name, default: value} | rest], acc, path) do
+    funs = [name | path]
+    |> Enum.reverse
+    |> Enum.map(fn nested_name ->
+      fn :get_and_update, data, next ->
+        with {nil, inner_data} <- next.(data[nested_name] || %{}),
+             data = Map.put(data, nested_name, inner_data),
+             do: {nil, data}
+      end
+    end)
+
+    acc = put_in(acc, funs, value)
+    defaults(rest, acc, path)
+  end
+  defp defaults([%{} | rest], acc, path) do
+    defaults(rest, acc, path)
+  end
+
+  defp changes(%Changeset{} = ch) do
+    Enum.reduce(ch.changes, %{}, fn {k, v}, m ->
+      case v do
+        %Changeset{} -> Map.put(m, k, changes(v))
+        x = [%Changeset{} | _] -> Map.put(m, k, Enum.map(x, &changes/1))
+        _ -> Map.put(m, k, v)
       end
     end)
   end

test/params_test.exs

@@ -274,13 +274,11 @@ defmodule ParamsTest do
     result = Params.to_map(changeset)
 
     assert result == %{
-      foo: nil,
       bat: %{
         man: "BATMAN",
         wo: %{
           man: "BATWOMAN"
-        },
-        mo: nil
+        }
       }
     }
   end
@@ -297,13 +295,67 @@ defmodule ParamsTest do
     result = Params.to_map(changeset)
 
     assert result == %{
-      foo: nil,
       bat: %{
         man: "Bruce",
         wo: %{
           man: "BATWOMAN"
-        },
-        mo: nil
+        }
+      }
+    }
+  end
+
+  defmodule DefaultNested do
+    use Params.Schema, %{
+      a: :string,
+      b: :string,
+      c: [field: :string, default: "C"],
+      d: %{
+        e: :string,
+        f: :string,
+        g: [field: :string, default: "G"],
+      },
+      h: %{
+        i: :string,
+        j: :string,
+        k: [field: :string, default: "K"],
+      },
+      l: %{
+        m: :string
+      },
+      n: %{
+        o: %{
+          p: [field: :string, default: "P"]
+        }
+      }
+
+    }
+  end
+
+  test "to_map only returns submitted fields" do
+    result = %{
+      a: "A",
+      d: %{
+        e: "E",
+        g: "g"
+      }
+    }
+    |> DefaultNested.from
+    |> Params.to_map
+
+    assert result == %{
+      a: "A",
+      c: "C",
+      d: %{
+        e: "E",
+        g: "g"
+      },
+      h: %{
+        k: "K"
+      },
+      n: %{
+        o: %{
+          p: "P"
+        }
       }
     }
   end