feat: implement TypedHashCoercer (#110)

lib/typed/coercion/coercer_registry.rb

@@ -21,7 +21,8 @@ class CoercerRegistry
           DateCoercer,
           EnumCoercer,
           StructCoercer,
-          TypedArrayCoercer
+          TypedArrayCoercer,
+          TypedHashCoercer
         ],
         Registry
       )

lib/typed/coercion/typed_hash_coercer.rb

@@ -0,0 +1,50 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class TypedHashCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Hash[T.untyped, T.untyped]} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        type.is_a?(T::Types::TypedHash)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must be a T::Hash.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Value must be a Hash.")) unless value.is_a?(Hash)
+
+        return Success.new(value) if type.recursively_valid?(value)
+
+        coerced_hash = {}
+        errors = []
+
+        value.each do |k, v|
+          key_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.first), value: k)
+          value_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.last), value: v)
+
+          if key_result.success? && value_result.success?
+            coerced_hash[key_result.payload] = value_result.payload
+          else
+            if key_result.failure?
+              errors << key_result.error
+            end
+
+            if value_result.failure?
+              errors << value_result.error
+            end
+          end
+        end
+
+        if errors.empty?
+          Success.new(coerced_hash)
+        else
+          Failure.new(CoercionError.new(errors.map(&:message).join(" | ")))
+        end
+      end
+    end
+  end
+end

test/support/structs/country.rb

@@ -7,6 +7,7 @@ class Country < T::Struct
 
   const :name, String
   const :cities, T::Array[City]
+  const :national_items, T::Hash[Symbol, String], default: {}
 end
 
-US_COUNTRY = Country.new(name: "US", cities: [NEW_YORK_CITY, DC_CITY])
+US_COUNTRY = Country.new(name: "US", cities: [NEW_YORK_CITY, DC_CITY], national_items: {bird: "bald eagle", anthem: "The Star-Spangled Banner"})

test/typed/coercion/struct_coercer_test.rb

@@ -28,7 +28,7 @@ def test_when_struct_of_correct_type_given_returns_success
   end
 
   def test_when_struct_of_incorrect_type_given_returns_failure
-    result = @coercer.coerce(type: @type, value: Country.new(name: "Canada", cities: []))
+    result = @coercer.coerce(type: @type, value: Country.new(name: "Canada", cities: [], national_items: {}))
 
     assert_failure(result)
     assert_error(Typed::Coercion::CoercionError.new("Value of type 'Country' cannot be coerced to Job Struct."), result)

test/typed/coercion/typed_hash_coercer_test.rb

@@ -0,0 +1,59 @@
+# typed: true
+
+require "test_helper"
+
+class TypedHashCoercerTest < Minitest::Test
+  def setup
+    @coercer = Typed::Coercion::TypedHashCoercer.new
+    @type = T::Utils.coerce(T::Hash[String, Integer])
+  end
+
+  def test_used_for_type_works
+    assert(@coercer.used_for_type?(T::Utils.coerce(T::Hash[String, Integer])))
+    assert(@coercer.used_for_type?(T::Utils.coerce(T::Hash[String, String])))
+    assert(@coercer.used_for_type?(T::Utils.coerce(Hash)))
+    refute(@coercer.used_for_type?(T::Utils.coerce(Integer)))
+  end
+
+  def test_when_non_hash_field_given_returns_failure
+    result = @coercer.coerce(type: T::Utils.coerce(Integer), value: {"test" => 1})
+
+    assert_failure(result)
+    assert_error(Typed::Coercion::CoercionError.new("Field type must be a T::Hash."), result)
+  end
+
+  def test_when_non_hash_value_given_returns_failure
+    result = @coercer.coerce(type: @type, value: "testing")
+
+    assert_failure(result)
+    assert_error(Typed::Coercion::CoercionError.new("Value must be a Hash."), result)
+  end
+
+  def test_when_already_of_type_returns_success
+    result = @coercer.coerce(type: @type, value: {"test" => 1})
+
+    assert_success(result)
+    assert_payload({"test" => 1}, result)
+  end
+
+  def test_when_coercable_hash_can_be_coerced_returns_success
+    result = @coercer.coerce(type: @type, value: {"test" => "1", 1 => 2})
+
+    assert_success(result)
+    assert_payload({"test" => 1, "1" => 2}, result)
+  end
+
+  def test_when_untyped_hash_returns_success
+    result = @coercer.coerce(type: T::Utils.coerce(Hash), value: {"test" => 1})
+
+    assert_success(result)
+    assert_payload({"test" => 1}, result)
+  end
+
+  def test_when_array_cannot_be_coerced_returns_failure
+    result = @coercer.coerce(type: @type, value: {"test" => "test"})
+
+    assert_failure(result)
+    assert_error(Typed::Coercion::CoercionError.new("'test' cannot be coerced into Integer."), result)
+  end
+end

