ree_lib 1.0.30 → 1.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0384a60b8e6da77137b281c223ae80df078ad10389876fb719bd6eb7264f305c'
-  data.tar.gz: 3771e23d3f69dbb9ba8ff56375b35ee039b92c2132e0398912e32677754f444b
+  metadata.gz: 5a28b9fc25900e54ca38f0a0a4fc47c8a46ceea9543d9a0cc2b95d72ff17c9cd
+  data.tar.gz: 19ace80db90cabee5a3909c9322c725c8c43b8a9766e2718ebd9b666bc929e56
 SHA512:
-  metadata.gz: b0e8d42f124e6252ce81fc64a7980c22c85e252ebdcedb5130fcaa53fda721d80c87804e33926251e5da9b753389593252309e5c09a9df4a769399084b0c158d
-  data.tar.gz: a8c6acc47b934e848ef7a98ad579b114cd8988bb78872ef5f2c616638e1e6cbe2d64a5618d6efd8fd5dd1ee1000397bab178fe16948617dff574cfa594eb3cf8
+  metadata.gz: 71287702a0bab2686193543bb28bd6eb322789293b3bec1605419e9bbe0dbecee651e5b0ceb7ce9311eff71a7f10513c47dd44811cfe65b48748ee42a4192d63
+  data.tar.gz: dcc67851e4a71dea3ee27c057d725861a2e75253d94cad46c137eb6307acadc0d4792542926145c3023e7241ee6557cfe7cf5a9392ab18ad5d6960c0b58f9707

data/Gemfile.lock

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

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/one_to_many.rb

@@ -3,8 +3,8 @@ class ReeDao::OneToMany
 
   fn :one_to_many do
     link :demodulize, from: :ree_string
-    link :underscore, from: :ree_string
     link :group_by, from: :ree_array
