ree_lib 1.0.16 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9005df5ff7af1e3f311ab2126f137560568d8e2c42bfb7da28b9a2e179675b4a
-  data.tar.gz: b0c9cd050d90ad8a2f66a738bfd3487c27d9561a367ce3a7d204c5ba6bf8d1cf
+  metadata.gz: 64fb753de0bc41d6229e85e080565a7eb3cabce192a6cd89a3e07deb0add91f7
+  data.tar.gz: b40c7415b989ea2ce5dd9c46b0a986a4672f8c91764b7ba9dc0604c3ab451e5c
 SHA512:
-  metadata.gz: 8816a34c2a7b69a9a82d61c5fc2f69055216cfe6ff02241c78850b9940fe37d09c1df87b49e0f137342f84ac304f6e3b0dfc4075af92f29a86fb4e77a92a981c
-  data.tar.gz: 9bd5bce19e5803ae000b362efcad7721802bc1c816dc1af26eefb80fc04c893b4b8c505471b033456c4b500a84b76de9b1ea319869adfab945c75ae2c52c675c
+  metadata.gz: f426600c0940004ac34514221aeac311edacd1e40221dcc030990350aa379fc43444a37995d2c1f3933929ecc4d611514e8127a66d6590518cb33f9a6011bc23
+  data.tar.gz: dfc8728bf7b03c7826ba050ca1e992ef700236a79bf34116ccf30e66d2d8850cfb2e81161387aa512b731ba61c7a59bf7857fbce7e913d6e56d365636266fc9a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.16)
+    ree_lib (1.0.18)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)

data/lib/ree_lib/packages/ree_enum/package/ree_enum/dsl.rb

@@ -34,25 +34,27 @@ module ReeEnum
             contract(
               ReeEnum::Value,
               Kwargs[
+                name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
               ] => String
             )
-            def serialize(value, role: nil)
+            def serialize(value, name:, role: nil)
               value.to_s
             end
 
             contract(
               Any,
               Kwargs[
+                name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
               ] => ReeEnum::Value
             ).throws(ReeMapper::CoercionError)
-            def cast(value, role: nil)
+            def cast(value, name:, role: nil)
               if value.is_a?(String)
                 enum_val = @enum.values.all.detect { |v| v.to_s == value }
 
                 if !enum_val
-                  raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+                  raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
                 end
 
                 enum_val
@@ -60,33 +62,35 @@ module ReeEnum
                 enum_val = @enum.values.all.detect { |v| v.to_i == value }
 
                 if !enum_val
-                  raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+                  raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
                 end
 
                 enum_val
               else
-                raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+                raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
               end
             end
 
             contract(
               ReeEnum::Value,
               Kwargs[
+                name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
               ] => Integer
             )
-            def db_dump(value, role: nil)
+            def db_dump(value, name:, role: nil)
               value.to_i
             end
 
             contract(
               Integer,
               Kwargs[
+                name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
               ] => ReeEnum::Value
             ).throws(ReeMapper::TypeError)
-            def db_load(value, role: nil)
-              cast(value, role: role)
+            def db_load(value, name:, role: nil)
+              cast(value, name: name, role: role)
             end
           end
 

data/lib/ree_lib/packages/ree_enum/spec/ree_enum/dsl_spec.rb

@@ -112,7 +112,7 @@ RSpec.describe ReeEnum::DSL do
         state: 'first',
         type: 'invalid',
       })
