Coercions => Casters

Author: solnic

lib/drops/casters.ex

@@ -0,0 +1,10 @@
+defmodule Drops.Casters do
+  def cast(:string, :integer, value), do: String.to_integer(value)
+
+  def cast(:string, :float, value) do
+    {float, _} = Float.parse(value)
+    float
+  end
+
+  def cast(:integer, :string, value), do: to_string(value)
+end

lib/drops/coercions.ex

@@ -1,7 +1,7 @@
 defmodule Drops.Contract do
   defmacro __using__(_opts) do
     quote do
-      alias Drops.{Coercions, Predicates}
+      alias Drops.{Casters, Predicates}
       alias Drops.Contract.Schema
       alias Drops.Contract.Schema.Key
 
@@ -70,14 +70,14 @@ defmodule Drops.Contract do
       def step(
             data,
             {:validate,
-             %{type: {:coerce, {{input_type, input_predicates}, output_type}}} = key}
+             %{type: {:cast, {{input_type, input_predicates}, output_type}}} = key}
           ) do
         value = get_in(data, key.path)
 
         case apply_predicates(value, input_predicates, path: key.path) do
           {:ok, _} ->
             validate(
-              Coercions.coerce(input_type, output_type, value),
+              Casters.cast(input_type, output_type, value),
               key.predicates,
               path: key.path
             )

lib/drops/contract.ex

@@ -8,7 +8,7 @@ defmodule Drops.Contract.DSL do
   end
 
   def from(type) do
-    {:coerce, type}
+    {:cast, type}
   end
 
   def type([list: members]) when is_map(members) do
@@ -35,7 +35,7 @@ defmodule Drops.Contract.DSL do
     {:type, {type, predicates}}
   end
 
-  def type({:coerce, input_type}, output_type) do
-    {:coerce, {type(input_type), type(output_type)}}
+  def type({:cast, input_type}, output_type) do
+    {:cast, {type(input_type), type(output_type)}}
   end
 end

lib/drops/contract/dsl.ex

@@ -38,13 +38,13 @@ defmodule Drops.Contract.Schema.Key do
     Enum.map(spec, &infer_type(&1, opts))
   end
 
-  defp infer_type({:coerce, {input_type, output_type}}, opts) do
-    {:coerce,
+  defp infer_type({:cast, {input_type, output_type}}, opts) do
+    {:cast,
      {{infer_type(input_type, opts), infer_predicates(input_type, opts)},
       infer_type(output_type, opts)}}
   end
 
-  defp infer_predicates({:coerce, {_input_type, output_type}}, opts) do
+  defp infer_predicates({:cast, {_input_type, output_type}}, opts) do
     infer_predicates(output_type, opts)
   end
 

lib/drops/contract/schema/key.ex

@@ -1,4 +1,4 @@
-defmodule Drops.CoercionTest do
+defmodule Drops.CastersTest do
   use Drops.ContractCase
 
   describe ":integer => :string" do