serega 0.10.0 → 0.11.0

data/lib/serega/plugins/preloads/lib/format_user_preloads.rb

@@ -7,17 +7,6 @@ class Serega
       # Utility that helps to transform user provided preloads to hash
       #
       class FormatUserPreloads
-        METHODS = {
-          Array => :array_to_hash,
-          FalseClass => :nil_to_hash,
-          Hash => :hash_to_hash,
-          NilClass => :nil_to_hash,
-          String => :string_to_hash,
-          Symbol => :symbol_to_hash
-        }.freeze
-
-        private_constant :METHODS
-
         class << self
           #
           # Transforms user provided preloads to hash
@@ -27,7 +16,16 @@ class Serega
           # @return [Hash] preloads transformed to hash
           #
           def call(value)
-            send(METHODS.fetch(value.class), value)
+            case value
+            when Array then array_to_hash(value)
+            when FalseClass then nil_to_hash(value)
+            when Hash then hash_to_hash(value)
+            when NilClass then nil_to_hash(value)
+            when String then string_to_hash(value)
+            when Symbol then symbol_to_hash(value)
+            else raise Serega::SeregaError,
+              "Preload option value can consist from Symbols, Arrays, Hashes (#{value.class} #{value.inspect} was provided)"
+            end
           end
 
           private
@@ -49,7 +47,7 @@ class Serega
           end
 
           def string_to_hash(value)
-            symbol_to_hash(value.to_sym)
+            {value.to_sym => {}}
           end
 
           def symbol_to_hash(value)

data/lib/serega/plugins/preloads/lib/main_preload_path.rb

@@ -22,9 +22,9 @@ class Serega
           #
           # @return [Array<Symbol>] Preloads path to `main` element
           def call(preloads)
-            return FROZEN_EMPTY_ARRAY if preloads.empty?
+            return FROZEN_EMPTY_ARRAY if !preloads || preloads.empty?
 
-            main_path(preloads)
+            main_path(preloads).freeze
           end
 
           private

data/lib/serega/plugins/preloads/lib/preloads_constructor.rb

@@ -4,39 +4,39 @@ class Serega
   module SeregaPlugins
     module Preloads
       #
-      # Finds preloads for provided attributes map
+      # Finds preloads for provided attributes plan
       #
       class PreloadsConstructor
         class << self
           #
-          # Constructs preloads hash for given attributes map
+          # Constructs preloads hash for given attributes plan
           #
-          # @param map [Array<Serega::MapPoint>] Serialization map
+          # @param plan [Array<Serega::PlanPoint>] Serialization plan
           #
           # @return [Hash]
           #
-          def call(map)
-            return FROZEN_EMPTY_HASH unless map
+          def call(plan)
+            return FROZEN_EMPTY_HASH unless plan
 
             preloads = {}
-            append_many(preloads, map)
+            append_many(preloads, plan)
             preloads
           end
 
           private
 
-          def append_many(preloads, map)
-            map.each do |point|
+          def append_many(preloads, plan)
+            plan.points.each do |point|
               current_preloads = point.attribute.preloads
               next unless current_preloads
 
-              has_nested = point.has_nested_points?
-              current_preloads = SeregaUtils::EnumDeepDup.call(current_preloads) if has_nested
+              child_plan = point.child_plan
+              current_preloads = SeregaUtils::EnumDeepDup.call(current_preloads) if child_plan
               append_current(preloads, current_preloads)
-              next unless has_nested
+              next unless child_plan
 
-              nested_preloads = nested(preloads, point.preloads_path)
-              append_many(nested_preloads, point.nested_points)
+              child_preloads = dig?(preloads, point.preloads_path)
+              append_many(child_preloads, child_plan)
             end
           end
 
@@ -50,8 +50,14 @@ class Serega
             end
           end
 
-          def nested(preloads, path)
-            (!path || path.empty?) ? preloads : preloads.dig(*path)
+          def dig?(hash, path)
+            return hash if !path || path.empty?
+
+            path.each do |point|
+              hash = hash[point]
+            end
+
+            hash
           end
         end
       end

data/lib/serega/plugins/preloads/preloads.rb

@@ -81,12 +81,12 @@ class Serega
       def self.load_plugin(serializer_class, **_opts)
         serializer_class.include(InstanceMethods)
         serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
+        serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
         serializer_class::SeregaConfig.include(ConfigInstanceMethods)
-        serializer_class::SeregaMapPoint.include(MapPointInstanceMethods)
+        serializer_class::SeregaPlanPoint.include(PlanPointInstanceMethods)
 
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
 
-        require_relative "./lib/enum_deep_freeze"
         require_relative "./lib/format_user_preloads"
         require_relative "./lib/main_preload_path"
         require_relative "./lib/preloads_constructor"
@@ -122,7 +122,7 @@ class Serega
       module InstanceMethods
         # @return [Hash] merged preloads of all serialized attributes
         def preloads
-          @preloads ||= PreloadsConstructor.call(map)
+          @preloads ||= PreloadsConstructor.call(plan)
         end
       end
 
@@ -199,50 +199,54 @@ class Serega
       # @see Serega::SeregaAttribute::AttributeInstanceMethods
       #
       module AttributeInstanceMethods
-        # @return [Hash,nil] formatted preloads of current attribute
-        def preloads
-          return @preloads if defined?(@preloads)
+        # @return [Hash, nil] normalized preloads of current attribute
+        attr_reader :preloads
 
-          @preloads = get_preloads
-        end
+        # @return [Array] normalized preloads_path of current attribute
+        attr_reader :preloads_path
 
-        # @return [Array] formatted preloads_path of current attribute
-        def preloads_path
-          return @preloads_path if defined?(@preloads_path)
+        private
 
-          @preloads_path = get_preloads_path
+        def set_normalized_vars(normalizer)
+          super
+          @preloads = normalizer.preloads
+          @preloads_path = normalizer.preloads_path
         end
+      end
 
-        # Patch for original `hide` method
-        #
-        # Marks attribute hidden if auto_hide_attribute_with_preloads option was set and attribute has preloads
-        #
-        # @return [Boolean, nil] if attribute is hidden
-        #
-        # @see Serega::SeregaAttribute::AttributeInstanceMethods#hide
-        #
-        def hide
-          res = super
-          return res unless res.nil?
+      #
+      # SeregaAttributeNormalizer additional/patched instance methods
+      #
+      # @see SeregaAttributeNormalizer::AttributeInstanceMethods
+      #
+      module AttributeNormalizerInstanceMethods
+        # @return [Hash,nil] normalized attribute preloads
+        def preloads
+          return @preloads if instance_variable_defined?(:@preloads)
 
-          auto_hide_attribute_with_preloads? || nil
+          @preloads = prepare_preloads
         end
 
-        private
+        # @return [Array, nil] normalized attribute preloads path
+        def preloads_path
+          return @preloads_path if instance_variable_defined?(:@preloads_path)
 
-        def auto_hide_attribute_with_preloads?
-          auto = self.class.serializer_class.config.preloads.auto_hide_attributes_with_preload
-          @auto_hide_attribute_with_preloads = auto && !preloads.nil? && (preloads != false) && (preloads != {})
+          @preloads_path = prepare_preloads_path
         end
 
+        private
+
+        #
         # Patched in:
         # - plugin :batch (extension :preloads - skips auto preloads when batch option provided)
-        def get_preloads
+        #
+        def prepare_preloads
+          opts = init_opts
           preloads_provided = opts.key?(:preload)
           preloads =
             if preloads_provided
               opts[:preload]
-            elsif relation? && self.class.serializer_class.config.preloads.auto_preload_attributes_with_serializer
+            elsif opts.key?(:serializer) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_serializer
               key
             elsif opts.key?(:delegate) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_delegate
               opts[:delegate].fetch(:to)
@@ -255,30 +259,58 @@ class Serega
           FormatUserPreloads.call(preloads)
         end
 
-        def get_preloads_path
-          path = Array(opts[:preload_path]).map!(&:to_sym)
+        def prepare_preloads_path
+          opts = init_opts
+          path = Array(opts[:preload_path]).map!(&:to_sym).freeze
           path = MainPreloadPath.call(preloads) if path.empty?
-          EnumDeepFreeze.call(path)
+          path
+        end
+
+        #
+        # Patch for original `prepare_hide` method
+        #
+        # Marks attribute hidden if auto_hide_attribute_with_preloads option was set and attribute has preloads
+        #
+        def prepare_hide
+          res = super
+          return res unless res.nil?
+
+          if preloads && !preloads.empty?
+            self.class.serializer_class.config.preloads.auto_hide_attributes_with_preload || nil
+          end
         end
       end
 
       #
