ree_lib 1.0.15 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a15d911dfb9f1955ac1829941bdb259c1423867dabb407221a1d55232dde3e50
-  data.tar.gz: b76069a3bd3760240ea5232de630f7ff4b372a767b5098ed9a91d7e224f73f7c
+  metadata.gz: 6160f2952d35b381ccb85c48139a84187d975ec72297a13ba240656398610bb1
+  data.tar.gz: d8aa690997677ddf8ae5bf2f219b00e5d7cad9bb0dcea89905f496bca2389072
 SHA512:
-  metadata.gz: 39b0b379f130624a30c254bc569d3cf8a3942974d036b4bebfc37d1a9c2087917644d61e946b7471b97102b832c43c951d8c209d1f64d9d2d7198b18082f0eed
-  data.tar.gz: 4628fd0c89f2a3670dfb7895decc76aae447057e5d7b0b3591c4942ca1be910b50653d41089589a29a48d794c703921232b4776266721982b30fd78881515ade
+  metadata.gz: 666753ee3a5ff1057d1d8b371d84b9a2510b0d89ce4a259ded6bdf0466f61f0009c18505f70bee8e92e65058cc1d460510cf9121ee3980845c3fd05936aa1f1f
+  data.tar.gz: d543b184c95e126f6623e339dcfe17d6966aa19b50c19378701f250d45f599b4734f2bf0c0a194effb4af0bd194b88d244060076362e7e569215b1470cee0275

data/Gemfile.lock

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

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

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/array_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Array do
+RSpec.describe 'ReeMapper::Array' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -18,16 +18,25 @@ RSpec.describe ReeMapper::Array do
   let(:mapper) {
     mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
       array :tags, each: integer
+      array? :ary_of_ary, each: array(each: integer)
     }
   }
 
   describe '#serialize' do
     it {
-      expect(mapper.serialize({ tags: [1, 2] })).to eq({ tags: [1, 2] })
+      expect(mapper.serialize({ tags: [1, 2], ary_of_ary: [[1]] })).to eq({ tags: [1, 2], ary_of_ary: [[1]] })
     }
 
     it {
-      expect { mapper.serialize({ tags: 1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ tags: 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array")
+    }
+
+    it {
+      expect { mapper.serialize({tags: [1], ary_of_ary: ["1"] }) }.to raise_error(ReeMapper::TypeError, "`ary_of_ary[0]` should be an array")
+    }
+
+    it {
+      expect { mapper.serialize({tags: [1], ary_of_ary: [[1, "1"]] }) }.to raise_error(ReeMapper::TypeError, "`ary_of_ary[0][1]` should be an integer")
     }
   end
 
@@ -37,7 +46,7 @@ RSpec.describe ReeMapper::Array do
     }
 
     it {
-      expect { mapper.cast({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array")
     }
   end
 
@@ -47,7 +56,7 @@ RSpec.describe ReeMapper::Array do
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ tags: 1 })) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump(OpenStruct.new({ tags: 1 })) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array")
     }
   end
 
@@ -57,7 +66,7 @@ RSpec.describe ReeMapper::Array do
     }
 
     it {
-      expect { mapper.db_load({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array")
     }
   end
 

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/bool_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Bool do
+RSpec.describe 'ReeMapper::Bool' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -31,11 +31,11 @@ RSpec.describe ReeMapper::Bool do
     }
 
     it {
-      expect { mapper.serialize({ bool: 'true' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ bool: 'true' }) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean")
     }
 
     it {
-      expect { mapper.serialize({ bool: 1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ bool: 1 }) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean")
     }
   end
 
@@ -81,11 +81,11 @@ RSpec.describe ReeMapper::Bool do
     }
 
     it {
-      expect { mapper.cast({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean")
     }
 
     it {
-      expect { mapper.cast({ 'bool' => Object.new }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ 'bool' => Object.new }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean")
     }
   end
 
@@ -99,11 +99,11 @@ RSpec.describe ReeMapper::Bool do
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ bool: 'true' })) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump(OpenStruct.new({ bool: 'true' })) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean")
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ bool: 1 })) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump(OpenStruct.new({ bool: 1 })) }.to raise_error(ReeMapper::TypeError, "`bool` should be a boolean")
     }
   end
 
