ree_lib 1.0.37 → 1.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfa479493ff3b8d80a181db242e9f443324b5c7f46b3629dae816f06eb2fd758
-  data.tar.gz: 371e0a229e967c47f8ad61de6c86aba1bb0e0b17651bf6447e7727734629e294
+  metadata.gz: 9f94479d9a955ba5ba5f65a8eba245bfab7c050b5a55e16a5de1773d920837bf
+  data.tar.gz: e45a2a8f9166d4ed50d3cbc58a3bb73cb026adf3b09a8b32f64af986c1e15bdb
 SHA512:
-  metadata.gz: 71b4a7f35d1a0569af42794acf8bf8c1193cf390ca773fd6ebab395cb86192199496812c9ae356e29a299a453304d6c25217cd20d9bd7884ded1e10fa798d68f
-  data.tar.gz: c5b3cf9ea44d8012ea7be12cf8ef9f33ac735a28c8d9bb384bf69fec6f8bc7932b7a1cf6f43be4439d7fa220b3cc2e630d8e0816b75c732fcb9b13e3e1b6ef22
+  metadata.gz: 93db2ec2423d53c97f2ae8a43e989f18c9d6d47e062686d1f89d9f45c58b90eca0778eb6c7ed20f1f16a35d85af7474e3a230f89f437d146817539626df25bbf
+  data.tar.gz: fec05fa12a474168bc340ecf473a7cef26aa1ce8d7a0845e459c419228ddb954f52cacd35e4a4a58ca8ab7574218a47e274f55d4793e23c102801c81993b7c88

data/Gemfile.lock

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

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

@@ -15,6 +15,7 @@ class ReeMapper::BuildMapperFactory
 
     klass.instance_eval {
       @types = {}
+      @wrappers = {}
       @strategies = strategies
     }
 
@@ -25,6 +26,9 @@ class ReeMapper::BuildMapperFactory
     klass.register_type(:float, ReeMapper::Float.new)
     klass.register_type(:integer, ReeMapper::Integer.new)
     klass.register_type(:string, ReeMapper::String.new)
+    klass.register_type(:any, ReeMapper::Any.new)
+
+    klass.register_wrapper(:array, ReeMapper::Array)
 
     klass
   end

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

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 class ReeMapper::Mapper
-  contract(ArrayOf[ReeMapper::MapperStrategy], Nilor[ReeMapper::AbstractType] => Any).throws(ReeMapper::UnsupportedTypeError)
+  contract(
+    ArrayOf[ReeMapper::MapperStrategy],
+    Nilor[ReeMapper::AbstractType, ReeMapper::AbstractWrapper] => self
+  ).throws(ReeMapper::UnsupportedTypeError)
   def self.build(strategies, type = nil)
     if type
       strategies.each do |strategy|
         method = strategy.method
         next if type.respond_to?(method)
-        raise ReeMapper::UnsupportedTypeError, "type #{type.inspect} should implement method `#{method}`"
+
+        raise ReeMapper::UnsupportedTypeError, "#{type.class} should implement method `#{method}`"
       end
     end
 
@@ -20,11 +24,13 @@ class ReeMapper::Mapper
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
             def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
-              if @type.is_a?(ReeMapper::Array)
-                @type.#{method}(obj, name: name, role: role, fields_filters: fields_filters)
-              else
-                @type.#{method}(obj, name: name, role: role)
-              end
+              #{
+                if type.is_a?(ReeMapper::AbstractWrapper)
+                  "@type.#{method}(obj, name: name, role: role, fields_filters: fields_filters)"
+                else
+                  "@type.#{method}(obj, name: name, role: role)"
+                end
+              }
             end
           RUBY
         else
@@ -95,9 +101,10 @@ class ReeMapper::Mapper
     end
   end
 
-  contract(Any, Symbol, Ksplat[RestKeys => Any] => nil)
-  def add_field(type, name, **opts)
-    @fields[name] = ReeMapper::Field.new(type, name, **opts)
+  contract(ReeMapper::Field => nil)
+  def add_field(field)
+    raise ArgumentError if field.name.nil?
+    @fields[field.name] = field
     nil
   end
 

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

@@ -2,7 +2,7 @@
 
 class ReeMapper::MapperFactory
   class << self
-    attr_reader :types, :strategies
+    attr_reader :types, :strategies, :wrappers
   end
 
   contract(Symbol => Nilor[ReeMapper::MapperStrategy])
@@ -18,9 +18,9 @@ class ReeMapper::MapperFactory
     )
   end
 
-  contract(Symbol, ReeMapper::Mapper => Class).throws(ArgumentError)
+  contract(Symbol, ReeMapper::Mapper => SubclassOf[self]).throws(ArgumentError)
   def self.register_mapper(name, type)
-    raise ArgumentError, "name of mapper type should not end with `?`" if name.to_s.end_with?('?')
+    raise ArgumentError, "mapper registration name 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
@@ -35,7 +35,7 @@ class ReeMapper::MapperFactory
     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
+        raise ArgumentError, "wrapped item can't be optional" if field_name.nil? && optional
 
         type = self.class.types.fetch(:#{name}).detect { (@mapper.strategy_methods - _1.strategy_methods).empty? }
 
@@ -43,9 +43,11 @@ class ReeMapper::MapperFactory
           raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
-        return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
+        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
 
-        @mapper.add_field(type, field_name, optional: optional, **opts)
+        return field unless field_name
+
+        @mapper.add_field(field)
       end
 
       def #{name}?(field_name, **opts)
@@ -56,6 +58,68 @@ class ReeMapper::MapperFactory
     self
   end
 
+  contract(Symbol, SubclassOf[ReeMapper::AbstractWrapper] => SubclassOf[self])
+  def self.register_wrapper(name, wrapper)
+    raise ArgumentError, "wrapper registration name should not end with `?`" if name.to_s.end_with?('?')
+    raise ArgumentError, "method :#{name} already defined" if !wrappers.key?(name) && method_defined?(name)
+
+    wrappers[name] ||= []
+    wrappers[name] << wrapper
+
+    class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+      contract(
+        Nilor[Symbol, ReeMapper::Field],
+        Nilor[ReeMapper::Field],
+        Kwargs[optional: Bool, dto: Nilor[Class]],
+        Ksplat[RestKeys => Any],
+        Optblock => Nilor[ReeMapper::Field]
+      ).throws(ReeMapper::Error, ArgumentError, ReeMapper::UnsupportedTypeError)
+      def #{name}(field_name = nil, subject = nil, optional: false, dto: nil, **opts, &blk)
+        raise ReeMapper::Error, "invalid DSL usage" unless @mapper
+        raise ArgumentError, 'wrapped type does not permit :dto without :block' if dto && !blk
+
+        if field_name.is_a?(ReeMapper::Field)
+          raise ArgumentError, "field_name should be a Symbol" if subject
+
+          subject = field_name
+          field_name = nil
+        end
+
+        raise ArgumentError, "wrapped item can't be optional" if field_name.nil? && optional
+        raise ArgumentError, "wrapped type should use either :subject or :block" if subject && blk || !subject && !blk
+
+        if blk
+          subject = ReeMapper::Field.new(
+            hash_from_blk(dto: dto, &blk)
+          )
+        end
+
+        wrapper = self.class.wrappers.fetch(:#{name}).detect do |wrapper|
+          @mapper.strategy_methods.all? { wrapper.method_defined?(_1) }
+        end
+
+        unless wrapper
+          raise ReeMapper::UnsupportedTypeError, "wrapper :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
+        end
+
+        type = ReeMapper::Mapper.build(@mapper.strategies, wrapper.new(subject))
+        type.name = :#{name}
+
+        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+
+        return field unless field_name
+
+        @mapper.add_field(field)
+      end
+
+      def #{name}?(*args, **opts, &blk)
+        #{name}(*args, optional: true, **opts, &blk)
+      end
+    RUBY
+
+    self
+  end
+
   contract(
     Kwargs[
       register_as: Nilor[Symbol]
@@ -71,41 +135,15 @@ class ReeMapper::MapperFactory
     @mapper = mapper
   end
 
-  contract(Nilor[Symbol], Kwargs[each: Nilor[ReeMapper::Field], optional: Bool, dto: Nilor[Class]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
-  def array(field_name = nil, each: nil, optional: false, dto: nil, **opts, &blk)
-    raise ReeMapper::Error, "invalid DSL usage" unless @mapper
-    raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
-    raise ArgumentError, 'array type should use either :each or :block' if each && blk || !each && !blk
-    raise ArgumentError, 'array does not permit :dto without :block' if dto && !blk
-    raise ArgumentError, 'array does not permit :only and :except keys' if opts.key?(:only) || opts.key?(:except)
-
-    if blk
-      each = ReeMapper::Field.new(
-        hash_from_blk(dto: dto, &blk)
-      )
-    end
-
-    type = ReeMapper::Mapper.build(@mapper.strategies, ReeMapper::Array.new(each))
-
-    return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
-
-    @mapper.add_field(type, field_name, optional: optional, **opts)
-  end
-
-  contract(Symbol, Kwargs[each: Nilor[ReeMapper::Field]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
-  def array?(field_name, each: nil, **opts, &blk)
-    raise ArgumentError if opts.key?(:optional)
-
-    array(field_name, each: each, optional: true, **opts, &blk)
-  end
-
   contract(Symbol, Kwargs[dto: Nilor[Class]], Ksplat[RestKeys => Any], Block => nil)
   def hash(field_name, dto: nil, **opts, &blk)
     raise ReeMapper::Error, "invalid DSL usage" unless @mapper
 
     type = hash_from_blk(dto: dto, &blk)
 
-    @mapper.add_field(type, field_name, **opts)
+    field = ReeMapper::Field.new(type, field_name, **opts)
+
+    @mapper.add_field(field)
   end
 
   contract(Symbol, Ksplat[RestKeys => Any], Block => nil)

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

@@ -0,0 +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)
+    value
+  end
+
+  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def cast(value, name:, role: nil)
+    value
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def db_dump(value, name:, role: nil)
+    value
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def db_load(value, name:, role: nil)
+    value
+  end
+end

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

@@ -0,0 +1,8 @@
+class ReeMapper::AbstractWrapper
+  attr_reader :subject
+
+  contract ReeMapper::Field => Any
+  def initialize(field)
+    @subject = field
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/{types → wrappers}/array.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
-class ReeMapper::Array < ReeMapper::AbstractType
-  attr_reader :of
-
-  contract ReeMapper::Field => Any
-  def initialize(of)
-    @of = of
-  end
-
+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: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -29,10 +22,10 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def cast(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -45,10 +38,10 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def db_dump(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -61,14 +54,14 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def db_load(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
       raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
-end
+end

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

@@ -22,14 +22,18 @@ module ReeMapper
   require_relative 'ree_mapper/fields_filter'
   require_relative 'ree_mapper/field'
 
+
+  require_relative 'ree_mapper/wrappers/abstract_wrapper'
+  require_relative 'ree_mapper/wrappers/array'
+
   require_relative 'ree_mapper/types/bool'
+  require_relative 'ree_mapper/types/any'
   require_relative 'ree_mapper/types/date_time'
   require_relative 'ree_mapper/types/time'
   require_relative 'ree_mapper/types/date'
   require_relative 'ree_mapper/types/float'
   require_relative 'ree_mapper/types/integer'
   require_relative 'ree_mapper/types/string'
-  require_relative 'ree_mapper/types/array'
 
   require_relative 'ree_mapper/strategy_outputs/strategy_output'
   require_relative 'ree_mapper/strategy_outputs/object_output'

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

@@ -43,7 +43,7 @@ RSpec.describe ReeMapper::MapperFactory do
       ).to eq({ val: { id: 1 } })
     }
 
-    it 'allow to register caster and serializer with same name' do
+    it 'allow to register caster and serializer with the same name' do
       caster = mapper_factory.call.use(:cast) { string :name }
 
       mapper_factory.register_mapper(:new_type, serializer)
@@ -69,7 +69,7 @@ RSpec.describe ReeMapper::MapperFactory do
     it 'raise an error if the mapper name is ended by ?' do
       expect {
         mapper_factory.register_mapper(:new_type?, serializer)
-      }.to raise_error(ArgumentError, 'name of mapper type should not end with `?`')
+      }.to raise_error(ArgumentError, 'mapper registration name should not end with `?`')
     end
 
     it 'raise an error if the mapper name is reserved' do
@@ -79,6 +79,66 @@ RSpec.describe ReeMapper::MapperFactory do
     end
   end
 
+  describe '.register_wrapper' do
+    let(:round_wrapper) {
+      Class.new(ReeMapper::AbstractWrapper) do
+        def serialize(value, name:, **opts)
+          raise ReeMapper::TypeError, "`#{name}` should be a number" if !value.is_a?(Numeric)
+
+          subject.type.serialize(value.round, name: name, **opts)
+        end
+      end
+    }
+
+    it {
+      mapper_factory.register_wrapper(:round, round_wrapper)
+
+      expect(
+        mapper_factory.call.use(:serialize) { round :val, integer }.serialize({ val: 1.1 })
+      ).to eq({ val: 1 })
+    }
+
+    it 'allow to register caster and serializer with the same name' do
+      caster_round_wrapper = Class.new(ReeMapper::AbstractWrapper) do
+        def cast(value, name:, **opts)
+          value = subject.type.cast(value, name: name, **opts)
+
+          raise ReeMapper::TypeError, "`#{name}` should be a number" if !value.is_a?(Numeric)
+          value.round
+        end
+      end
+
+      mapper_factory.register_wrapper(:round, round_wrapper)
+      mapper_factory.register_wrapper(:round, caster_round_wrapper)
+
+      expect(
+        mapper_factory.call.use(:serialize) { round :val, integer }.serialize({ val: 1.1 })
+      ).to eq({ val: 1 })
+
+      expect(
+        mapper_factory.call.use(:cast) { round :val, float }.cast({ val: '1.1' })
+      ).to eq({ val: 1 })
+    end
+
+    it 'raise an error if the registration wrapper name is ended by ?' do
+      expect {
+        mapper_factory.register_wrapper(:new_type?, round_wrapper)
+      }.to raise_error(ArgumentError, 'wrapper registration name should not end with `?`')
+    end
+
+    it 'raise an error if name is reserved' do
+      expect {
+        mapper_factory.register_wrapper(:hash, round_wrapper)
+      }.to raise_error(ArgumentError, 'method :hash already defined')
+    end
+
+    it 'raise an error if name is reserved by mapper' do
+      expect {
+        mapper_factory.register_wrapper(:integer, round_wrapper)
+      }.to raise_error(ArgumentError, 'method :integer already defined')
+    end
+  end
+
   describe '.use' do
     it {
       mapper = mapper_factory.call.use(:cast) do

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ReeMapper::Bool' 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),
+        build_mapper_strategy(method: :serialize, dto: Hash),
+        build_mapper_strategy(method: :db_dump,   dto: Hash),
+        build_mapper_strategy(method: :db_load,   dto: Hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      any :any
+    }
+  }
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ any: true })).to eq({ any: true })
+    }
+  end
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ 'any' => true })).to eq({ any: true })
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump(OpenStruct.new({ any: true }))).to eq({ any: true })
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ 'any' => true })).to eq({ any: true })
+    }
+  end
+end

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

