ree_lib 1.0.20 → 1.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6972cd73aa8f6a7837528ca839deab2958095a3d23ad8fdb07a0db7963354669
-  data.tar.gz: 9439598c7328cca53fa6bfb7fe580725d55630793634d2674ad10e1a3dc96578
+  metadata.gz: f6ae0f9daf43194e577174cd9d39c1516e301a5c53b05f0ab5a3467b0cb4b704
+  data.tar.gz: e333d78c1cf0f28bee7797be4b2718898f094c431a5abec04256f93e9ff6e450
 SHA512:
-  metadata.gz: 720520759e9483422ca206093e0f22e8cc7a490442a7cea13eae70b77be60e31895fc2180faf916a250ddd58a1a0a3e43d7ae1bdb417c88079b6f7cddcc51355
-  data.tar.gz: ebbea5de6b75a32c2f6c2ab7d6889258aa323121a578d575fbe77db3bf4004566b46ce747fb69a58067a5bda91246ca30df0cc00af1f19c3c74bde9fceb7fe0e
+  metadata.gz: f7282239063aebfcf7c1c6552980ef933ac48efc47cc28afdf28b65ad82913af52c71f6b8b0f45f733967633033235e2e82856d95b91b9935ed98b13c4656199
+  data.tar.gz: 4eae3f07e6a0808da7f32c791ff06ec9c414f7cb6c818ec845bd79b7825983e58a0baec5f63a403d7ae660ebbea07fdc9b1873d6ed34cdd0424bc212d6943fd9

data/Gemfile.lock

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

data/lib/ree_lib/packages/ree_dao/package/ree_dao/dataset_extensions.rb

@@ -111,16 +111,20 @@ module ReeDao
       end
 
       def update(entity)
-        raw = opts[:schema_mapper].db_dump(entity)
-        raw = extract_changes(entity, raw)
+        if opts[:schema_mapper]
+          raw = opts[:schema_mapper].db_dump(entity)
+          raw = extract_changes(entity, raw)
+
+          unless raw.empty?
+            update_persistence_state(entity, raw)
+            key_condition = prepare_key_condition_from_entity(entity)
+            where(key_condition).__original_update(raw)
+          end
 
-        unless raw.empty?
-          update_persistence_state(entity, raw)
-          key_condition = prepare_key_condition_from_entity(entity)
-          where(key_condition).__original_update(raw)
+          entity
+        else
+          __original_update(entity)
         end
-
-        entity
       end
 
       def delete(entity = nil)

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/find_human_time_zones_by_offset_spec.rb

@@ -6,7 +6,6 @@ RSpec.describe :find_human_time_zones_by_offset do
   it {
     gmt_12 = find_human_time_zones_by_offset("+12:00")
 
-    expect(gmt_12.length).to eq(4)
     expect(gmt_12).to be_a(Array)
   }
 end

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/find_time_zones_by_offset_spec.rb

@@ -6,7 +6,6 @@ RSpec.describe :find_time_zones_by_offset do
   it {
     gmt_12 = find_time_zones_by_offset("+12:00")
 
-    expect(gmt_12.length).to eq(16)
     expect(gmt_12).to be_a(Array)
   }
 end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::ArgumentError < ReeMapper::Error
+end

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

@@ -2,7 +2,8 @@
 
 class ReeMapper::Field
   attr_reader :type, :name, :from, :doc, :optional, :null, :roles, :default,
-              :name_as_str, :name_as_instance_var_name, :from_as_str
+              :name_as_str, :name_as_instance_var_name, :from_as_str,
+              :fields_filter
 
   NO_DEFAULT = Object.new.freeze
 
@@ -15,10 +16,13 @@ class ReeMapper::Field
       optional: Bool,
       null:     Bool,
       role:     Nilor[ArrayOf[Symbol], Symbol],
-      default:  Any
+      default:  Any,
+      only:     Nilor[ReeMapper::FilterFieldsContract],
+      except:   Nilor[ReeMapper::FilterFieldsContract]
     ] => Any
   ).throws(ArgumentError)
-  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT)
+  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT, 
+                 only: nil, except: nil)
     @type     = type
     @name     = name
     @from     = from || name
@@ -28,6 +32,8 @@ class ReeMapper::Field
     @roles    = Array(role)
     @default  = default
 