+    link :underscore, from: :ree_string
   end
 
   contract(
@@ -24,10 +24,7 @@ class ReeDao::OneToMany
     else
       dto_class = assoc_dao
         .opts[:schema_mapper]
-        .strategies
-        .detect {_1 .method == :db_load }
-        .output
-        .dto
+        .dto(:db_load)
 
       name = underscore(demodulize(dto_class.name))
       "set_#{name}s".to_sym

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/one_to_one.rb

@@ -3,8 +3,8 @@ class ReeDao::OneToOne
 
   fn :one_to_one do
     link :demodulize, from: :ree_string
-    link :underscore, from: :ree_string
     link :index_by, from: :ree_array
+    link :underscore, from: :ree_string
   end
 
   contract(
@@ -21,10 +21,7 @@ class ReeDao::OneToOne
 
     dto_class = assoc_dao
       .opts[:schema_mapper]
-      .strategies
-      .detect {_1 .method == :db_load }
-      .output
-      .dto
+      .dto(:db_load)
 
     assoc_name = underscore(demodulize(dto_class.name))
     reverse = opts[:reverse]

data/lib/ree_lib/packages/ree_dao/package/ree_dao/functions/persist_assoc.rb

@@ -27,10 +27,7 @@ class ReeDao::PersistAssoc
     assoc_name = if opts[:child_assoc].nil?
       dto_class = assoc_dao
         .opts[:schema_mapper]
-        .strategies
-        .detect {_1 .method == :db_load }
-        .output
-        .dto
+        .dto(:db_load)
 
       name = underscore(demodulize(dto_class.name))
       "#{name}s"

data/lib/ree_lib/packages/ree_dto/package/ree_dto/entity_dsl.rb

@@ -63,8 +63,10 @@ module ReeDto::EntityDSL
           }
         end
 
-        contract self => Bool
+        contract Any => Bool
         def ==(val)
+          return false unless val.is_a?(self.class)
+
           #{
             args.map {|k, _|
               "@#{k} == val.#{k}"

data/lib/ree_lib/packages/ree_dto/spec/ree_dto/entity_dsl_spec.rb

@@ -38,6 +38,8 @@ RSpec.describe ReeDto::EntityDSL do
   it { expect(@test_dto.email).to eq('test@example.com') }
   it { expect(@test_dto).to eq(@compare_dto) }
   it { expect(@test_dto).to_not eq(@uncompareable_dto)}
+  it { expect(@test_dto == Object.new).to eq(false) }
+  it { expect(@test_dto == @test_dto).to eq(true) }
 
   context "missing args" do
     it {

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

@@ -10,10 +10,10 @@ class ReeMapper::DefaultFactory
 
   def build
     build_mapper_factory(strategies: [
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash),
-      build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-      build_mapper_strategy(method: :db_dump, output: :symbol_key_hash),
-      build_mapper_strategy(method: :db_load, output: :object, always_optional: true)
+      build_mapper_strategy(method: :cast),
+      build_mapper_strategy(method: :serialize),
+      build_mapper_strategy(method: :db_dump),
+      build_mapper_strategy(method: :db_load, dto: Object, always_optional: true)
     ])
   end
 end

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

@@ -5,23 +5,15 @@ class ReeMapper::BuildMapperStrategy
 
   fn :build_mapper_strategy
 
-  OUTPUT_MAP = {
-    string_key_hash: ReeMapper::StringKeyHashOutput,
-    symbol_key_hash: ReeMapper::SymbolKeyHashOutput,
-    object:          ReeMapper::ObjectOutput
-  }.freeze
-
   contract(Kwargs[
     method:          Symbol,
-    output:          Symbol,
+    dto:             Class,
     always_optional: Bool
-  ] => ReeMapper::MapperStrategy).throws(ArgumentError)
-  def call(method:, output:, always_optional: false)
-    raise ArgumentError, 'invalid output' unless OUTPUT_MAP.key?(output)
-
+  ] => ReeMapper::MapperStrategy)
+  def call(method:, dto: Hash, always_optional: false)
     ReeMapper::MapperStrategy.new(
       method:          method,
-      output:          OUTPUT_MAP.fetch(output).new,
+      dto:             dto,
       always_optional: always_optional
     )
   end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class ReeMapper::Mapper
-  contract(ArrayOf[ReeMapper::MapperStrategy], Nilor[ReeMapper::AbstractType] => Any)
+  contract(ArrayOf[ReeMapper::MapperStrategy], Nilor[ReeMapper::AbstractType] => Any).throws(ReeMapper::UnsupportedTypeError)
   def self.build(strategies, type = nil)
     if type
       strategies.each do |strategy|
@@ -110,4 +110,18 @@ class ReeMapper::Mapper
   def name=(name)
     @name = name
   end
+
+  contract(Symbol => Class).throws(ArgumentError)
+  def dto(strategy_method)
+    strategy = strategies.detect { _1.method == strategy_method }
+    raise ArgumentError, "there is no :#{strategy_method} strategy" unless strategy
+    strategy.dto
+  end
+
+  contract(None => nil).throws(ReeMapper::ArgumentError)
+  def prepare_dto
+    raise ReeMapper::ArgumentError, "mapper should contain at least one field" if fields.empty?
+    strategies.each { _1.prepare_dto(fields.keys) }
+    nil
+  end
 end

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

@@ -5,12 +5,6 @@ class ReeMapper::MapperFactory
     attr_reader :types, :strategies
   end
 