-      # Serega::SeregaMapPoint additional/patched instance methods
+      # Serega::SeregaPlanPoint additional/patched instance methods
       #
-      # @see Serega::SeregaMapPoint::InstanceMethods
+      # @see Serega::SeregaPlanPoint::InstanceMethods
       #
-      module MapPointInstanceMethods
+      module PlanPointInstanceMethods
         #
         # @return [Hash] preloads for nested attributes
         #
-        def preloads
-          @preloads ||= PreloadsConstructor.call(nested_points)
-        end
+        attr_reader :preloads
 
         #
         # @return [Array<Symbol>] preloads path for current attribute
         #
-        def preloads_path
+        attr_reader :preloads_path
+
+        private
+
+        def set_normalized_vars
+          super
+
+          @preloads = prepare_preloads
+          @preloads_path = prepare_preloads_path
+        end
+
+        def prepare_preloads
+          PreloadsConstructor.call(child_plan)
+        end
+
+        def prepare_preloads_path
           attribute.preloads_path
         end
       end

data/lib/serega/plugins/presenter/presenter.rb

@@ -80,15 +80,6 @@ class Serega
       # @see Serega
       #
       module ClassMethods
-        # Overrides {Serega::ClassMethods#attribute} method, additionally adds method
-        # to Presenter to not hit {Serega::SeregaPlugins::Presenter::Presenter#method_missing}
-        # @see Serega::ClassMethods#attribute
-        def attribute(_name, **_opts, &_block)
-          super.tap do |attribute|
-            self::Presenter.def_delegator(:__getobj__, attribute.key) unless attribute.block
-          end
-        end
-
         private
 
         def inherited(subclass)

data/lib/serega/plugins/string_modifiers/parse_string_modifiers.rb

@@ -75,11 +75,21 @@ class Serega
             name = attribute.to_sym
             attribute.clear
 
-            current_attrs = (!path_stack || path_stack.empty?) ? res : res.dig(*path_stack)
+            current_attrs = dig?(res, path_stack)
             current_attrs[name] = nested_attributes
 
             name
           end
+
+          def dig?(hash, path)
+            return hash if !path || path.empty?
+
+            path.each do |point|
+              hash = hash[point]
+            end
+
+            hash
+          end
         end
       end
     end

data/lib/serega/plugins.rb

@@ -13,7 +13,7 @@ class Serega
       # @param mod [Module] Plugin module
       #
       # @example Register plugin
-      #   Serega::SeregaPlugins.register_plugin(:plugin_name, PluginModule)
+      #   SeregaPlugins.register_plugin(:plugin_name, PluginModule)
       #
       # @return [void]
       #
@@ -29,10 +29,10 @@ class Serega
       # @raise [SeregaError] Raises SeregaError when plugin was not found
       #
       # @example Find plugin when providing name
-      #   Serega::SeregaPlugins.find_plugin(:presenter) # => Serega::SeregaPlugins::Presenter
+      #   SeregaPlugins.find_plugin(:presenter) # => SeregaPlugins::Presenter
       #
       # @example Find plugin when providing plugin itself
-      #   Serega::SeregaPlugins.find_plugin(Presenter) # => Presenter
+      #   SeregaPlugins.find_plugin(Presenter) # => Presenter
       #
       # @return [Class<Module>] Plugin core module
       #

data/lib/serega/utils/enum_deep_dup.rb

@@ -7,40 +7,40 @@ class Serega
   module SeregaUtils
     #
     # Duplicates nested hashes and arrays
+    # It does not duplicate any non-Array and non-Hash values
     #
     class EnumDeepDup
-      DUP = {
-        Hash => ->(data) { dup_hash_values(data) },
-        Array => ->(data) { dup_array_values(data) }
-      }.freeze
-      private_constant :DUP
-
       class << self
         #
-        # Deeply duplicate provided data
+        # Deeply duplicate provided Array or Hash data
+        # It does not duplicate any non-Array and non-Hash values
         #
         # @param data [Hash, Array] Data to duplicate
         #
         # @return [Hash, Array] Duplicated data
         #
         def call(data)