-      }.to raise_error(ReeMapper::CoercionError, 'should be one of ["account"]')
+      }.to raise_error(ReeMapper::CoercionError, '`type` should be one of ["account"]')
 
     expect(
       mapper.cast({

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper.rb

@@ -19,32 +19,33 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, role: nil)
-              @type.#{method}(obj, role: role)
+            def #{method}(obj, name: nil, role: nil)
+              @type.#{method}(obj, name: name, role: role)
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, role: nil)
+            def #{method}(obj, name: nil, role: nil)
               @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
                 next unless field.has_role?(role)
+                nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
 
                 if @#{method}_strategy.has_value?(obj, field)
                   value = @#{method}_strategy.get_value(obj, field)
                   unless value.nil? && field.null
-                    value = field.type.public_send(:#{method}, value, role: role)
+                    value = field.type.#{method}(value, name: nested_name, role: role)
                   end
                   @#{method}_strategy.assign_value(acc, field, value)
                 elsif field.optional || @#{method}_strategy.always_optional
                   if field.has_default?
                     value = field.default
                     unless value.nil? && field.null
-                      value = field.type.public_send(:#{method}, value, role: role)
+                      value = field.type.#{method}(value, name: nested_name, role: role)
                     end
                     @#{method}_strategy.assign_value(acc, field, value)
                   end
                 else
-                  raise ReeMapper::TypeError, "Missing required field `\#{field.from}`"
+                  raise ReeMapper::TypeError, "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`"
                 end
               end
             end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/abstract_type.rb

@@ -1,17 +1,17 @@
 class ReeMapper::AbstractType
-  def serialize(value, role: nil)
+  def serialize(value, name:, role: nil)
     raise NotImplementedError
   end
 
-  def cast(value, role: nil)
+  def cast(value, name:, role: nil)
     raise NotImplementedError
   end
 
-  def db_dump(value, role: nil)
+  def db_dump(value, name:, role: nil)
     raise NotImplementedError
   end
 
-  def db_load(value, role: nil)
+  def db_load(value, name:, role: nil)
     raise NotImplementedError
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/array.rb

@@ -8,63 +8,63 @@ class ReeMapper::Array < ReeMapper::AbstractType
     @of = of
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.is_a?(Array)
-      value.map {
+      value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.serialize(_1, role: role)
+          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role)
         end
       }
     else
-      raise ReeMapper::TypeError, 'should be an array'
+      raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
     if value.is_a?(Array)
-      value.map {
+      value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.cast(_1, role: role)
+          of.type.cast(_1, name: "#{name}[#{_2}]", role: role)
         end
       }
     else
-      raise ReeMapper::TypeError, "should be an array"
+      raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
     if value.is_a?(Array)
-      value.map {
+      value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_dump(_1, role: role)
+          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role)
         end
       }
     else
-      raise ReeMapper::TypeError, 'should be an array'
+      raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_load(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
     if value.is_a?(Array)
-      value.map {
+      value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_load(_1, role: role)
+          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role)
         end
       }
     else
-      raise ReeMapper::TypeError, "should be an array"
+      raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/bool.rb

@@ -4,33 +4,33 @@ class ReeMapper::Bool < ReeMapper::AbstractType
   TRUE_CAST_VALUES = ['1', 'true', 'on', 1, true].freeze
   FALSE_CAST_VALUES = ['0', 'false', 'off', 0, false].freeze
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.is_a?(TrueClass) || value.is_a?(FalseClass)
       value
     else
-      raise ReeMapper::TypeError, 'should be a boolean'
+      raise ReeMapper::TypeError, "`#{name}` should be a boolean"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
+  def cast(value, name:, role: nil)
     if TRUE_CAST_VALUES.include?(value)
       true
     elsif FALSE_CAST_VALUES.include?(value)
       false
     else
-      raise ReeMapper::CoercionError, "should be a boolean"
+      raise ReeMapper::CoercionError, "`#{name}` is invalid boolean"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date.rb

@@ -3,17 +3,17 @@
 require 'date'
 
 class ReeMapper::Date < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.class == Date
       value
     else
-      raise ReeMapper::TypeError, "should be a date"
+      raise ReeMapper::TypeError, "`#{name}` should be a date"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def cast(value, name:, role: nil)
     if value.class == Date
       value
     elsif value.class == DateTime || value.class == Time
@@ -22,20 +22,20 @@ class ReeMapper::Date < ReeMapper::AbstractType
       begin
         Date.parse(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "is invalid date"
+        raise ReeMapper::CoercionError, "`#{name}` is invalid date"
       end
     else
-      raise ReeMapper::TypeError, "should be a date"
+      raise ReeMapper::TypeError, "`#{name}` should be a date"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date_time.rb

@@ -3,17 +3,17 @@
 require 'date'
 
 class ReeMapper::DateTime < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.class == DateTime
       value
     else
-      raise ReeMapper::TypeError, "should be a datetime"
+      raise ReeMapper::TypeError, "`#{name}` should be a datetime"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
     if value.class == DateTime
       value
     elsif value.class == Time
@@ -22,20 +22,20 @@ class ReeMapper::DateTime < ReeMapper::AbstractType
       begin
         ReeDatetime::InDefaultTimeZone.new.call(DateTime.parse(value))
       rescue ArgumentError
-        raise ReeMapper::CoercionError, "is invalid datetime"
+        raise ReeMapper::CoercionError, "`#{name}` is invalid datetime"
       end
     else
-      raise ReeMapper::TypeError, "should be a datetime"
+      raise ReeMapper::TypeError, "`#{name}` should be a datetime"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/float.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
 class ReeMapper::Float < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.is_a?(Float)
       value
     else
-      raise ReeMapper::TypeError, 'should be a float'
+      raise ReeMapper::TypeError, "`#{name}` should be a float"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
     if value.is_a?(Float)
       value
     elsif value.is_a?(String)
       begin
         Float(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "is invalid float"
+        raise ReeMapper::CoercionError, "`#{name}` is invalid float"
       end
     else
-      raise ReeMapper::TypeError, "should be a float"
+      raise ReeMapper::TypeError, "`#{name}` should be a float"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/integer.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
 class ReeMapper::Integer < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.is_a? Integer
       value
     else
-      raise ReeMapper::TypeError, 'should be an integer'
+      raise ReeMapper::TypeError, "`#{name}` should be an integer"
     end
   end
 
-  contract(Any , Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]]=> Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, role: nil)
+  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]]=> Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
     if value.is_a?(Integer)
       value
     elsif value.is_a?(String)
       begin
         Integer(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "is invalid integer"
+        raise ReeMapper::CoercionError, "`#{name}` is invalid integer"
       end
     else
-      raise ReeMapper::TypeError, "should be an integer"
+      raise ReeMapper::TypeError, "`#{name}` should be an integer"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/string.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
 class ReeMapper::String < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.is_a? String
       value
     else
-      raise ReeMapper::TypeError, 'should be a string'
+      raise ReeMapper::TypeError, "`#{name}` should be a string"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def cast(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def db_load(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/time.rb

@@ -3,17 +3,17 @@
 require 'time'
 
 class ReeMapper::Time < ReeMapper::AbstractType
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
-  def serialize(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
     if value.class == Time
       value
     else
-      raise ReeMapper::TypeError, "should be a time"
+      raise ReeMapper::TypeError, "`#{name}` should be a time"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
     if value.class == Time
       value
     elsif value.class == DateTime
@@ -22,20 +22,20 @@ class ReeMapper::Time < ReeMapper::AbstractType
       begin
         Time.parse(value)
       rescue ArgumentError
-        raise ReeMapper::CoercionError, "is invalid time"
+        raise ReeMapper::CoercionError, "`#{name}` is invalid time"
       end
     else
-      raise ReeMapper::TypeError, "should be a time"
+      raise ReeMapper::TypeError, "`#{name}` should be a time"
     end
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
-  def db_dump(value, role: nil)
-    serialize(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role)
   end
 
-  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def db_load(value, role: nil)
-    cast(value, role: role)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
   end
 end