-  HASH_KEY_OPTION_VALUES = [:symbol, :string, nil].freeze
-  HASH_KEY_OPTION_MAP = {
-    symbol: ReeMapper::SymbolKeyHashOutput,
-    string: ReeMapper::StringKeyHashOutput
-  }.freeze
-
   contract(Symbol, Any => Class).throws(ArgumentError)
   def self.register_type(name, object_type)
     register(
@@ -70,17 +64,17 @@ class ReeMapper::MapperFactory
     @mapper = mapper
   end
 
-  contract(Nilor[Symbol], Kwargs[each: Nilor[ReeMapper::Field], optional: Bool, key: Nilor[Symbol]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
-  def array(field_name = nil, each: nil, optional: false, key: nil, **opts, &blk)
+  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, 'invalid :key option value' unless HASH_KEY_OPTION_VALUES.include?(key)
+    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(key: key, &blk)
+        hash_from_blk(dto: dto, &blk)
       )
     end
 
@@ -98,12 +92,11 @@ class ReeMapper::MapperFactory
     array(field_name, each: each, optional: true, **opts, &blk)
   end
 
-  contract(Symbol, Kwargs[key: Nilor[Symbol]], Ksplat[RestKeys => Any], Block => nil)
-  def hash(field_name, key: nil, **opts, &blk)
+  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
-    raise ArgumentError, 'invalid :key option value' unless HASH_KEY_OPTION_VALUES.include?(key)
 
-    type = hash_from_blk(key: key, &blk)
+    type = hash_from_blk(dto: dto, &blk)
 
     @mapper.add_field(type, field_name, **opts)
   end
@@ -115,17 +108,12 @@ class ReeMapper::MapperFactory
 
   private
 
-  def hash_from_blk(key:, &blk)
+  def hash_from_blk(dto:, &blk)
     mapper_proxy = self.class.call
 
     strategies = @mapper.strategies.map do |strategy|
       strategy = strategy.dup
-      output = strategy.output
-      if key
-        strategy.output = HASH_KEY_OPTION_MAP.fetch(key).new
-      elsif !(output.is_a?(ReeMapper::SymbolKeyHashOutput) || output.is_a?(ReeMapper::StringKeyHashOutput))
-        strategy.output = ReeMapper::SymbolKeyHashOutput.new
-      end
+      strategy.dto = dto if dto
       strategy
     end
 

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

@@ -24,7 +24,7 @@ class ReeMapper::MapperFactoryProxy
     else
       strategy = mapper_factory.strategies.detect { _1.method == strategy_or_method }
       raise ArgumentError, "MapperFactory strategy :#{strategy_or_method} not found" unless strategy
-      strategy = Marshal.load(Marshal.dump(strategy))
+      strategy = strategy.dup
       strategy.dto = dto if dto
     end
 
@@ -34,6 +34,7 @@ class ReeMapper::MapperFactoryProxy
 
     mapper = ReeMapper::Mapper.build(strategies)
     mapper_factory.new(mapper).instance_exec(&blk)
+    mapper.prepare_dto
 
     mapper_factory.register(register_as, mapper) if register_as
 

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

@@ -3,24 +3,19 @@
 class ReeMapper::MapperStrategy
   attr_reader :method, :always_optional
 
-  contract(Symbol, ReeMapper::StrategyOutput, Bool => Any)
-  def initialize(method:, output:, always_optional:)
+  contract(Symbol, Class, Bool => Any)
+  def initialize(method:, dto:, always_optional:)
     @method          = method
-    @output          = output
+    @output          = build_output(dto)
     @always_optional = always_optional
   end
 
-  contract None => ReeMapper::StrategyOutput
-  def output
-    @output
+  def initialize_dup(_orig)
+    @output = @output.dup
+    super
   end
 
-  contract ReeMapper::StrategyOutput => ReeMapper::StrategyOutput
-  def output=(output)
-    @output = output
-  end
-
-  contract(Any)
+  contract(None => Object)
   def build_object
     output.build_object
   end
@@ -48,13 +43,33 @@ class ReeMapper::MapperStrategy
     end
   end
 
-  contract(Class => Class)
+  contract(Class => nil)
   def dto=(dto)
-    output.dto = dto
+    @output = build_output(dto)
+    nil
   end
 
-  contract(None => Nilor[Class])
+  contract(None => Class)
   def dto
     output.dto
   end
+
+  contract(ArrayOf[Symbol] => nil)
+  def prepare_dto(field_names)
+    output.prepare_dto(field_names)
+  end
+
+  private
+
+  attr_reader :output
+
+  def build_output(dto)
+    if dto == Hash || (defined?(OpenStruct) && dto == OpenStruct)
+      ReeMapper::HashOutput.new(dto)
+    elsif dto == Struct
+      ReeMapper::StructOutput.new
+    else
+      ReeMapper::ObjectOutput.new(dto)
+    end
+  end
 end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/{symbol_key_hash_output.rb → hash_output.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class ReeMapper::SymbolKeyHashOutput < ReeMapper::StrategyOutput
-  contract(Hash)
+class ReeMapper::HashOutput < ReeMapper::StrategyOutput
+  contract(None => Object)
   def build_object
-    Hash.new
+    dto.new
   end
 
   contract(Object, ReeMapper::Field, Any => nil)
@@ -11,4 +11,4 @@ class ReeMapper::SymbolKeyHashOutput < ReeMapper::StrategyOutput
     object[field.name] = value
     nil
   end
-end
+end

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

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
 class ReeMapper::ObjectOutput < ReeMapper::StrategyOutput
-  def initialize(*)
-    @dto = Object
-    super
-  end
-
-  contract(Object)
+  contract(None => Object)
   def build_object
-    @dto.allocate
+    dto.allocate
   end
 
   contract(Object, ReeMapper::Field, Any => nil)

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

@@ -1,21 +1,18 @@
 # frozen_string_literal: true
 
 class ReeMapper::StrategyOutput
-  def build_object
-    raise NotImplementedError
-  end
+  attr_reader :dto
 
-  def assign_value(*)
-    raise NotImplementedError
-  end
-
-  contract(Class => Class)
-  def dto=(dto)
+  contract(Class => Any)
+  def initialize(dto)
     @dto = dto
   end
 
-  contract(None => Nilor[Class])
-  def dto
-    @dto
+  contract(Object, ReeMapper::Field, Any => nil).throws(NotImplementedError)
+  def assign_value(object, field, value)
+    raise NotImplementedError
   end
+
+  contract(ArrayOf[Symbol] => nil)
+  def prepare_dto(field_names); end
 end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ReeMapper::StructOutput < ReeMapper::StrategyOutput
+  contract(None => Any)
+  def initialize; end
+
+  def initialize_dup(orig)
+    @dto = nil
+    super
+  end
+
+  contract(None => Object)
+  def build_object
+    dto.allocate
+  end
+
+  contract(Object, ReeMapper::Field, Any => nil)
+  def assign_value(object, field, value)
+    object[field.name] = value
+    nil
+  end
+
+  contract(ArrayOf[Symbol] => nil)
+  def prepare_dto(field_names)
+    @dto = Struct.new(*field_names)
+    nil
+  end
+end

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

@@ -33,8 +33,8 @@ module ReeMapper
 
   require_relative 'ree_mapper/strategy_outputs/strategy_output'
   require_relative 'ree_mapper/strategy_outputs/object_output'
-  require_relative 'ree_mapper/strategy_outputs/string_key_hash_output'
-  require_relative 'ree_mapper/strategy_outputs/symbol_key_hash_output'
+  require_relative 'ree_mapper/strategy_outputs/hash_output'
+  require_relative 'ree_mapper/strategy_outputs/struct_output'
 
   require_relative 'ree_mapper/mapper_strategy'
   require_relative 'ree_mapper/mapper'
@@ -154,10 +154,10 @@ Create `mapper_factory.rb` file to declare `MapperFactory` class.
 
     def build
       mapper_factory = build_mapper_factory(strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :string_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :object)
+        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: Object)
       ])
 
       mapper_factory.register(:cart_user, user_caster)

data/lib/ree_lib/packages/ree_mapper/schemas/ree_mapper/functions/build_mapper_strategy.schema.json

@@ -10,7 +10,7 @@
     {
       "doc": "",
       "throws": [
-        "ArgumentError"
+
       ],
       "return": "ReeMapper::MapperStrategy",
       "args": [
@@ -19,8 +19,8 @@
           "type": "Symbol"
         },
         {
-          "arg": "output",
-          "type": "Symbol"
+          "arg": "dto",
+          "type": "Class"
         },
         {
           "arg": "always_optional",

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/functions/build_mapper_factory_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe :build_mapper_factory do
 
   it {
     result = build_mapper_factory(strategies: [
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash)
+      build_mapper_strategy(method: :cast, dto: Hash)
     ])
 
     expect(result).to be_a(Class)

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/functions/build_mapper_strategy_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe :build_mapper_strategy do
   link :build_mapper_strategy, from: :ree_mapper
 
   it {
-    result = build_mapper_strategy(method: :cast, output: :symbol_key_hash)
+    result = build_mapper_strategy(method: :cast, dto: Hash)
     
     expect(result).to be_a(ReeMapper::MapperStrategy)
   }

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

@@ -7,7 +7,7 @@ RSpec.describe ReeMapper::MapperFactory do
 
   let(:mapper_factory) {
     build_mapper_factory(strategies: [
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash)
+      build_mapper_strategy(method: :cast, dto: Hash)
     ])
   }
 
@@ -72,5 +72,12 @@ RSpec.describe ReeMapper::MapperFactory do
         end
       }.to raise_error(ArgumentError, 'MapperFactory strategy :not_found not found')
     }
