ree_lib 1.0.85 → 1.0.87

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

@@ -43,7 +43,13 @@ class ReeMapper::MapperFactory
           raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
-        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+        field = ReeMapper::Field.new(
+          type,
+          field_name,
+          optional: optional,
+          **opts,
+          location: caller_locations&.first&.to_s
+        )
 
         return field unless field_name
 
@@ -90,7 +96,8 @@ class ReeMapper::MapperFactory
 
         if blk
           subject = ReeMapper::Field.new(
-            hash_from_blk(dto: dto, &blk)
+            hash_from_blk(dto: dto, &blk),
+            location: caller_locations&.first&.to_s,
           )
         end
 
@@ -105,7 +112,13 @@ class ReeMapper::MapperFactory
         type = ReeMapper::Mapper.build(@mapper.strategies, wrapper.new(subject))
         type.name = :#{name}
 
-        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+        field = ReeMapper::Field.new(
+          type,
+          field_name,
+          optional: optional,
+          **opts,
+          location: caller_locations&.first&.to_s,
+        )
 
         return field unless field_name
 
@@ -141,7 +154,7 @@ class ReeMapper::MapperFactory
 
     type = hash_from_blk(dto: dto, &blk)
 
-    field = ReeMapper::Field.new(type, field_name, **opts)
+    field = ReeMapper::Field.new(type, field_name, **opts, location: caller_locations&.first&.to_s)
 
     @mapper.add_field(field)
   end

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

@@ -1,2 +1,8 @@
 class ReeMapper::AbstractType
+  private
+
+  def truncate(str, limit = 180)
+    @trancator ||= ReeString::Truncate.new
+    @trancator.call(str, limit)
+  end
 end

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

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 class ReeMapper::Any < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def serialize(value, name:, location: nil)
     value
   end
 
-  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def cast(value, name:, location: nil)
     value
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def db_dump(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def db_dump(value, name:, location: nil)
     value
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
-  def db_load(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Any)
+  def db_load(value, name:, location: nil)
     value
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(TrueClass) || value.is_a?(FalseClass)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a boolean"
+      raise ReeMapper::TypeError.new("`#{name}` should be a boolean, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Bool).throws(ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::CoercionError)
+  def cast(value, name:, location: nil)
     if TRUE_CAST_VALUES.include?(value)
       true
     elsif FALSE_CAST_VALUES.include?(value)
       false
     else
-      raise ReeMapper::CoercionError, "`#{name}` is invalid boolean"
+      raise ReeMapper::CoercionError.new("`#{name}` is invalid boolean, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Bool).throws(ReeMapper::CoercionError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == Date
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a date"
+      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def cast(value, name:, location: 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, "`#{name}` is invalid date"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid date, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a date"
+      raise ReeMapper::TypeError.new("`#{name}` should be a date, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Date).throws(ReeMapper::TypeError, ReeMapper::CoercionError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == DateTime
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a datetime"
+      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: 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, "`#{name}` is invalid datetime"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid datetime, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a datetime"
+      raise ReeMapper::TypeError.new("`#{name}` should be a datetime, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => DateTime).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   end
 end

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

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
 class ReeMapper::Float < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(Float)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a float"
+      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Numeric)
       value.to_f
     elsif value.is_a?(String)
       begin
         Float(value)
       rescue ArgumentError => e
-        raise ReeMapper::CoercionError, "`#{name}` is invalid float"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid float, got `#{truncate(value.inspect)}`", location)
       end
     elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
       value.to_f
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a float"
+      raise ReeMapper::TypeError.new("`#{name}` should be a float, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Integer).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a? Integer
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an integer"
+      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]]=> Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Integer)
       value
     elsif value.is_a?(String)
-      value = Integer(value, exception: false)
-      if value.nil?
-        raise ReeMapper::CoercionError, "`#{name}` is invalid integer"
+      coerced_value = Integer(value, exception: false)
+      if coerced_value.nil?
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid integer, got `#{truncate(value.inspect)}`", location)
       end
-      value
+      coerced_value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an integer"
+      raise ReeMapper::TypeError.new("`#{name}` should be an integer, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Integer).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   end
 end

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

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
 class ReeMapper::Rational < ReeMapper::AbstractType
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a?(Rational)
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a rational"
+      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
     if value.is_a?(Rational)
       value
     elsif value.is_a?(String)
       begin
         Rational(value)
       rescue ArgumentError, ZeroDivisionError => e
-        raise ReeMapper::CoercionError, "`#{name}` is invalid rational"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid rational, got `#{truncate(value.inspect)}`", location)
       end
     elsif value.is_a?(Numeric)
       Rational(value)
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a rational"
+      raise ReeMapper::TypeError.new("`#{name}` should be a rational, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String)
-  def db_dump(value, name:, role: nil)
-    serialize(value, name: name, role: role).to_s
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location).to_s
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational)
-  def db_load(value, name:, role: nil)
-    cast(value, name: name, role: role)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Rational)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.is_a? String
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a string"
+      raise ReeMapper::TypeError.new("`#{name}` should be a string, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def cast(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => String).throws(ReeMapper::TypeError)
+  def db_load(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   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[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::TypeError)
+  def serialize(value, name:, location: nil)
     if value.class == Time
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a time"
+      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, location: 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, "`#{name}` is invalid time"
+        raise ReeMapper::CoercionError.new("`#{name}` is invalid time, got `#{truncate(value.inspect)}`", location)
       end
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a time"
+      raise ReeMapper::TypeError.new("`#{name}` should be a time, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, location: nil)
+    serialize(value, name: name, location: location)
   end
 
-  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)
+  contract(Any, Kwargs[name: String, location: Nilor[String]] => Time).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def db_load(value, name:, location: nil)
+    cast(value, name: name, location: location)
   end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/abstract_wrapper.rb

@@ -5,4 +5,11 @@ class ReeMapper::AbstractWrapper
   def initialize(field)
     @subject = field
   end
+
+  private
+
+  def truncate(str, limit = 180)
+    @trancator ||= ReeString::Truncate.new
+    @trancator.call(str, limit)
+  end
 end

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

@@ -1,67 +1,119 @@
 # frozen_string_literal: true
 
 class ReeMapper::Array < ReeMapper::AbstractWrapper
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => Array
+  ).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil, fields_filters: [], location: nil)
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && subject.null
           _1
         else
-          subject.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
+          subject.type.serialize(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter],
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => Array
+  ).throws(ReeMapper::TypeError)
+  def cast(value, name:, role: nil, fields_filters: [], location: nil)
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && subject.null
           _1
         else
-          subject.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
+          subject.type.cast(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter],
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => Array
+  ).throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && subject.null
           _1
         else
-          subject.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
+          subject.type.db_dump(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter],
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
-    .throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [])
+  contract(
+    Any,
+    Kwargs[
+      name: String, 
+      role: Nilor[Symbol, ArrayOf[Symbol]],
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
+    ] => Array
+  ).throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && subject.null
           _1
         else
-          subject.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
+          subject.type.db_load(
+            _1, 
+            name: "#{name}[#{_2}]", 
+            role: role, 
+            fields_filters: fields_filters + [subject.fields_filter], 
+            location: subject.location,
+          )
         end
       }
     else
-      raise ReeMapper::TypeError, "`#{name}` should be an array"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
   end
-end
+end