@@ -149,11 +149,11 @@ RSpec.describe ReeMapper::Bool do
     }
 
     it {
-      expect { mapper.db_load({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ 'bool' => 'right' }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean")
     }
 
     it {
-      expect { mapper.db_load({ 'bool' => Object.new }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ 'bool' => Object.new }) }.to raise_error(ReeMapper::CoercionError, "`bool` is invalid boolean")
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/date_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Date do
+RSpec.describe 'ReeMapper::Date' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -27,19 +27,19 @@ RSpec.describe ReeMapper::Date do
     }
 
     it {
-      expect { mapper.serialize({ date: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.serialize({ date: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.serialize({ date: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.serialize({ date: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date: Object.new }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
   end
 
@@ -61,7 +61,7 @@ RSpec.describe ReeMapper::Date do
     }
 
     it {
-      expect { mapper.cast({ 'date' => 'no date' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ 'date' => 'no date' }) }.to raise_error(ReeMapper::CoercionError, "`date` is invalid date")
     }
   end
 
@@ -83,7 +83,7 @@ RSpec.describe ReeMapper::Date do
     }
 
     it {
-      expect { mapper.db_load({ 'date' => 'no date' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ 'date' => 'no date' }) }.to raise_error(ReeMapper::CoercionError, "`date` is invalid date")
     }
   end
 
@@ -93,19 +93,19 @@ RSpec.describe ReeMapper::Date do
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date: Object.new }) }.to raise_error(ReeMapper::TypeError, "`date` should be a date")
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/date_time_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::DateTime do
+RSpec.describe 'ReeMapper::DateTime' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -27,23 +27,23 @@ RSpec.describe ReeMapper::DateTime do
     }
 
     it {
-      expect { mapper.serialize({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.serialize({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.serialize({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.serialize({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.serialize({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
   end
 
@@ -65,15 +65,15 @@ RSpec.describe ReeMapper::DateTime do
     }
 
     it {
-      expect { mapper.cast({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.cast({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.cast({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`date_time` is invalid datetime")
     }
   end
 
@@ -83,23 +83,23 @@ RSpec.describe ReeMapper::DateTime do
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump OpenStruct.new({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
   end
 
@@ -121,15 +121,15 @@ RSpec.describe ReeMapper::DateTime do
     }
 
     it {
-      expect { mapper.db_load({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_load({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime")
     }
 
     it {
-      expect { mapper.db_load({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`date_time` is invalid datetime")
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/float_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Float do
+RSpec.describe 'ReeMapper::Float' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -31,15 +31,15 @@ RSpec.describe ReeMapper::Float do
     }
 
     it {
-      expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
 
     it {
-      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
 
     it {
-      expect { mapper.cast({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ float: Object.new }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
   end
 
@@ -49,15 +49,15 @@ RSpec.describe ReeMapper::Float do
     }
 
     it {
-      expect { mapper.serialize({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
 
     it {
-      expect { mapper.serialize({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
 
     it {
-      expect { mapper.serialize({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ float: Object.new }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
   end
 
@@ -67,15 +67,15 @@ RSpec.describe ReeMapper::Float do
     }
 
     it {
-      expect { mapper.db_dump({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
 
     it {
-      expect { mapper.db_dump({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
 
     it {
-      expect { mapper.db_dump({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ float: Object.new }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
   end
 
@@ -89,19 +89,19 @@ RSpec.describe ReeMapper::Float do
     }
 
     it {
-      expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
 
     it {
-      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
 
     it {
-      expect { mapper.db_load({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
 
     it {
-      expect { mapper.db_load({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ float: Object.new }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float")
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/hash_spec.rb

@@ -27,7 +27,11 @@ RSpec.describe 'Mapper Hash' do
     }
 
     it {
-      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, 'Missing required field `x`')
+      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, 'Missing required field `x` for `point`')
+    }
+
+    it {
+      expect { mapper.cast({ point: { x: 1, y: 'not integer' } }) }.to raise_error(ReeMapper::CoercionError, '`point[y]` is invalid integer')
     }
   end
 

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/integer_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Integer do
+RSpec.describe 'ReeMapper::Integer' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -31,15 +31,15 @@ RSpec.describe ReeMapper::Integer do
     }
 
     it {
-      expect { mapper.cast({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer')
     }
 
     it {
-      expect { mapper.cast({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer')
     }
 
     it {
-      expect { mapper.cast({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
   end
 
@@ -49,19 +49,19 @@ RSpec.describe ReeMapper::Integer do
     }
 
     it {
-      expect { mapper.serialize({ number: '1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ number: '1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.serialize({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.serialize({ number: '1b' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.serialize({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
   end
 
@@ -71,19 +71,19 @@ RSpec.describe ReeMapper::Integer do
     }
 
     it {
-      expect { mapper.db_dump({ number: '1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ number: '1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.db_dump({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.db_dump({ number: '1b' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
-      expect { mapper.db_dump({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
   end
 
@@ -97,15 +97,15 @@ RSpec.describe ReeMapper::Integer do
     }
 
     it {
-      expect { mapper.db_load({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer')
     }
 
     it {
-      expect { mapper.db_load({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer')
     }
 
     it {
-      expect { mapper.db_load({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/string_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::String do
+RSpec.describe 'ReeMapper::String' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -24,40 +24,40 @@ RSpec.describe ReeMapper::String do
   describe '#serialize' do
     it { expect(mapper.serialize({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.serialize({ str: nil }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.serialize({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.serialize({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.serialize({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.serialize({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.serialize({ str: Object.new }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
   end
 
   describe '#cast' do
     it { expect(mapper.cast({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.cast({ str: nil }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.cast({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.cast({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.cast({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.cast({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.cast({ str: Object.new }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
   end
 
   describe '#db_dump' do
     it { expect(mapper.db_dump({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.db_dump({ str: nil }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_dump({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.db_dump({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_dump({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.db_dump({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_dump({ str: Object.new }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
   end
 
   describe '#db_load' do
     it { expect(mapper.db_load({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.db_load({ str: nil }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_load({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.db_load({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_load({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
 
-    it { expect { mapper.db_load({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+    it { expect { mapper.db_load({ str: Object.new }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string") }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/time_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ReeMapper::Time do
+RSpec.describe 'ReeMapper::Time' do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
@@ -27,23 +27,23 @@ RSpec.describe ReeMapper::Time do
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.serialize({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.serialize({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.serialize({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
   end
 
@@ -65,15 +65,15 @@ RSpec.describe ReeMapper::Time do
     }
 
     it {
-      expect { mapper.cast({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.cast({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.cast({ time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.cast({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.cast({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`time` is invalid time")
     }
   end
 
@@ -83,23 +83,23 @@ RSpec.describe ReeMapper::Time do
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_dump({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_dump({ time: Time.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ time: Time.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_dump({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_dump({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_dump({ time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
   end
 
@@ -121,15 +121,15 @@ RSpec.describe ReeMapper::Time do
     }
 
     it {
-      expect { mapper.db_load({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_load({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+      expect { mapper.db_load({ time: Object.new }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time")
     }
 
     it {
-      expect { mapper.db_load({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+      expect { mapper.db_load({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`time` is invalid time")
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/type_options_spec.rb

@@ -170,7 +170,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     }
 
     it {
-      expect { mapper.cast({ number: nil }) }.to raise_error(ReeMapper::TypeError, 'should be an integer')
+      expect { mapper.cast({ number: nil }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
     }
 
     it {
@@ -183,7 +183,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
       let(:mapper) { mapper_factory.call.use(:cast) { integer? :number, default: :not_number } }
 
       it {
-        expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, 'should be an integer')
+        expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer')
       }
     end
   end

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.15"
+  VERSION = "1.0.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.15
+  version: 1.0.17
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree