Merge pull request #95 from belousovAV/21-expose-mapper-location

Expose failed mapper location

ree_lib/lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_array.rb

@@ -8,20 +8,22 @@ class ReeDao::PgArray < ReeMapper::AbstractWrapper
     Kwargs[
       name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
     ] => Or[Sequel::Postgres::PGArray, String]
   )
-  def db_dump(value, name:, role: nil, fields_filters: [])
+  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
     if !value.is_a?(Array)
-      raise ReeMapper::TypeError, "`#{name}` should be an array, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
     end
 
     value = value.map.with_index do |el, index|
       subject.type.db_dump(
         el,
         name: "#{name}[#{index}]",
         role: role,
-        fields_filters: fields_filters + [subject.fields_filter]
+        fields_filters: fields_filters + [subject.fields_filter],
+        location: subject.location,
       )
     end
 
@@ -37,20 +39,22 @@ def db_dump(value, name:, role: nil, fields_filters: [])
     Kwargs[
       name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [])
+  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
     if !value.is_a?(Sequel::Postgres::PGArray)
-      raise ReeMapper::TypeError, "`#{name}` should be a Sequel::Postgres::PGArray, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a Sequel::Postgres::PGArray, got `#{truncate(value.inspect)}`", location)
     end
 
     value.map.with_index do |val, index|
       subject.type.db_load(
         val,
         name: "#{name}[#{index}]",
         role: role,
-        fields_filters: fields_filters + [subject.fields_filter]
+        fields_filters: fields_filters + [subject.fields_filter],
+        location: subject.location,
       )
     end
   end

ree_lib/lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_jsonb.rb

@@ -8,7 +8,8 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
     Kwargs[
       name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
     ] => Or[
       Sequel::Postgres::JSONBHash,
       Sequel::Postgres::JSONBArray,
@@ -20,18 +21,19 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
       Sequel::Postgres::JSONBNull
     ]
   ).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil, fields_filters: [])
+  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
     value = subject.type.db_dump(
       value,
       name: name,
       role: role,
-      fields_filters: fields_filters + [subject.fields_filter]
+      fields_filters: fields_filters + [subject.fields_filter],
+      location: subject.location,
     )
 
     begin
       Sequel.pg_jsonb_wrap(value)
     rescue Sequel::Error
-      raise ReeMapper::TypeError, "`#{name}` should be an jsonb primitive, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be an jsonb primitive, got `#{truncate(value.inspect)}`", location)
     end
   end
 
@@ -40,7 +42,8 @@ def db_dump(value, name:, role: nil, fields_filters: [])
     Kwargs[
       name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter]
+      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
+      location: Nilor[String],
     ] => Or[
       Hash,
       Array,
@@ -52,7 +55,7 @@ def db_dump(value, name:, role: nil, fields_filters: [])
       Rational,
     ]
   ).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [])
+  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
     value = case value
     when Sequel::Postgres::JSONBHash
       ReeObject::ToHash.new.call(value.to_h)
@@ -61,14 +64,15 @@ def db_load(value, name:, role: nil, fields_filters: [])
     when Numeric, String, TrueClass, FalseClass, NilClass
       value
     else
-      raise ReeMapper::TypeError, "`#{name}` should be a Sequel::Postgres::JSONB, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::TypeError.new("`#{name}` should be a Sequel::Postgres::JSONB, got `#{truncate(value.inspect)}`", location)
     end
 
     subject.type.db_load(
       value,
       name: name,
       role: role,
-      fields_filters: fields_filters + [subject.fields_filter]
+      fields_filters: fields_filters + [subject.fields_filter],
+      location: subject.location,
     )
   end
 end

ree_lib/lib/ree_lib/packages/ree_dao/spec/ree_dao/wrappers/pg_array_spec.rb

@@ -46,7 +46,7 @@
     it {
       expect {
         mapper.db_dump({ tags: 1 })
-      }.to raise_error(ReeMapper::TypeError, "`tags` should be an array, got `1`")
+      }.to raise_error(ReeMapper::TypeError, /`tags` should be an array, got `1`/)
     }
   end
 
@@ -66,7 +66,7 @@
         mapper.db_load({
           tags: 1
         })