-          duplicate_data = data.dup
-          DUP.fetch(duplicate_data.class).call(duplicate_data)
-          duplicate_data
+          case data
+          when Hash
+            # https://github.com/fastruby/fast-ruby#hash-vs-hashdup-code
+            data = Hash[data] # rubocop:disable Style/HashConversion
+            dup_hash_values(data)
+          when Array
+            data = data.dup
+            dup_array_values(data)
+          end
+
+          data
         end
 
         private
 
-        def dup_hash_values(duplicate_data)
-          duplicate_data.each do |key, value|
-            duplicate_data[key] = call(value) if value.is_a?(Enumerable)
-          end
+        def dup_hash_values(data)
+          data.transform_values! { |value| call(value) }
         end
 
-        def dup_array_values(duplicate_data)
-          duplicate_data.map! do |value|
-            value.is_a?(Enumerable) ? call(value) : value
-          end
+        def dup_array_values(data)
+          data.map! { |value| call(value) }
         end
       end
     end

data/lib/serega/utils/enum_deep_freeze.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Utilities
+  #
+  module SeregaUtils
+    #
+    # Utility to freeze nested hashes and arrays
+    #
+    class EnumDeepFreeze
+      class << self
+        #
+        # Freezes nested hashes and arrays
+        #
+        # @param data[Hash, Array] data to freeze
+        #
+        # @return [Hash, Array] same deeply frozen data
+        #
+        def call(data)
+          case data
+          when Hash
+            data.transform_values! { |value| call(value) }
+            data.freeze
+          when Array
+            data.map! { |value| call(value) }
+            data.freeze
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/serega/utils/to_hash.rb

@@ -38,31 +38,39 @@ class Serega
         private
 
         def array_to_hash(values)
-          return Serega::FROZEN_EMPTY_HASH if values.empty?
+          return FROZEN_EMPTY_HASH if values.empty?
 
-          values.each_with_object({}) do |value, obj|
-            obj.merge!(call(value))
+          res = {}
+          values.each do |value|
+            case value
+            when String then res[value.to_sym] = FROZEN_EMPTY_HASH
+            when Symbol then res[value] = FROZEN_EMPTY_HASH
+            else res.merge!(call(value))
+            end
           end
+          res
         end
 
         def hash_to_hash(values)
-          return Serega::FROZEN_EMPTY_HASH if values.empty?
+          return FROZEN_EMPTY_HASH if values.empty?
 
-          values.each_with_object({}) do |(key, value), obj|
-            obj[key.to_sym] = call(value)
+          res = {}
+          values.each do |key, value|
+            res[key.to_sym] = call(value)
           end
+          res
         end
 
         def nil_to_hash(_value)
-          Serega::FROZEN_EMPTY_HASH
+          FROZEN_EMPTY_HASH
         end
 
         def string_to_hash(value)
-          symbol_to_hash(value.to_sym)
+          {value.to_sym => FROZEN_EMPTY_HASH}
         end
 
         def symbol_to_hash(value)
-          {value => Serega::FROZEN_EMPTY_HASH}
+          {value => FROZEN_EMPTY_HASH}
         end
       end
     end

data/lib/serega.rb

@@ -16,11 +16,13 @@ end
 require_relative "serega/errors"
 require_relative "serega/helpers/serializer_class_helper"
 require_relative "serega/utils/enum_deep_dup"
+require_relative "serega/utils/enum_deep_freeze"
 require_relative "serega/utils/symbol_name"
 require_relative "serega/utils/to_hash"
 require_relative "serega/json/adapter"
 
 require_relative "serega/attribute"
+require_relative "serega/attribute_normalizer"
 require_relative "serega/validations/utils/check_allowed_keys"
 require_relative "serega/validations/utils/check_opt_is_bool"
 require_relative "serega/validations/utils/check_opt_is_hash"
@@ -41,8 +43,8 @@ require_relative "serega/validations/check_serialize_params"
 
 require_relative "serega/config"
 require_relative "serega/object_serializer"
-require_relative "serega/map_point"
-require_relative "serega/map"
+require_relative "serega/plan_point"
+require_relative "serega/plan"
 require_relative "serega/plugins"
 
 class Serega
@@ -227,13 +229,17 @@ class Serega
       attribute_class.serializer_class = subclass
       subclass.const_set(:SeregaAttribute, attribute_class)
 