@@ -21,7 +21,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
         integer :x
         integer :y
         integer :z
-      } 
+      }
     }
 
     context 'with only' do
@@ -71,7 +71,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
             point :y, except: [:x, :z]
           end
 
-          array :points, each: point(only: [:x, :y])
+          array :points, point(only: [:x, :y])
         }
       }
 
@@ -169,7 +169,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
         integer :number
         integer? :opt_number
         integer :opt_number_long, optional: true
-        array? :opt_array, each: integer
+        array? :opt_array, integer
         array? :opt_array_with_blk do
           integer :id
         end
@@ -278,7 +278,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
           integer :for_all
           integer :for_admin, role: :admin
         }
-        
+
         mapper_factory.call.use(:cast) {
           nested_type :my_field
         }

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/{types → wrappers}/array_spec.rb

@@ -17,8 +17,8 @@ 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)
+      array :tags, integer
+      array? :ary_of_ary, array(integer)
     }
   }
 
@@ -73,7 +73,7 @@ RSpec.describe 'ReeMapper::Array' do
   context 'with array of array' do
     let(:mapper) {
       mapper_factory.call.use(:serialize) {
-        array :coords, each: array(each: integer)
+        array :coords, array(integer)
       }
     }
 
@@ -85,7 +85,7 @@ RSpec.describe 'ReeMapper::Array' do
   context 'with nullable element of array' do
     let(:mapper) {
       mapper_factory.call.use(:serialize) {
-        array :tags, each: integer(null: true)
+        array :tags, integer(null: true)
       }
     }
 