+    @fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
+
     @name_as_str               = @name.to_s
     @name_as_instance_var_name = :"@#{@name}"
     @from_as_str               = @from.to_s

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class ReeMapper::FieldsFilter
+  class OnlyStrategy
+    def initialize(only, except)
+      @fields = Set.new
+
+      only.each do |item|
+        if item.is_a? Symbol
+          @fields << item
+        else
+          item.each do |key, val|
+            @fields << key
+          end
+        end
+      end
+
+      if !except.nil?
+        except.each do |item|
+          if item.is_a? Symbol
+            @fields.delete item
+          else
+            item.each do |key, val|
+              @fields.delete key
+            end
+          end
+        end
+      end
+    end
+
+    def allow?(field)
+      fields.include? field
+    end
+
+    private
+    attr_reader :fields
+  end
+
+  class ExceptStrategy
+    def initialize(except)
+      @fields = Set.new
+
+      except&.each do |item|
+        if item.is_a? Symbol
+          @fields << item
+        end
+      end
+    end
+
+    def allow?(field)
+      !fields.include?(field)
+    end
+
+    private
+    attr_reader :fields
+  end
+
+  class NoneStrategy
+    def self.allow?(field)
+      true
+    end
+  end
+
+  def self.empty_filter
+    @empty_filter ||= new(NoneStrategy, {}).freeze
+  end
+
+  contract Nilor[ReeMapper::FilterFieldsContract], Nilor[ReeMapper::FilterFieldsContract] => Any
+  def self.build(only:, except:)
+    return empty_filter if only.nil? && except.nil?
+
+    strategy = if !only.nil?
+      OnlyStrategy.new(only, except)
+    elsif !except.nil?
+      ExceptStrategy.new(except)
+    else
+      NoneStrategy
+    end
+
+    nested_fields_filters = {}
+    
+    only = only&.select { _1.is_a? Hash }&.reduce(&:merge)
+    except = except&.select { _1.is_a? Hash }&.reduce(&:merge)
+
+    only&.each { nested_fields_filters[_1] = build(only: _2, except: except&.dig(_1)) }
+    except&.each { nested_fields_filters[_1] ||= build(only: nil, except: _2) }
+
+    new(strategy, nested_fields_filters)
+  end
+
+  def initialize(strategy, nested_fields_filters)
+    @strategy              = strategy
+    @nested_fields_filters = nested_fields_filters
+  end
+
+  def allow?(field)
+    strategy.allow?(field)
+  end
+
+  def filter_for(field)
+    nested_fields_filters.fetch(field, self.class.empty_filter)
+  end
+
+  private
+  attr_reader :strategy, :nested_fields_filters
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ReeMapper::FilterFieldsContract
+  def self.valid?(value)
+    return false unless value.is_a? Array
+
+    value.each do |item|
+      next if item.is_a? Symbol
+      return false unless item.is_a? Hash
+
+      item.each do |key, val|
+        return false unless key.is_a?(Symbol)
+        return false unless valid?(val)
+      end
+    end
+
+    true
+  end
+
+  def self.to_s
+    "FilterFieldsContract"
+  end
+
+  def self.message(*)
+    "Invalid filter fields contract"
+  end
+end

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

@@ -19,34 +19,58 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil)
-              @type.#{method}(obj, name: name, role: role)
+            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
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil)
+            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: [])
+              if only && !ReeMapper::FilterFieldsContract.valid?(only)
+                raise ReeMapper::ArgumentError, "Invalid `only` format"
+              end
+
+              if except && !ReeMapper::FilterFieldsContract.valid?(except)
+                raise ReeMapper::ArgumentError, "Invalid `except` format"
+              end
+
+              user_fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
+
               @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
+                field_fields_filters = fields_filters + [user_fields_filter]
+
+                next unless field_fields_filters.all? { _1.allow? field.name }
                 next unless field.has_role?(role)
-                nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
-
-                if @#{method}_strategy.has_value?(obj, field)
-                  value = @#{method}_strategy.get_value(obj, field)
-                  unless value.nil? && field.null
-                    value = field.type.#{method}(value, name: nested_name, role: role)
-                  end
-                  @#{method}_strategy.assign_value(acc, field, value)
-                elsif field.optional || @#{method}_strategy.always_optional
-                  if field.has_default?
-                    value = field.default
-                    unless value.nil? && field.null
-                      value = field.type.#{method}(value, name: nested_name, role: role)
-                    end
-                    @#{method}_strategy.assign_value(acc, field, value)
-                  end
-                else
+
+                is_with_value = @#{method}_strategy.has_value?(obj, field)
+                is_optional = field.optional || @#{method}_strategy.always_optional
+
+                if !is_with_value && !is_optional
                   raise ReeMapper::TypeError, "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`"
                 end
+
+                next if !is_with_value && !field.has_default?
+
+                value = if is_with_value
+                  @#{method}_strategy.get_value(obj, field)
+                else
+                  field.default
+                end
+
+                unless value.nil? && field.null
+                  nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
+
+                  nested_fields_filters = field_fields_filters.map { _1.filter_for(field.name) }
+                  nested_fields_filters += [field.fields_filter]
+
+                  value = field.type.#{method}(value, name: nested_name, role: role, fields_filters: nested_fields_filters)
+                end
+
+                @#{method}_strategy.assign_value(acc, field, value)
               end
             end
           RUBY

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

@@ -76,6 +76,7 @@ class ReeMapper::MapperFactory
     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 :only and :except keys' if opts.key?(:only) || opts.key?(:except)
 
     if blk
       each = ReeMapper::Field.new(

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

@@ -8,14 +8,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     @of = of
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def serialize(value, name:, role: nil)
+  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
           _1
         else
-          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -23,14 +24,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def cast(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
+    .throws(ReeMapper::TypeError)
+  def cast(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.cast(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -38,14 +40,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
+    .throws(ReeMapper::TypeError)
+  def db_dump(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else
@@ -53,14 +56,15 @@ class ReeMapper::Array < ReeMapper::AbstractType
     end
   end
 
-  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil)
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
+    .throws(ReeMapper::TypeError)
+  def db_load(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
         if _1.nil? && of.null
           _1
         else
-          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role)
+          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
         end
       }
     else

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

@@ -16,7 +16,10 @@ module ReeMapper
   require_relative 'ree_mapper/errors/coercion_error'
   require_relative 'ree_mapper/errors/type_error'
   require_relative 'ree_mapper/errors/unsupported_type_error'
+  require_relative 'ree_mapper/errors/argument_error'
 
+  require_relative 'ree_mapper/filter_fields_contract'
+  require_relative 'ree_mapper/fields_filter'
   require_relative 'ree_mapper/field'
 
   require_relative 'ree_mapper/types/bool'

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

@@ -15,6 +15,142 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     )
   }
 
+  describe 'only and except' do
+    before {
+      mapper_factory.call(register_as: :point).use(:cast) {
+        integer :x
+        integer :y
+        integer :z
+      } 
+    }
+
+    context 'with only' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :id
+          integer? :opt_id
+          point :point, only: [:x, :y]
+        }
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1, y: 1 } })).to eq({ id: 1, point: { x: 1, y: 1 } })
+      }
+
+      it {
+        expect(mapper.cast({ opt_id: 1, point: { x: 1 } }, only: [:opt_id, point: [:x]])).to eq({ opt_id: 1, point: { x: 1 } })
+      }
+    end
+
+    context 'with except' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :id
+          point :point, except: [:z]
+        }
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1, y: 1 } })).to eq({ id: 1, point: { x: 1, y: 1 } })
+      }
+
+      it {
+        expect(mapper.cast({ id: 1, point: { x: 1 } }, except: [:id, point: [:y]])).to eq({ point: { x: 1 } })
+      }
+    end
+
+    context 'with only and except' do
+      let(:mapper) {
+        mapper_factory.call.use(:cast) {
+          integer :included
+          integer :excluded
+          point :point, only: [:x, :y], except: [:y]
+
+          hash :matrix do
+            point :x, only: [:x]
+            point :y, except: [:x, :z]
+          end
+
+          array :points, each: point(only: [:x, :y])
+        }
+      }
+
+      it {
+        expect(mapper.cast(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1}]
+          }
+        )).to eq(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1 }]
+          }
+        )
+      }
+
+      it {
+        expect(mapper.cast(
+          {
+            included: 1,
+            excluded: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 }, y: { y: 1 } },
+            points: [{ x: 1, y: 1}]
+          },
+          only: [:included, point: [:x], matrix: [x: [:x]], points: [:x]]
+        )).to eq(
+          {
+            included: 1,
+            point: { x: 1 },
+            matrix: { x: { x: 1 } },
+            points: [{ x: 1 }]
+          }
+        )
+      }
+    end
+
+    context 'with invalid only' 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
+        }
+      }
+
+      it {
+        expect {
+          mapper.cast({}, except: {})
+        }.to raise_error(
+          ReeMapper::ArgumentError,
+          "Invalid `except` format"
+        )
+      }
+    end
+  end
+
   describe 'from:' do
     let(:mapper) {
       mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.20
+  version: 1.0.21
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-28 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -906,11 +906,14 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/default_factory.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/dsl.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/argument_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/coercion_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/type_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/unsupported_type_error.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/field.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/fields_filter.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/filter_fields_contract.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_factory.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_strategy.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper.rb