-      map_class = Class.new(self::SeregaMap)
-      map_class.serializer_class = subclass
-      subclass.const_set(:SeregaMap, map_class)
+      attribute_normalizer_class = Class.new(self::SeregaAttributeNormalizer)
+      attribute_normalizer_class.serializer_class = subclass
+      subclass.const_set(:SeregaAttributeNormalizer, attribute_normalizer_class)
 
-      map_point_class = Class.new(self::SeregaMapPoint)
-      map_point_class.serializer_class = subclass
-      subclass.const_set(:SeregaMapPoint, map_point_class)
+      plan_class = Class.new(self::SeregaPlan)
+      plan_class.serializer_class = subclass
+      subclass.const_set(:SeregaPlan, plan_class)
+
+      plan_point_class = Class.new(self::SeregaPlanPoint)
+      plan_point_class.serializer_class = subclass
+      subclass.const_set(:SeregaPlanPoint, plan_point_class)
 
       object_serializer_class = Class.new(self::SeregaObjectSerializer)
       object_serializer_class.serializer_class = subclass
@@ -253,7 +259,8 @@ class Serega
 
       # Assign same attributes
       attributes.each_value do |attr|
-        subclass.attribute(attr.name, **attr.opts, &attr.block)
+        params = attr.initials
+        subclass.attribute(params[:name], **params[:opts], &params[:block])
       end
 
       super
@@ -332,12 +339,12 @@ class Serega
     end
 
     #
-    # Array of MapPoints, which are attributes combined with nested attributes.
-    # This map can be traversed to find currently serializing attributes.
+    # Plan for serialization.
+    # This plan can be traversed to find serialized attributes and nested attributes.
     #
-    # @return [Array<Serega::SeregaMapPoint>] map
-    def map
-      @map ||= self.class::SeregaMap.call(opts)
+    # @return [Array<Serega::SeregaPlanPoint>] plan
+    def plan
+      @plan ||= self.class::SeregaPlan.call(opts)
     end
 
     private
@@ -373,7 +380,7 @@ class Serega
     # - plugin :metadata (adds metadata to final result)
     def serialize(object, opts)
       self.class::SeregaObjectSerializer
-        .new(**opts, points: map)
+        .new(**opts, plan: plan)
         .serialize(object)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2023-04-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -29,20 +29,20 @@ files:
 - VERSION
 - lib/serega.rb
 - lib/serega/attribute.rb
+- lib/serega/attribute_normalizer.rb
 - lib/serega/config.rb
 - lib/serega/errors.rb
 - lib/serega/helpers/serializer_class_helper.rb
 - lib/serega/json/adapter.rb
 - lib/serega/json/json.rb
 - lib/serega/json/oj.rb
-- lib/serega/map.rb
-- lib/serega/map_point.rb
 - lib/serega/object_serializer.rb
+- lib/serega/plan.rb
+- lib/serega/plan_point.rb
 - lib/serega/plugins.rb
 - lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb
 - lib/serega/plugins/activerecord_preloads/lib/preloader.rb
 - lib/serega/plugins/batch/batch.rb
-- lib/serega/plugins/batch/lib/batch_option_model.rb
 - lib/serega/plugins/batch/lib/loader.rb
 - lib/serega/plugins/batch/lib/loaders.rb
 - lib/serega/plugins/batch/lib/plugins_extensions/activerecord_preloads.rb
@@ -65,7 +65,6 @@ files:
 - lib/serega/plugins/metadata/validations/check_opt_hide_nil.rb
 - lib/serega/plugins/metadata/validations/check_opts.rb
 - lib/serega/plugins/metadata/validations/check_path.rb
-- lib/serega/plugins/preloads/lib/enum_deep_freeze.rb
 - lib/serega/plugins/preloads/lib/format_user_preloads.rb
 - lib/serega/plugins/preloads/lib/main_preload_path.rb
 - lib/serega/plugins/preloads/lib/preloads_constructor.rb
@@ -77,6 +76,7 @@ files:
 - lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
 - lib/serega/utils/enum_deep_dup.rb
+- lib/serega/utils/enum_deep_freeze.rb
 - lib/serega/utils/symbol_name.rb
 - lib/serega/utils/to_hash.rb
 - lib/serega/validations/attribute/check_block.rb