-      }.to raise_error(ReeMapper::TypeError, "`tags` should be a Sequel::Postgres::PGArray, got `1`")
+      }.to raise_error(ReeMapper::TypeError, /`tags` should be a Sequel::Postgres::PGArray, got `1`/)
     }
   end
-end
+end

ree_lib/lib/ree_lib/packages/ree_dao/spec/ree_dao/wrappers/pg_jsonb_spec.rb

@@ -55,14 +55,14 @@
     it {
       expect {
         mapper.db_dump({ numbers: ['1'] })
-      }.to raise_error(ReeMapper::TypeError, "`numbers[0]` should be an integer, got `\"1\"`")
+      }.to raise_error(ReeMapper::TypeError, /`numbers\[0\]` should be an integer, got `\"1\"`/)
     }
 
     it {
       object = Object.new
       expect {
         mapper.db_dump({ any: object })
-      }.to raise_error(ReeMapper::TypeError, "`any` should be an jsonb primitive, got `#{object.inspect}`")
+      }.to raise_error(ReeMapper::TypeError, /`any` should be an jsonb primitive, got `#{object.inspect}`/)
     }
   end
 
@@ -88,14 +88,14 @@
     it {
       expect {
         mapper.db_load({ numbers: Sequel::Postgres::JSONBArray.new([1.1]) })
-      }.to raise_error(ReeMapper::TypeError, "`numbers[0]` should be an integer, got `1.1`")
+      }.to raise_error(ReeMapper::TypeError, /`numbers\[0\]` should be an integer, got `1.1`/)
     }
 
     it {
       object = Object.new
       expect {
         mapper.db_load({ numbers: object })
-      }.to raise_error(ReeMapper::TypeError, "`numbers` should be a Sequel::Postgres::JSONB, got `#{object.inspect}`")
+      }.to raise_error(ReeMapper::TypeError, /`numbers` should be a Sequel::Postgres::JSONB, got `#{object.inspect}`/)
     }
   end
 end

ree_lib/lib/ree_lib/packages/ree_enum/package/ree_enum/base_enum_mapper.rb

@@ -12,25 +12,25 @@ def initialize(enum)
     ReeEnum::Value,
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => Or[Integer, String]
   )
-  def db_dump(value, name:, role: nil)
+  def db_dump(value, name:, location: nil)
     value.mapped_value
   end
 
   contract(
     Or[Integer, String],
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => ReeEnum::Value
   ).throws(ReeMapper::CoercionError)
-  def db_load(value, name:, role: nil)
+  def db_load(value, name:, location: nil)
     enum_val = @enum.get_values.by_mapped_value(value)
 
     if !enum_val
-      raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
     end
 
     enum_val

ree_lib/lib/ree_lib/packages/ree_enum/package/ree_enum/integer_value_enum_mapper.rb

@@ -6,21 +6,21 @@ class ReeEnum::IntegerValueEnumMapper < ReeEnum::BaseEnumMapper
     ReeEnum::Value,
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => Integer
   )
-  def serialize(value, name:, role: nil)
+  def serialize(value, name:, location: nil)
     value.value
   end
 
   contract(
     Any,
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => ReeEnum::Value
   ).throws(ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  def cast(value, name:, location: nil)
     enum_value = case value
     when Integer
       @enum.get_values.by_value(value)
@@ -34,7 +34,7 @@ def cast(value, name:, role: nil)
     end
 
     if enum_value.nil?
-      raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
     end
 
     enum_value

ree_lib/lib/ree_lib/packages/ree_enum/package/ree_enum/string_value_enum_mapper.rb

@@ -6,21 +6,21 @@ class ReeEnum::StringValueEnumMapper < ReeEnum::BaseEnumMapper
     ReeEnum::Value,
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => String
   )
-  def serialize(value, name:, role: nil)
+  def serialize(value, name:, location: nil)
     value.value
   end
 
   contract(
     Any,
     Kwargs[
       name: String,
-      role: Nilor[Symbol, ArrayOf[Symbol]]
+      location: Nilor[String],
     ] => ReeEnum::Value
   ).throws(ReeMapper::CoercionError)