@@ -98,7 +98,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: integer?
+          array :tags, integer?
         }
       }.to raise_error(ArgumentError)
     }
@@ -106,7 +106,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: integer(optional: true)
+          array :tags, integer(optional: true)
         }
       }.to raise_error(ArgumentError)
     }
@@ -114,7 +114,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: array(each: integer, optional: true)
+          array :tags, array(integer, optional: true)
         }
       }.to raise_error(ArgumentError)
     }

data/lib/ree_lib/packages/ree_swagger/package/ree_swagger/beans/type_definitions_repo.rb

@@ -27,7 +27,7 @@ class ReeSwagger::TypeDefinitionsRepo
         ReeMapper::Array => ->(type, build_serializer_schema) {
           {
             type: 'array',
-            items: build_serializer_schema.(type.of.type)
+            items: build_serializer_schema.(type.subject.type)
           }
         },
         ReeMapper::DateTime => ->(*) {

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

@@ -30,7 +30,7 @@ RSpec.describe :build_parameters_spec do
 
   it {
     caster = mapper_factory.call.use(:cast) do
-      array :id, each: string
+      array :id, string
     end
 
     expect {

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

@@ -39,17 +39,17 @@ RSpec.describe :build_serializer_schema do
     end
 
     mapper_factory.call.use(:serialize) do
-      integer   :id,            doc:  'Identificator'
+      integer   :id,            doc:    'Identificator'
       string    :name
       bool      :is_admin
       float     :free_space
-      array     :tags,          each: string
+      array     :tags,          string
       date_time :created_at
       date      :birth_day
       time      :updated_at
 
       setting   :one_setting
-      array     :many_settings, each: setting
+      array     :many_settings, setting
 
       hash      :cart do
         integer :size

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.37
+  version: 1.0.38
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-12 00:00:00.000000000 Z
+date: 2023-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -967,7 +967,7 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/strategy_output.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/struct_output.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/abstract_type.rb
-- lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/array.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/any.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/bool.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date_time.rb
@@ -975,6 +975,8 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/integer.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/string.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/time.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/abstract_wrapper.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/array.rb
 - lib/ree_lib/packages/ree_mapper/schemas/ree_mapper/default_factory.schema.json
 - lib/ree_lib/packages/ree_mapper/schemas/ree_mapper/functions/build_mapper_factory.schema.json
 - lib/ree_lib/packages/ree_mapper/schemas/ree_mapper/functions/build_mapper_strategy.schema.json
@@ -984,7 +986,7 @@ files:
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/functions/build_mapper_strategy_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_factory_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_spec.rb
-- lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/array_spec.rb
+- lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/any_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/bool_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/date_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/date_time_spec.rb
@@ -994,6 +996,7 @@ files:
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/string_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/time_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/type_options_spec.rb
+- lib/ree_lib/packages/ree_mapper/spec/ree_mapper/wrappers/array_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/spec_helper.rb
 - lib/ree_lib/packages/ree_migrator/.gitignore
 - lib/ree_lib/packages/ree_migrator/.rspec