ree_lib 1.0.93 → 1.0.95

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

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

@@ -4,116 +4,124 @@ class ReeMapper::Array < ReeMapper::AbstractWrapper
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => 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],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def serialize(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.serialize(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => 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],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def cast(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.cast(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => 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],
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def db_dump(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.db_dump(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String, 
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => 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], 
-            location: subject.location,
-          )
-        end
-      }
-    else
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+  def db_load(value, role: nil, fields_filters: nil)
+    if !value.is_a?(Array)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value.map.with_index do |item, idx|
+      next nil if item.nil? && subject.null
+
+      subject.type.db_load(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.prepend_field_name(idx.to_s)
+      e.location ||= subject.location
+      raise e
     end
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/benchmarks/mapper_benchmark_spec.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 require 'benchmark'
 
+no_contracts = Ree::Contracts.no_contracts?
+Ree.disable_contracts
+
 package_require "ree_mapper"
 
 RSpec.xdescribe 'Mapper Benchmark' do
@@ -25,7 +28,44 @@ RSpec.xdescribe 'Mapper Benchmark' do
     obj = { my_field: { my_field: { my_field: 1 } } }
 
     _benchmark_res = Benchmark.bmbm do |x|
-      x.report('cast') { 1000.times { mapper.cast(obj) } }
+      x.report('cast') { 100000.times { mapper.cast(obj) } }
     end
   end
+
+  xit do
+    Ree.disable_contracts
+    require "ruby-prof"
+    package_require "ree_mapper"
+
+    mapper = ReeMapper::BuildMapperFactory.new.call(
+      strategies: [
+        ReeMapper::BuildMapperStrategy.new.call(method: :cast, dto: Hash),
+      ]
+    ).call.use(:cast) do
+      hash :my_field do
+        hash :my_field do
+          integer :my_field
+        end
+      end
+    end
+
+    obj = { my_field: { my_field: { my_field: 1 } } }
+
+    result = RubyProf::Profile.profile do
+      mapper.cast(obj)
+    end
+
+    RubyProf::FlatPrinter.new(result).print(STDOUT)
+  end
 end
+
+if !no_contracts
+  Ree.enable_contracts
+end
+
+# version main
+# cast   0.369019   0.001180   0.370199 (  0.370515)
+# cast   0.356124   0.001060   0.357184 (  0.357502)
+# version 1.0.93
+# cast   0.791664   0.004125   0.795789 (  0.796938)
+# cast   0.782544   0.016745   0.799289 (  0.799759)

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_factory_spec.rb

@@ -82,12 +82,17 @@ RSpec.describe ReeMapper::MapperFactory do
   describe '.register_wrapper' do
     let(:round_wrapper) {
       Class.new(ReeMapper::AbstractWrapper) do
-        def serialize(value, name:, location: nil, **opts)
+        def serialize(value, **opts)
           if !value.is_a?(Numeric)
-            raise ReeMapper::TypeError.new("`#{name}` should be a number, got `#{truncate(value.inspect)}`", location)
+            raise ReeMapper::TypeError.new("should be a number, got `#{truncate(value.inspect)}`")
           end
 
-          subject.type.serialize(value.round, name: name, location: subject.location, **opts)
+          begin
+            subject.type.serialize(value.round, **opts)
+          rescue ReeMapper::ErrorWithLocation => e
+            e.location ||= subject.location
+            raise e
+          end
         end
       end
     }
@@ -102,12 +107,18 @@ RSpec.describe ReeMapper::MapperFactory do
 
     it 'allow to register caster and serializer with the same name' do
       caster_round_wrapper = Class.new(ReeMapper::AbstractWrapper) do
-        def cast(value, name:, location: nil, **opts)
-          value = subject.type.cast(value, name: name, location: subject.location, **opts)
+        def cast(value, **opts)
+          value = begin
+            subject.type.cast(value, **opts)
+          rescue ReeMapper::ErrorWithLocation => e
+            e.location ||= subject.location
+            raise e
+          end
 
           if !value.is_a?(Numeric)
-            raise ReeMapper::TypeError.new("`#{name}` should be a number, got `#{truncate(value.inspect)}`", location)
+            raise ReeMapper::TypeError.new("should be a number, got `#{truncate(value.inspect)}`")
           end
+
           value.round
         end
       end

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

@@ -27,7 +27,7 @@ RSpec.describe 'Mapper Hash' do
     }
 
     it {
-      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, /Missing required field `x` for `point`/)
+      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, /`point\[x\]` is missing required field/)
     }
 
     it {

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

@@ -116,37 +116,18 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
       }
     end
 
-    context 'with invalid only' do
+    context "with empty nested filter" do
       let(:mapper) {
         mapper_factory.call.use(:cast) {
-          point :point
-        }
-      }
-
-      it {
-        expect {
-          mapper.cast({}, only: {})
-        }.to raise_error(
-          ReeMapper::ArgumentError,
-          "Invalid `only` format"
-        )
-      }
-    end
-
-    context 'with invalid except' do
-      let(:mapper) {
-        mapper_factory.call.use(:cast) {
-          point :point
+          hash :point_wrap do
+            point :point
+          end
         }
       }
 
       it {
-        expect {
-          mapper.cast({}, except: {})
-        }.to raise_error(
-          ReeMapper::ArgumentError,
-          "Invalid `except` format"
-        )
+        expect(mapper.cast({ point_wrap: { point: { x: 1, y: 1, z: 1 } } }, only: [point_wrap: [:point]]))
+          .to eq({ point_wrap: { point: { x: 1, y: 1, z: 1 } } })
       }
     end
   end
@@ -193,7 +174,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     }
 
     it {
-      expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, /Missing required field `number` for `root`/)
+      expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, /`number` is missing required field/)
     }
 
     it {

data/lib/ree_lib/packages/ree_roda/spec/ree_roda/services/build_swagger_from_routes_spec.rb

@@ -17,19 +17,22 @@ RSpec.describe :build_swagger_from_routes do
       package do
         depends_on :ree_actions
         depends_on :ree_dao
+        depends_on :ree_errors
       end
     end
 
     class ReeRodaTestSwagger::Cmd
       include ReeActions::DSL
 
-      action :cmd
+      action :cmd do
+        link :invalid_param_error, from: :ree_errors
+      end
 
       ActionCaster = build_mapper.use(:cast) do
         integer :id
       end
 
-      InvalidErr = ReeErrors::ValidationError.build(:invalid, "invalid")
+      InvalidErr = invalid_param_error(:invalid, "invalid")
 
       contract(Any, Any => Any).throws(InvalidErr)
       def call(access, attrs)
@@ -71,7 +74,7 @@ RSpec.describe :build_swagger_from_routes do
   it {
     swagger = build_swagger_from_routes(routes, "test", "test", "1.0", "https://example.com")
 
-    expect(swagger.dig(:paths, "/api/actions", :post, :responses, 422, :description))
-      .to eq("- type: **validation**, code: **invalid**, message: **invalid**")
+    expect(swagger.dig(:paths, "/api/actions", :post, :responses, 400, :description))
+      .to eq("- type: **invalid_param**, code: **invalid**, message: **invalid param**")
   }
 end

data/lib/ree_lib/packages/ree_roda/spec/ree_roda/services/locales/en.yml

@@ -1,2 +1,4 @@
 en:
-  invalid: "invalid"
+  ree_roda_test_swagger:
+    errors:
+      invalid: "invalid param"

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/deconstantize.rb

@@ -7,7 +7,7 @@ class ReeString::Deconstantize
 
   doc(<<~DOC)
     Removes the rightmost segment from the constant expression in the string.
-    
+
       deconstantize('Net::HTTP')   # => "Net"
       deconstantize('::Net::HTTP') # => "::Net"
       deconstantize('String')      # => ""

data/lib/ree_lib/packages/ree_swagger/Package.schema.json

@@ -7,6 +7,9 @@
     "ree_swagger"
   ],
   "depends_on": [
+    {
+      "name": "ree_array"
+    },
     {
       "name": "ree_dto"
     },

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/functions/build_parameters.rb

@@ -6,6 +6,7 @@ class ReeSwagger::BuildParameters
   fn :build_parameters do
     link :get_caster_definition
     link :build_request_body_schema
+    link :wrap, from: :ree_array
   end
 
   ObjectPathParamError = Class.new(StandardError)
@@ -36,7 +37,7 @@ class ReeSwagger::BuildParameters
         name: field.name_as_str,
         in: is_path_param ? 'path' : 'query',
         required: is_path_param || !field.optional,
-        schema: build_request_body_schema(field.type, [], [field.fields_filter]) || {}
+        schema: build_request_body_schema(field.type, [], wrap(field.fields_filter)) || {}
       }
 
       schema[:style] = 'deepObject' if field.type.type.nil?

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/functions/build_request_body_schema.rb

@@ -10,9 +10,9 @@ class ReeSwagger::BuildRequestBodySchema
   contract(
     ReeMapper::Mapper,
     ArrayOf[Symbol],
-    ArrayOf[ReeMapper::FieldsFilter] => Nilor[Hash]
+    Nilor[ArrayOf[ReeMapper::FieldsFilter]] => Nilor[Hash]
   )
-  def call(mapper, path_params = [], fields_filters = [])
+  def call(mapper, path_params = [], fields_filters = nil)
     if mapper.type
       return get_caster_definition(mapper.type, method(:call).to_proc)
     end
@@ -20,7 +20,7 @@ class ReeSwagger::BuildRequestBodySchema
     required_fields = []
 
     properties = mapper.fields.each_with_object({}) do |(_name, field), acc|
-      next unless fields_filters.all? { _1.allow?(field.name) }
+      next unless fields_filters.nil? || fields_filters.all? { _1.allow?(field.name) }
 
       next if path_params.include?(field.name)
 
@@ -34,8 +34,15 @@ class ReeSwagger::BuildRequestBodySchema
       required_fields << field.name.to_s if !field.optional
       field_mapper = field.type
 
-      nested_fields_filters = fields_filters.map { _1.filter_for(field.name) }
-      nested_fields_filters += [field.fields_filter]
+      nested_fields_filters = fields_filters&.filter_map { _1.filter_for(field.name) }
+
+      if field.fields_filter
+        nested_fields_filters = if nested_fields_filters
+          nested_fields_filters + [field.fields_filter]
+        else
+          [field.fields_filter]
+        end
+      end
 
       swagger_type = call(field_mapper, [], nested_fields_filters)