Accept params in Schemecto.new/2

Author: josevalim

README.md

@@ -30,19 +30,17 @@ defmodule Example do
           %{name: :city, type: :string},
           %{name: :zip, type: :string}
         ],
-        with: &Example.validate_address/2
+        with: &Example.validate_address/1
       )}
     ]
 
-    Schemecto.new(fields)
-    |> Ecto.Changeset.cast(params, [:name, :email, :address])
+    Schemecto.new(fields, params)
     |> Ecto.Changeset.validate_required([:name, :email])
     |> Ecto.Changeset.validate_format(:email, ~r/@/)
   end
 
-  def validate_address(changeset, params) do
+  def validate_address(changeset) do
     changeset
-    |> Ecto.Changeset.cast(params, [:street, :city, :zip])
     |> Ecto.Changeset.validate_required([:street, :city])
     |> Ecto.Changeset.validate_length(:zip, is: 5)
   end

lib/schemecto.ex

@@ -6,6 +6,10 @@ defmodule Schemecto do
   @doc """
   Creates a new schemaless changeset with the given field definitions.
 
+  If parameters are given, they are cast into the changeset according
+  to fields. Parameters are a keyword list, a map of string or atom keys,
+  or nil.
+
   ## Parameters
 
     * `fields` - List of field definitions. Each field is a map with:
@@ -23,12 +27,19 @@ defmodule Schemecto do
         %{name: :age, type: :integer, default: 0, description: "Age in years"}
       ]
 
-      changeset = Schemecto.new(fields)
-      changeset = Ecto.Changeset.cast(changeset, %{name: "John", age: 30}, [:name, :age])
+      params = %{"name" => "John", "age" => 30}
+      changeset = Schemecto.new(fields, params)
 
   """
-  def new(fields) when is_list(fields) do
-    build_changeset(fields)
+  def new(fields, params \\ %{})
+      when is_list(fields) and (is_list(params) or is_map(params) or params == nil) do
+    changeset = build_changeset(fields)
+
+    if params == [] or params == %{} or params == nil do
+      changeset
+    else
+      Ecto.Changeset.cast(changeset, params, Map.keys(changeset.types))
+    end
   end
 
   @doc """
@@ -38,14 +49,13 @@ defmodule Schemecto do
 
     * `fields` - List of field definitions for the nested changeset
     * `opts` - Keyword list of options:
-      * `:with` - A 2-arity function that receives a changeset and params,
-        and returns a validated changeset (required)
+      * `:with` - A 1-arity function that receives a changeset
+        with the parameters already cast into them (if any) (required)
 
   ## Examples
 
-      def validate_address(changeset, params) do
+      def validate_address(changeset) do
         changeset
-        |> Ecto.Changeset.cast(params, [:street, :city, :zip])
         |> Ecto.Changeset.validate_required([:street, :city])
       end
 
@@ -58,21 +68,19 @@ defmodule Schemecto do
             %{name: :city, type: :string},
             %{name: :zip, type: :string}
           ],
-          with: &validate_address/2
+          with: &validate_address/1
         )}
       ]
 
-      changeset =
-        Schemecto.new(fields)
-        |> Ecto.Changeset.cast(params, [:name, :email, :address])
+      changeset = Schemecto.new(fields, params)
 
   """
   def one(fields, opts) when is_list(fields) and is_list(opts) do
     function = Keyword.fetch!(opts, :with)
 
-    if not is_function(function, 2) do
+    if not is_function(function, 1) do
       raise ArgumentError,
-            "expected :with option to be a 2-arity function, got: #{inspect(function)}"
+            "expected :with option to be a 1-arity function, got: #{inspect(function)}"
     end
 
     Ecto.ParameterizedType.init(Schemecto.One, %{
@@ -93,9 +101,8 @@ defmodule Schemecto do
 
   ## Examples
 
-      def validate_tag(changeset, params) do
+      def validate_tag(changeset) do
         changeset
-        |> Ecto.Changeset.cast(params, [:name, :color])
         |> Ecto.Changeset.validate_required([:name])
       end
 
@@ -106,21 +113,19 @@ defmodule Schemecto do
             %{name: :name, type: :string},
             %{name: :color, type: :string}
           ],
-          with: &validate_tag/2
+          with: &validate_tag/1
         )}
       ]
 
-      changeset =
-        Schemecto.new(fields)
-        |> Ecto.Changeset.cast(params, [:title, :tags])
+      changeset = Schemecto.new(fields, params)
 
   """
   def many(fields, opts) when is_list(fields) and is_list(opts) do
     function = Keyword.fetch!(opts, :with)
 
-    if not is_function(function, 2) do
+    if not is_function(function, 1) do
       raise ArgumentError,
-            "expected :with option to be a 2-arity function, got: #{inspect(function)}"
+            "expected :with option to be a 1-arity function, got: #{inspect(function)}"
     end
 
     Ecto.ParameterizedType.init(Schemecto.Many, %{
@@ -250,18 +255,13 @@ defmodule Schemecto do
   end
 
   defp type_to_json_schema({:parameterized, {Schemecto.One, %{changeset: changeset, with: fun}}}) do
-    changeset
-    |> fun.(%{})
-    |> to_json_schema()
+    changeset |> fun.() |> to_json_schema()
   end
 
   defp type_to_json_schema({:parameterized, {Schemecto.Many, %{changeset: changeset, with: fun}}}) do
     %{
       "type" => "array",
-      "items" =>
-        changeset
-        |> fun.(%{})
-        |> to_json_schema()
+      "items" => changeset |> fun.() |> to_json_schema()
     }
   end
 

lib/schemecto/many.ex

@@ -21,19 +21,25 @@ defmodule Schemecto.Many do
   def cast(nil, _params), do: {:ok, nil}
 
   def cast(values, %{changeset: changeset, with: fun}) when is_list(values) do
-    # Validate each value in the list and collect results
+    keys = Map.keys(changeset.types)
+
     {valid_values, all_errors} =
       values
       |> Enum.with_index()
       |> Enum.reduce({[], []}, fn {value, index}, {valid_acc, error_acc} ->
         if is_map(value) do
-          # Call the validation function with the changeset and the input value
-          case fun.(changeset, value) do
+          changeset =
+            if value == %{} do
+              changeset
+            else
+              Ecto.Changeset.cast(changeset, value, keys)
+            end
+
+          case fun.(changeset) do
             %Ecto.Changeset{valid?: true} = cs ->
               {[Ecto.Changeset.apply_changes(cs) | valid_acc], error_acc}
 
             %Ecto.Changeset{valid?: false, errors: errors} ->
-              # Add index information to the errors
               indexed_errors = [{index, errors} | error_acc]
               {valid_acc, indexed_errors}
           end

lib/schemecto/one.ex

@@ -14,8 +14,14 @@ defmodule Schemecto.One do
   def cast(nil, _params), do: {:ok, nil}
 
   def cast(value, %{changeset: changeset, with: fun}) when is_map(value) do
-    # Call the validation function with the changeset and the input value
-    case fun.(changeset, value) do
+    changeset =
+      if value == %{} do
+        changeset
+      else
+        Ecto.Changeset.cast(changeset, value, Map.keys(changeset.types))
+      end
+
+    case fun.(changeset) do
       %Ecto.Changeset{valid?: true} = cs ->
         {:ok, Ecto.Changeset.apply_changes(cs)}