ree_lib 1.0.35 → 1.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 190a7da138d373c34c6e7636265ccce86c37e6ad5fd0c02b4e3c81c7e376393a
-  data.tar.gz: ad6b89d186eec9a9006cc6d217ee82d6f20a34428bd052953aac7e2624a6b41c
+  metadata.gz: 61b5c4cb5d7eef9fc932ebe3a674c5c752cb82d035248910a8a3da7a1ffe45b5
+  data.tar.gz: d604e93726df4c19ebfe4c244a9d91da836e2a587d8599969bd9e5980a4e07d9
 SHA512:
-  metadata.gz: 45199483809ad7917a207699df3acd7689db5dd246dfdce7910a7427a4d100750196a903b51aba2e24d0594141a01b8086e0767f9427b555fa2bdece22e83491
-  data.tar.gz: d20668755d3da265a0ec0351220dfe9604cfaf21ebbb78833b093445afd01280e7b6e7d83ebba428b3808c346754fb1debcbed29197098f136c3b1a30bb24369
+  metadata.gz: e05879958d07507dce29039623c4c88a5eb4b49ea7c9eee56b86346f004cbea2f455a42464142cc91d04aeefb07e65d3f2436073a3e58bcfd9434b6512cc8d31
+  data.tar.gz: c5888ac8151e1016bde7705fdbdc13bc4f814007401ff23d9da9bac160810ca6e1b92008015b507e90a110035848189d6d291093b7fea42ca1df7d6c5f962c24

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.35)
+    ree_lib (1.0.36)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -36,6 +36,8 @@ GEM
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     msgpack (1.6.0)
+    nokogiri (1.14.2-x86_64-darwin)
+      racc (~> 1.4)
     nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.23)
@@ -44,7 +46,7 @@ GEM
     racc (1.6.2)
     rainbow (3.1.1)
     rake (13.0.6)
-    ree (1.0.23)
+    ree (1.0.26)
       commander (~> 4.6.0)
     rexml (3.2.5)
     rollbar (3.3.3)

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_factory.rb

@@ -18,13 +18,13 @@ class ReeMapper::BuildMapperFactory
       @strategies = strategies
     }
 
-    klass.register(:bool, Mapper.build(strategies, ReeMapper::Bool.new))
-    klass.register(:date_time, Mapper.build(strategies, ReeMapper::DateTime.new))
-    klass.register(:time, Mapper.build(strategies, ReeMapper::Time.new))
-    klass.register(:date, Mapper.build(strategies, ReeMapper::Date.new))
-    klass.register(:float, Mapper.build(strategies, ReeMapper::Float.new))
-    klass.register(:integer, Mapper.build(strategies, ReeMapper::Integer.new))
-    klass.register(:string, Mapper.build(strategies, ReeMapper::String.new))
+    klass.register_type(:bool, ReeMapper::Bool.new)
+    klass.register_type(:date_time, ReeMapper::DateTime.new)
+    klass.register_type(:time, ReeMapper::Time.new)
+    klass.register_type(:date, ReeMapper::Date.new)
+    klass.register_type(:float, ReeMapper::Float.new)
+    klass.register_type(:integer, ReeMapper::Integer.new)
+    klass.register_type(:string, ReeMapper::String.new)
 
     klass
   end

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

@@ -7,7 +7,7 @@ class ReeMapper::Mapper
       strategies.each do |strategy|
         method = strategy.method
         next if type.respond_to?(method)
-        raise ReeMapper::UnsupportedTypeError, "type #{type.name} should implement method `#{method}`"
+        raise ReeMapper::UnsupportedTypeError, "type #{type.inspect} should implement method `#{method}`"
       end
     end
 
@@ -113,7 +113,7 @@ class ReeMapper::Mapper
 
   contract(Symbol => Class).throws(ArgumentError)
   def dto(strategy_method)
-    strategy = strategies.detect { _1.method == strategy_method }
+    strategy = find_strategy(strategy_method)
     raise ArgumentError, "there is no :#{strategy_method} strategy" unless strategy
     strategy.dto
   end
@@ -124,4 +124,9 @@ class ReeMapper::Mapper
     strategies.each { _1.prepare_dto(fields.keys) }
     nil
   end
+
+  contract(Symbol => Nilor[ReeMapper::MapperStrategy])
+  def find_strategy(strategy_method)
+    strategies.detect { _1.method == strategy_method }
+  end
 end

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

@@ -5,35 +5,42 @@ class ReeMapper::MapperFactory
     attr_reader :types, :strategies
   end
 
-  contract(Symbol, Any => Class).throws(ArgumentError)
-  def self.register_type(name, object_type)
-    register(
+  contract(Symbol => Nilor[ReeMapper::MapperStrategy])
+  def self.find_strategy(strategy_method)
+    strategies.detect { _1.method == strategy_method }
+  end
+
+  contract(Symbol, ReeMapper::AbstractType, Kwargs[strategies: ArrayOf[ReeMapper::MapperStrategy]] => Class)
+  def self.register_type(name, object_type, strategies: self.strategies)
+    register_mapper(
       name,
       ReeMapper::Mapper.build(strategies, object_type)
     )
   end
 
-  contract(Symbol, Any => Class).throws(ArgumentError)
-  def self.register(name, type)
-    raise ArgumentError, "name of mapper type should not include `?`" if name.to_s.end_with?('?')
-    raise ArgumentError, "type :#{name} already registered" if types.key?(name)
-    raise ArgumentError, "method :#{name} already defined" if method_defined?(name)
+  contract(Symbol, ReeMapper::Mapper => Class).throws(ArgumentError)
+  def self.register_mapper(name, type)
+    raise ArgumentError, "name of mapper type should not end with `?`" if name.to_s.end_with?('?')
+
+    defined_strategy_method = types[name]&.flat_map(&:strategy_methods)&.detect { type.find_strategy(_1) }
+    raise ArgumentError, "type :#{name} with `#{defined_strategy_method}` strategy already registered" if defined_strategy_method
+    raise ArgumentError, "method :#{name} already defined" if !types.key?(name) && method_defined?(name)
 
     type = type.dup
     type.name = name
     type.freeze
-    types[name] = type
+    types[name] ||= []
+    types[name] << type
 
     class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
       def #{name}(field_name = nil, optional: false, **opts)
         raise ReeMapper::Error, "invalid DSL usage" unless @mapper
         raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
 
-        type = self.class.types.fetch(:#{name})
+        type = self.class.types.fetch(:#{name}).detect { (@mapper.strategy_methods - _1.strategy_methods).empty? }
 
-        @mapper.strategy_methods.each do |method|
-          next if type.respond_to?(method)
-          raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement method `\#{method}`"
+        unless type
+          raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
         return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name

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

@@ -22,7 +22,7 @@ class ReeMapper::MapperFactoryProxy
     if strategy_or_method.is_a?(ReeMapper::MapperStrategy)
       strategy = strategy_or_method
     else
-      strategy = mapper_factory.strategies.detect { _1.method == strategy_or_method }
+      strategy = mapper_factory.find_strategy(strategy_or_method)
       raise ArgumentError, "MapperFactory strategy :#{strategy_or_method} not found" unless strategy
       strategy = strategy.dup
       strategy.dto = dto if dto
@@ -36,7 +36,7 @@ class ReeMapper::MapperFactoryProxy
     mapper_factory.new(mapper).instance_exec(&blk)
     mapper.prepare_dto
 
-    mapper_factory.register(register_as, mapper) if register_as
+    mapper_factory.register_mapper(register_as, mapper) if register_as
 
     after_build&.call(mapper)
 

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

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

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

@@ -20,6 +20,8 @@ class ReeMapper::Float < ReeMapper::AbstractType
       rescue ArgumentError => e
         raise ReeMapper::CoercionError, "`#{name}` is invalid float"
       end
+    elsif defined?(BigDecimal) && value.is_a?(BigDecimal)
+      value.to_f
     else
       raise ReeMapper::TypeError, "`#{name}` should be a float"
     end

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

@@ -160,7 +160,7 @@ Create `mapper_factory.rb` file to declare `MapperFactory` class.
         build_mapper_strategy(method: :db_load,   dto: Object)
       ])
 
-      mapper_factory.register(:cart_user, user_caster)
+      mapper_factory.register_mapper(:cart_user, user_caster)
 
       mapper_factory
     end

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

@@ -5,35 +5,76 @@ RSpec.describe ReeMapper::MapperFactory do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
-  let(:mapper_factory) {
-    build_mapper_factory(strategies: [
-      build_mapper_strategy(method: :cast, dto: Hash)
-    ])
-  }
+  let(:cast_strategy) { build_mapper_strategy(method: :cast, dto: Hash) }
+  let(:serialize_strategy) { build_mapper_strategy(method: :serialize, dto: Hash) }
+  let(:mapper_factory) { build_mapper_factory(strategies: [cast_strategy, serialize_strategy]) }
+
+  describe '.register_type' do
+    let(:mapper_type) {
+      Class.new(ReeMapper::AbstractType) do
+        def cast(*); :value end
+        def serialize(*); end
+      end
+    }
 
-  describe '.register' do
     it {
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      expect(mapper_factory.instance_methods).to include(:new_type)
+      mapper_factory.register_type(:new_type, mapper_type.new)
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: :any })
+      ).to eq({ val: :value })
     }
 