+
+    it {
+      expect {
+        mapper_factory.call.use(:cast) do
+        end
+      }.to raise_error(ReeMapper::ArgumentError, "mapper should contain at least one field")
+    }
   end
 end

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

@@ -4,11 +4,11 @@ RSpec.describe ReeMapper::Mapper do
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
 
-  describe 'input' do
+  describe '#:strategy_method' do
     let(:mapper) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+          build_mapper_strategy(method: :cast, dto: Hash),
         ]
       ).call.use(:cast) do
         integer :my_field
@@ -26,13 +26,19 @@ RSpec.describe ReeMapper::Mapper do
     it {
       expect(mapper.cast(OpenStruct.new({ my_field: 1 }))).to eq({ my_field: 1 })
     }
+
+    it {
+      obj = Object.new
+      obj.define_singleton_method(:my_field) { 1 }
+      expect(mapper.cast(obj)).to eq({ my_field: 1 })
+    }
   end
 
-  describe 'string key hash output' do
+  describe 'hash dto' do
     let(:mapper) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :string_key_hash),
+          build_mapper_strategy(method: :cast, dto: Hash),
         ]
       ).call.use(:cast) do
         integer :my_field
@@ -40,15 +46,15 @@ RSpec.describe ReeMapper::Mapper do
     }
 
     it {
-      expect(mapper.cast({ my_field: 1 })).to eq({ 'my_field' => 1 })
+      expect(mapper.cast({ my_field: 1 })).to eq({ my_field: 1 })
     }
   end
 
-  describe 'string key hash output' do
+  describe 'ostruct dto' do
     let(:mapper) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+          build_mapper_strategy(method: :cast, dto: OpenStruct),
         ]
       ).call.use(:cast) do
         integer :my_field
@@ -56,16 +62,47 @@ RSpec.describe ReeMapper::Mapper do
     }
 
     it {
-      expect(mapper.cast({ my_field: 1 })).to eq({ my_field: 1 })
+      expect(mapper.cast({ my_field: 1 }).to_h).to eq({ my_field: 1 })
+    }
+
+    it {
+      expect(mapper.cast({ my_field: 1 })).to be_a(OpenStruct)
     }
   end
 
-  describe 'object output' do
+  describe 'struct dto' do
+    let(:mapper) {
+      build_mapper_factory(
+        strategies: [
+          build_mapper_strategy(method: :cast, dto: Struct),
+        ]
+      ).call.use(:cast) do
+        integer :my_field
+        hash :hsh do
+          integer :nested_field
+        end
+      end
+    }
+
+    it {
+      nested_struct = Struct.new(:nested_field)
+      struct = Struct.new(:my_field, :hsh)
+      expect(mapper.cast({ my_field: 1, hsh: { nested_field: 1 } }).inspect).to eq(
+        struct.new(1, nested_struct.new(1)).inspect
+      )
+    }
+
+    it { 
+      expect(mapper.cast({ my_field: 1, hsh: { nested_field: 1 } })).to be_a(Struct)
+    }
+  end
+
+  describe 'object dto' do
     let(:dto) { Class.new }
     let(:mapper) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :object),
+          build_mapper_strategy(method: :cast, dto: Object),
         ]
       ).call.use(:cast, dto: dto) do
         integer :my_field
@@ -87,7 +124,7 @@ RSpec.describe ReeMapper::Mapper do
     let(:mapper_factory) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :symbol_key_hash, always_optional: true),
+          build_mapper_strategy(method: :cast, dto: Hash, always_optional: true),
         ]
       )
     }
@@ -101,4 +138,32 @@ RSpec.describe ReeMapper::Mapper do
       expect(mapper.cast({})).to eq({})
     }
   end
+
+  describe '#dto' do
+    let(:mapper_factory) {
+      build_mapper_factory(
+        strategies: [
+          build_mapper_strategy(method: :cast, dto: Hash, always_optional: true),
+          build_mapper_strategy(method: :serialize, dto: Object),
+        ]
+      )
+    }
+    let(:mapper) {
+      mapper_factory.call.use(:cast).use(:serialize, dto: Struct) do
+        integer :my_field
+      end
+    }
+
+    it {
+      expect(mapper.dto(:cast)).to eq(Hash)
+    }
+
+    it {
+      expect(mapper.dto(:serialize)).to be < Struct
+    }
+
+    it {
+      expect { mapper.dto(:db_dump) }.to raise_error(ArgumentError, "there is no :db_dump strategy")
+    }
+  end
 end

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Array' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }
@@ -135,10 +135,10 @@ RSpec.describe 'ReeMapper::Array' do
     }
   end
 
-  context 'with array of hashes with key option' do
+  context 'with array of hashes with dto option' do
     let(:mapper) {
       mapper_factory.call.use(:serialize) {
-        array :coords, key: :string do
+        array :coords, dto: OpenStruct do
           integer :x
           integer :y
         end
@@ -146,8 +146,8 @@ RSpec.describe 'ReeMapper::Array' do
     }
 
     it {
-      expect(mapper.serialize({ coords: [{ x: 1, y: 1 }, { x: 2, y: 2 }] }))
-        .to eq({ coords: [{ 'x' => 1, 'y' => 1 }, { 'x' => 2, 'y' => 2 }] })
+      expect(mapper.serialize({ coords: [{ x: 1, y: 1 }] }))
+        .to eq({ coords: [OpenStruct.new({ x: 1, y: 1 })] })
     }
   end
 end

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Bool' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Date' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::DateTime' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Float' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,7 +7,7 @@ RSpec.describe 'Mapper Hash' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast, output: :symbol_key_hash)
+        build_mapper_strategy(method: :cast, dto: Hash)
       ]
     )
   }
@@ -35,38 +35,16 @@ RSpec.describe 'Mapper Hash' do
     }
   end
 
-  describe 'key: option' do
+  describe 'dto: option' do
     it {
       expect(
         mapper_factory.call.use(:cast) {
-          hash :point, key: :string do
+          hash :point, dto: OpenStruct do
             integer :x
             integer :y
           end
         }.cast({ point: { x: 1, y: 1 } })
-      ).to eq({ point: { 'x' => 1, 'y' => 1 } })
-    }
-
-    it {
-      expect(
-        mapper_factory.call.use(:cast) {
-          hash :point, key: :symbol do
-            integer :x
-            integer :y
-          end
-        }.cast({ point: { x: 1, y: 1 } })
-      ).to eq({ point: { x: 1, y: 1 } })
-    }
-
-    it {
-      expect {
-        mapper_factory.call.use(:cast) {
-          hash :point, key: :whatever do
-            integer :x
-            integer :y
-          end
-        }
-      }.to raise_error(ArgumentError)
+      ).to eq({ point: OpenStruct.new({ x: 1, y: 1 }) })
     }
   end
 