-  def cast(value, name:, role: nil)
+  def cast(value, name:, location: nil)
     enum_value = case value
     when String
       @enum.get_values.by_value(value)
@@ -29,7 +29,7 @@ def cast(value, name:, role: nil)
     end
 
     if enum_value.nil?
-      raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`"
+      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
     end
 
     enum_value

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

@@ -152,15 +152,15 @@ def call(value)
         type: 'invalid',
         number: 0,
       })
-    }.to raise_error(ReeMapper::CoercionError, '`type` should be one of ["account"], got `"invalid"`')
+    }.to raise_error(ReeMapper::CoercionError, /`type` should be one of \["account"\], got `"invalid"`/)
 
     expect {
       mapper.db_load({
         state: 'first',
         type: 'invalid',
         number: 0,
       })
-    }.to raise_error(ReeMapper::CoercionError, '`type` should be one of ["account"], got `"invalid"`')
+    }.to raise_error(ReeMapper::CoercionError, /`type` should be one of \["account"\], got `"invalid"`/)
 
     expect(
       mapper.cast({
@@ -242,4 +242,4 @@ def call(value)
       swagger_definition_fetcher.call(TestReeEnum::ContentTypes.type_for_mapper, -> {})
     )
   }
-end
+end

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

@@ -14,6 +14,7 @@ module ReeMapper
 
   require_relative 'ree_mapper/types/abstract_type'
   require_relative 'ree_mapper/errors/error'
+  require_relative 'ree_mapper/errors/error_with_location'
   require_relative 'ree_mapper/errors/coercion_error'
   require_relative 'ree_mapper/errors/type_error'
   require_relative 'ree_mapper/errors/unsupported_type_error'

ree_lib/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/coercion_error.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-class ReeMapper::CoercionError < ReeMapper::Error
+class ReeMapper::CoercionError < ReeMapper::ErrorWithLocation
 end

ree_lib/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/error_with_location.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ReeMapper::ErrorWithLocation < ReeMapper::Error
+  attr_reader :location
+
+  def initialize(message, location = nil)
+    if message.is_a?(String) && location && ENV["RUBY_ENV"] == "test"
+      message = "#{message}, located at #{location}"
+    end
+
+    super(message)
+    @location = location
+  end
+
+  def full_message(...)
+    msg = super
+    return msg if location.nil?
+
+    idx = msg.index(/\).*\n/)
+    return msg if idx.nil?
+    return msg if ENV["RUBY_ENV"] == "test"
+
+    msg.insert(idx + 1, ", located at #{location}")
+  end
+end

ree_lib/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/type_error.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-class ReeMapper::TypeError < ReeMapper::Error
+class ReeMapper::TypeError < ReeMapper::ErrorWithLocation
 end

ree_lib/lib/ree_lib/packages/ree_mapper/package/ree_mapper/field.rb

@@ -3,7 +3,7 @@
 class ReeMapper::Field
   attr_reader :type, :name, :from, :doc, :optional, :null, :roles, :default,
               :name_as_str, :name_as_instance_var_name, :from_as_str,
-              :fields_filter
+              :fields_filter, :location
 
   NO_DEFAULT = Object.new.freeze
 
@@ -18,11 +18,12 @@ class ReeMapper::Field
       role:     Nilor[ArrayOf[Symbol], Symbol],
       default:  Any,
       only:     Nilor[ReeMapper::FilterFieldsContract],
-      except:   Nilor[ReeMapper::FilterFieldsContract]
+      except:   Nilor[ReeMapper::FilterFieldsContract],
+      location: Nilor[String],
     ] => Any
   ).throws(ArgumentError)
-  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT, 
-                 only: nil, except: nil)
+  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT,
+                 only: nil, except: nil, location: nil)
     @type     = type
     @name     = name
     @from     = from || name
@@ -38,6 +39,13 @@ def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: fal
     @name_as_instance_var_name = :"@#{@name}"
     @from_as_str               = @from.to_s
 
+    @location = location
+    if @location
+      @location = @location
+        .sub(Ree.root_dir, ".")
+        .sub(/:in.+/, "")
+    end
+
     raise ArgumentError, 'required fields do not support defaults' if has_default? && !optional
   end