-    it 'raise an error if the type is already registered' do
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+    it {
+      mapper_factory.register_type(:new_type, mapper_type.new, strategies: [cast_strategy])
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: :any })
+      ).to eq({ val: :value })
+    }
+  end
+
+  describe '.register_mapper' do
+    let(:serializer) { mapper_factory.call.use(:serialize) { integer :id } }
+
+    it {
+      mapper_factory.register_mapper(:new_type, serializer)
+
+      expect(
+        mapper_factory.call.use(:serialize) { new_type :val }.serialize({ val: { id: 1 } })
+      ).to eq({ val: { id: 1 } })
+    }
+
+    it 'allow to register caster and serializer with same name' do
+      caster = mapper_factory.call.use(:cast) { string :name }
+
+      mapper_factory.register_mapper(:new_type, serializer)
+      mapper_factory.register_mapper(:new_type, caster)
+
+      expect(
+        mapper_factory.call.use(:serialize) { new_type :val }.serialize({ val: { id: 1 } })
+      ).to eq({ val: { id: 1 } })
+
+      expect(
+        mapper_factory.call.use(:cast) { new_type :val }.cast({ val: { name: '1' } })
+      ).to eq({ val: { name: '1' } })
+    end
+
+    it 'raise an error if the mapper is already registered' do
+      mapper_factory.register_mapper(:new_type, serializer)
 
       expect {
-        mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      }.to raise_error(ArgumentError, 'type :new_type already registered')
+        mapper_factory.register_mapper(:new_type, serializer)
+      }.to raise_error(ArgumentError, 'type :new_type with `serialize` strategy already registered')
     end
 
-    it 'raise an error if the type is ended by ?' do
+    it 'raise an error if the mapper name is ended by ?' do
       expect {
-        mapper_factory.register(:new_type?, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
-      }.to raise_error(ArgumentError)
+        mapper_factory.register_mapper(:new_type?, serializer)
+      }.to raise_error(ArgumentError, 'name of mapper type should not end with `?`')
     end
 
-    it 'raise an error if the type method is already registered' do
+    it 'raise an error if the mapper name is reserved' do
       expect {
-        mapper_factory.register(:array, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+        mapper_factory.register_mapper(:array, serializer)
       }.to raise_error(ArgumentError, 'method :array already defined')
     end
   end
@@ -48,13 +89,17 @@ RSpec.describe ReeMapper::MapperFactory do
     }
 
     it {
-      mapper_factory.register(:new_type, ReeMapper::Mapper.build([], ReeMapper::AbstractType.new))
+      serializer = mapper_factory.call.use(:serialize) do
+        integer :my_field
+      end
+
+      mapper_factory.register_mapper(:new_type, serializer)
 
       expect {
         mapper_factory.call.use(:cast) do
           new_type :settings
         end
-      }.to raise_error(ReeMapper::UnsupportedTypeError)
+      }.to raise_error(ReeMapper::UnsupportedTypeError, 'type :new_type should implement `cast`')
     }
 
     it {
@@ -62,7 +107,9 @@ RSpec.describe ReeMapper::MapperFactory do
         integer :id
       end
 
-      expect(mapper_factory.instance_methods).to include(:user)
+      expect(
+        mapper_factory.call.use(:cast) { user :user }.cast({ user: { id: 1 } })
+      ).to eq({ user: { id: 1 } })
     }
 
     it {
@@ -80,4 +127,14 @@ RSpec.describe ReeMapper::MapperFactory do
       }.to raise_error(ReeMapper::ArgumentError, "mapper should contain at least one field")
     }
   end
+
+  describe '.find_strategy' do
+    it {
+      expect(mapper_factory.find_strategy(:cast)).to eq(cast_strategy)
+    }
+
+    it {
+      expect(mapper_factory.find_strategy(:unknown)).to be_nil
+    }
+  end
 end

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

@@ -92,7 +92,7 @@ RSpec.describe ReeMapper::Mapper do
       )
     }
 