@@ -74,7 +52,7 @@ RSpec.describe 'Mapper Hash' do
     let(:mapper_factory) {
       build_mapper_factory(
         strategies: [
-          build_mapper_strategy(method: :cast, output: :object)
+          build_mapper_strategy(method: :cast, dto: Object)
         ]
       )
     }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Integer' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::String' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::Time' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -7,10 +7,10 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
   let(:mapper_factory) {
     build_mapper_factory(
       strategies: [
-        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
-        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
-        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+        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)
       ]
     )
   }

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

@@ -13,8 +13,8 @@ RSpec.describe :build_endpoint_schema do
 
   let(:mapper_factory) {
     strategies = [
-      build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+      build_mapper_strategy(method: :serialize, dto: Hash),
+      build_mapper_strategy(method: :cast, dto: Hash),
     ]
 
     build_mapper_factory(

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

@@ -1,11 +1,11 @@
 RSpec.describe :build_parameters_spec do
-  link :build_parameters, from: :ree_swagger
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
+  link :build_parameters, from: :ree_swagger
 
   let(:mapper_factory) {
     strategies = [
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+      build_mapper_strategy(method: :cast, dto: Hash),
     ]
 
     build_mapper_factory(

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

@@ -1,11 +1,11 @@
 RSpec.describe :build_request_body_schema_spec do
-  link :build_request_body_schema, from: :ree_swagger
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
+  link :build_request_body_schema, from: :ree_swagger
 
   let(:mapper_factory) {
     strategies = [
-      build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+      build_mapper_strategy(method: :cast, dto: Hash),
     ]
 
     build_mapper_factory(

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 RSpec.describe :build_serializer_schema do
-  link :build_serializer_schema, from: :ree_swagger
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
+  link :build_serializer_schema, from: :ree_swagger
 
   let(:mapper_factory) {
     strategies = [
-      build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+      build_mapper_strategy(method: :serialize, dto: Hash),
     ]
 
     build_mapper_factory(

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

@@ -1,8 +1,8 @@
 RSpec.describe :register_type do
-  link :register_type, from: :ree_swagger
-  link :build_serializer_schema, from: :ree_swagger
   link :build_mapper_factory, from: :ree_mapper
   link :build_mapper_strategy, from: :ree_mapper
+  link :build_serializer_schema, from: :ree_swagger
+  link :register_type, from: :ree_swagger
 
   class ReeSwagger::MyType < ReeMapper::AbstractType
     def serialize(obj, role: nil)
@@ -12,7 +12,7 @@ RSpec.describe :register_type do
 
   let(:mapper_factory) {
     strategies = [
-      build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+      build_mapper_strategy(method: :serialize, dto: Hash),
     ]
 
     build_mapper_factory(strategies: strategies).register(

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.30
+  version: 1.0.31
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-07 00:00:00.000000000 Z
+date: 2023-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -921,10 +921,10 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_factory.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_factory_proxy.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_strategy.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/hash_output.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/object_output.rb
 - 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/string_key_hash_output.rb
-- lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/symbol_key_hash_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/bool.rb

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-class ReeMapper::StringKeyHashOutput < ReeMapper::StrategyOutput
-  contract(Hash)
-  def build_object
-    Hash.new
-  end
-
-  contract(Object, ReeMapper::Field, Any => nil)
-  def assign_value(object, field, value)
-    object[field.name_as_str] = value
-    nil
-  end
-end