test/typed/hash_serializer_test.rb

@@ -1,5 +1,7 @@
 # typed: true
 
+require "test_helper"
+
 class HashSerializerTest < Minitest::Test
   class StructWithBooleanDefaultSetToTrue < T::Struct
     include ActsAsComparable
@@ -49,18 +51,18 @@ def test_with_boolean_it_can_serialize
     assert_payload({name: "New York", capital: false}, result)
   end
 
-  def test_with_array_it_can_serialize
+  def test_with_array_and_hash_it_can_serialize
     result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country)).serialize(US_COUNTRY)
 
     assert_success(result)
-    assert_payload({name: "US", cities: [NEW_YORK_CITY, DC_CITY]}, result)
+    assert_payload({name: "US", cities: [NEW_YORK_CITY, DC_CITY], national_items: {bird: "bald eagle", anthem: "The Star-Spangled Banner"}}, result)
   end
 
   def test_with_array_it_can_deep_serialize
     result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country), should_serialize_values: true).serialize(US_COUNTRY)
 
     assert_success(result)
-    assert_payload({name: "US", cities: [{name: "New York", capital: false}, {name: "DC", capital: true}]}, result)
+    assert_payload({name: "US", cities: [{name: "New York", capital: false}, {name: "DC", capital: true}], national_items: {bird: "bald eagle", anthem: "The Star-Spangled Banner"}}, result)
   end
 
   def test_when_struct_given_is_not_of_target_type_returns_failure
@@ -101,14 +103,14 @@ def test_with_boolean_it_can_deserialize
   end
 
   def test_with_array_it_can_deserialize
-    result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize({name: "US", cities: [NEW_YORK_CITY, DC_CITY]})
+    result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize({name: "US", cities: [NEW_YORK_CITY, DC_CITY], national_items: {bird: "bald eagle", anthem: "The Star-Spangled Banner"}})
 
     assert_success(result)
     assert_payload(US_COUNTRY, result)
   end
 
   def test_with_array_it_can_deep_deserialize
-    result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize({name: "US", cities: [{name: "New York", capital: false}, {name: "DC", capital: true}]})
+    result = Typed::HashSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize({name: "US", cities: [{name: "New York", capital: false}, {name: "DC", capital: true}], national_items: {bird: "bald eagle", anthem: "The Star-Spangled Banner"}})
 
     assert_success(result)
     assert_payload(US_COUNTRY, result)

test/typed/json_serializer_test.rb

@@ -34,7 +34,7 @@ def test_with_array_it_can_serialize
     result = Typed::JSONSerializer.new(schema: Typed::Schema.from_struct(Country)).serialize(US_COUNTRY)
 
     assert_success(result)
-    assert_payload('{"name":"US","cities":[{"name":"New York","capital":false},{"name":"DC","capital":true}]}', result)
+    assert_payload('{"name":"US","cities":[{"name":"New York","capital":false},{"name":"DC","capital":true}],"national_items":{"bird":"bald eagle","anthem":"The Star-Spangled Banner"}}', result)
   end
 
   def test_will_use_inline_serializers
@@ -61,7 +61,7 @@ def test_with_boolean_it_can_deserialize
   end
 
   def test_with_array_it_can_deep_deserialize
-    result = Typed::JSONSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize('{"name":"US","cities":[{"name":"New York","capital":false},{"name":"DC","capital":true}]}')
+    result = Typed::JSONSerializer.new(schema: Typed::Schema.from_struct(Country)).deserialize('{"name":"US","cities":[{"name":"New York","capital":false},{"name":"DC","capital":true}],"national_items":{"bird":"bald eagle","anthem":"The Star-Spangled Banner"}}')
 
     assert_success(result)
     assert_payload(US_COUNTRY, result)