-    it { 
+    it {
       expect(mapper.cast({ my_field: 1, hsh: { nested_field: 1 } })).to be_a(Struct)
     }
   end
@@ -166,4 +166,28 @@ RSpec.describe ReeMapper::Mapper do
       expect { mapper.dto(:db_dump) }.to raise_error(ArgumentError, "there is no :db_dump strategy")
     }
   end
+
+  describe '#find_strategy' do
+    let(:mapper_factory) {
+      build_mapper_factory(
+        strategies: [
+          build_mapper_strategy(method: :cast),
+          build_mapper_strategy(method: :serialize),
+        ]
+      )
+    }
+    let(:mapper) {
+      mapper_factory.call.use(:cast) do
+        integer :my_field
+      end
+    }
+
+    it {
+      expect(mapper.find_strategy(:cast)).to be_a(ReeMapper::MapperStrategy)
+    }
+
+    it {
+      expect(mapper.find_strategy(:serialize)).to be_nil
+    }
+  end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'bigdecimal'
 
 RSpec.describe 'ReeMapper::Float' do
   link :build_mapper_factory, from: :ree_mapper
@@ -30,6 +31,10 @@ RSpec.describe 'ReeMapper::Float' do
       expect(mapper.cast({ float: '1.1' })).to eq({ float: 1.1 })
     }
 
+    it {
+      expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+    }
+
     it {
       expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
@@ -88,6 +93,10 @@ RSpec.describe 'ReeMapper::Float' do
       expect(mapper.db_load({ float: '1.1' })).to eq({ float: 1.1 })
     }
 
+    it {
+      expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+    }
+
     it {
       expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/to_hash.rb

@@ -6,7 +6,7 @@ class ReeObject::ToHash
   fn :to_hash do
     def_error { RecursiveObjectErr }
   end
-  
+
   BASIC_TYPES = [
     Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,
     Module, Class
@@ -57,8 +57,8 @@ class ReeObject::ToHash
       raise RecursiveObjectErr, "Recursive object found: #{obj}"
     end
 
-    cache[obj.object_id] = acc
-    
+    cache[obj.object_id] = true
+
     obj.instance_variables.each do |var|
       key_name = var.to_s.delete("@")
       key_sym = key_name.to_sym
@@ -69,6 +69,8 @@ class ReeObject::ToHash
       acc[key] = recursively_convert(value, {}, cache)
     end
 
+    cache.delete(obj.object_id)
+
     acc
   end
 end

data/lib/ree_lib/packages/ree_object/spec/ree_object/functions/to_hash_spec.rb

@@ -167,6 +167,11 @@ RSpec.describe :to_hash do
           to_hash(obj)
         }.to raise_error(ReeObject::ToHash::RecursiveObjectErr, /Recursive object found: /)
       }
+
+      it {
+        obj = obj_klass.new
+        expect(to_hash([obj, obj])).to eq([{}, {}])
+      }
     end
   end
 end

data/lib/ree_lib/packages/ree_swagger/spec/functions/build_serializer_schema_spec.rb

@@ -11,16 +11,13 @@ RSpec.describe :build_serializer_schema do
 
     build_mapper_factory(
       strategies: strategies
-    ).register(
+    ).register_type(
       :unregistered_type,
-      ReeMapper::Mapper.build(
-        strategies,
-        Class.new(ReeMapper::AbstractType) do
-          def serialize(val, role: nil)
-            val
-          end
-        end.new
-      )
+      Class.new(ReeMapper::AbstractType) do
+        def serialize(val, role: nil)
+          val
+        end
+      end.new
     )
   }
 
@@ -118,10 +115,10 @@ RSpec.describe :build_serializer_schema do
           test_unregistered_type: {},
           partial_value: {
             type: 'object',
-            properties: { 
+            properties: {
               nested_partial_value: {
                 type: 'object',
-                properties: { 
+                properties: {
                   included: { type: 'string' }
                 }
               }

data/lib/ree_lib/packages/ree_swagger/spec/functions/register_type_spec.rb

@@ -15,13 +15,8 @@ RSpec.describe :register_type do
       build_mapper_strategy(method: :serialize, dto: Hash),
     ]
 
-    build_mapper_factory(strategies: strategies).register(
-      :my_type,
-      ReeMapper::Mapper.build(
-        strategies,
-        ReeSwagger::MyType.new
-      )
-    )
+    build_mapper_factory(strategies: strategies)
+      .register_type(:my_type, ReeSwagger::MyType.new)
   }
 
   let(:mapper) {

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.35
+  version: 1.0.36
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree