serega 0.21.0 → 0.30.0

data/lib/serega/plan_point.rb

@@ -25,6 +25,14 @@ class Serega
       # @return [Hash] Attributes to serialize
       attr_reader :modifiers
 
+      # Shows preloads for nested attributes
+      # @return [Hash] preloads for nested attributes
+      attr_reader :preloads
+
+      # Shows preloads_path for current attribute
+      # @return [Array<Symbol>, nil] preloads path for current attribute
+      attr_reader :preloads_path
+
       #
       # Initializes plan point
       #
@@ -46,8 +54,8 @@ class Serega
 
       # Attribute `value`
       # @see SeregaAttribute::AttributeInstanceMethods#value
-      def value(obj, ctx)
-        attribute.value(obj, ctx)
+      def value(obj, ctx, batches: nil)
+        attribute.value(obj, ctx, batches: batches)
       end
 
       # Attribute `name`
@@ -68,6 +76,16 @@ class Serega
         attribute.serializer
       end
 
+      def batch?
+        !attribute.batch_loaders.empty?
+      end
+
+      # Attribute `batch_loaders`
+      # @see SeregaAttribute::AttributeInstanceMethods#batch_loaders
+      def batch_loaders
+        attribute.batch_loaders
+      end
+
       #
       # @return [SeregaObjectSerializer] object serializer for child plan
       #
@@ -77,11 +95,11 @@ class Serega
 
       private
 
-      # Patched in:
-      # - plugin :batch (prepares @batch)
-      # - plugin :preloads (prepares @preloads and @preloads_path)
       def set_normalized_vars
         @child_plan = prepare_child_plan
+        @preloads = prepare_preloads
+        @preloads_path = prepare_preloads_path
+        plan.mark_as_has_batch_points if batch?
       end
 
       def prepare_child_plan
@@ -91,6 +109,14 @@ class Serega
 
         serializer::SeregaPlan.new(self, fields)
       end
+
+      def prepare_preloads
+        SeregaUtils::PreloadsConstructor.call(child_plan)
+      end
+
+      def prepare_preloads_path
+        attribute.preloads_path
+      end
     end
 
     extend SeregaHelpers::SerializerClassHelper

data/lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb

@@ -4,7 +4,6 @@ class Serega
   module SeregaPlugins
     #
     # Plugin :activerecord_preloads
-    # (depends on :preloads plugin, that must be loaded first)
     #
     # Automatically preloads associations to serialized objects
     #
@@ -14,10 +13,9 @@ class Serega
     #
     # @example
     #   class AppSerializer < Serega
-    #     plugin :preloads,
-    #       auto_preload_attributes_with_delegate: true,
-    #       auto_preload_attributes_with_serializer: true,
-    #       auto_hide_attributes_with_preload: true
+    #     config.auto_preload_attributes_with_delegate = true
+    #     config.auto_preload_attributes_with_serializer = true
+    #     config.auto_hide_attributes_with_preload = true
     #
     #     plugin :activerecord_preloads
     #   end
@@ -62,14 +60,6 @@ class Serega
         opts.each_key do |key|
           raise SeregaError, "Plugin #{plugin_name.inspect} does not accept the #{key.inspect} option. No options are allowed"
         end
-
-        unless serializer_class.plugin_used?(:preloads)
-          raise SeregaError, "Plugin #{plugin_name.inspect} must be loaded after the :preloads plugin. Please load the :preloads plugin first"
-        end
-
-        if serializer_class.plugin_used?(:batch)
-          raise SeregaError, "Plugin #{plugin_name.inspect} must be loaded before the :batch plugin"
-        end
       end
 
       #
@@ -82,8 +72,30 @@ class Serega
       #
       def self.load_plugin(serializer_class, **_opts)
         require_relative "lib/preloader"
+        require_relative "lib/active_record_objects"
 
         serializer_class.include(InstanceMethods)
+        serializer_class::SeregaBatchAttributeLoader.include(BatchAttributeLoaderInstanceMethods)
+      end
+
+      #
+      # Overrides SeregaBatch::AttributeLoader class instance methods
+      #
+      module BatchAttributeLoaderInstanceMethods
+        private
+
+        # Preloads associations to batch-generated data
+        def load_one(serializer_class, batch_loader_name, context)
+          batch_loaded_data = super
+
+          preloads = point.preloads
+          return batch_loaded_data if preloads.empty?
+
+          ar_objects = ActiveRecordObjects.call(batch_loaded_data)
+          Preloader.preload(ar_objects, preloads)
+
+          batch_loaded_data
+        end
       end
 
       #

data/lib/serega/plugins/activerecord_preloads/lib/active_record_objects.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module ActiverecordPreloads
+      # Detects and returns found ActiveRecord objects
+      class ActiveRecordObjects
+        class << self
+          # Iterates over provided data and selects ActiveRecord objects
+          # @param data [Hash,Array,Object] any data
+          # @return [Array] Found ActiveRecord objects
+          def call(data)
+            res = []
+            extract(data, res)
+            res
+          end
+
+          private
+
+          def extract(data, res)
+            case data
+            when ActiveRecord::Base then res << data
+            when Array then data.each { |value| extract(value, res) }
+            when Hash then data.each_value { |value| extract(value, res) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/plugins/camel_case/camel_case.rb

@@ -203,7 +203,7 @@ class Serega
           res = super
           return res if init_opts[:camel_case] == false
 
-          self.class.serializer_class.config.camel_case.transform.call(res.to_s).to_sym
+          self.class.serializer_class.config.camel_case.transform.call(+res.to_s).to_sym
         end
       end
     end

data/lib/serega/plugins/formatters/formatters.rb

@@ -64,10 +64,6 @@ class Serega
             "Plugin #{plugin_name.inspect} does not accept the #{key.inspect} option. Allowed options:\n" \
             "  - :formatters [Hash<Symbol, #call>] - Formatters (names and according callable values)"
         end
-
-        if serializer_class.plugin_used?(:batch)
-          raise SeregaError, "Plugin #{plugin_name.inspect} must be loaded before the :batch plugin"
-        end
       end
 
       #
@@ -81,6 +77,7 @@ class Serega
       def self.load_plugin(serializer_class, **_opts)
         serializer_class::SeregaConfig.include(ConfigInstanceMethods)
         serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
+        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
       end
 
@@ -155,7 +152,7 @@ class Serega
       end
 
       #
-      # Attribute class additional/patched instance methods
+      # AttributeNormalizer class additional/patched instance methods
       #
       # @see SeregaAttributeNormalizer
       #
@@ -163,29 +160,69 @@ class Serega
         # Block or callable instance that will format attribute values
         # @return [Proc, #call, nil] Block or callable instance that will format attribute values
         def formatter
-          return @formatter if instance_variable_defined?(:@formatter)
+          @formatter ||= prepare_formatter
+        end
 
-          @formatter = prepare_formatter
+        #
+        # Returns formatter method signature for optimized calling
+        #
+        # @return [String, nil] Formatter signature ("1", "2", "1_ctx") or nil if no formatter
+        #
+        def formatter_signature
+          @formatter_signature ||= prepare_formatter_signature
         end
 
         private
 
-        def prepare_value_block
-          return super unless formatter
-
-          # Wrap original block into formatter block
-          proc do |object, context|
-            value = super.call(object, context)
-            formatter.call(value, context)
-          end
-        end
-
         def prepare_formatter
           formatter = init_opts[:format]
           return unless formatter
 
           formatter = self.class.serializer_class.config.formatters.opts.fetch(formatter) if formatter.is_a?(Symbol)
-          prepare_callable_proc(formatter)
+          formatter
+        end
+
+        def prepare_formatter_signature
+          return unless formatter
+
+          SeregaUtils::MethodSignature.call(formatter, pos_limit: 2, keyword_args: [:ctx])
+        end
+      end
+
+      #
+      # Attribute class additional/patched instance methods
+      #
+      # @see SeregaAttribute
+      #
+      module AttributeInstanceMethods
+        #
+        # Returns formatted attribute value
+        #
+        # @param object [Object] Serialized object
+        # @param context [Hash] Serialization context
+        #
+        # @return [Object] Formatted attribute value
+        #
+        def value(object, context, batches: nil)
+          result = super # `:batches` parameter is needed to find unformatted result
+          return result unless formatter
+
+          case formatter_signature
+          when "1" then formatter.call(result)
+          when "1_ctx" then formatter.call(result, ctx: context)
+          else # "2"
+            formatter.call(result, context)
+          end
+        end
+
+        private
+
+        attr_reader :formatter, :formatter_signature
+
+        def set_normalized_vars(normalizer)
+          super
+          @formatter = normalizer.formatter
+          @formatter_signature = normalizer.formatter_signature
         end
       end
 
@@ -241,13 +278,33 @@ class Serega
           def call(formatter_name, formatter)
             raise Serega::SeregaError, "Option #{formatter_name.inspect} must have callable value" unless formatter.respond_to?(:call)
 
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(formatter, "#{formatter_name.inspect} value")
-            params_count = SeregaUtils::ParamsCount.call(formatter, max_count: 2)
+            signature = SeregaUtils::MethodSignature.call(formatter, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error unless valid_signature?(signature)
+          end
+
+          private
 
-            if params_count > 2
-              raise SeregaError, "Formatter can have maximum 2 parameters (value to format, context)"
+          def valid_signature?(signature)
+            case signature
+            when "1"      # (object)
+              true
+            when "2"      # (object, context)
+              true
+            when "1_ctx"  # (object, :ctx)
+              true
+            else
+              false
             end
           end
+
+          def signature_error
+            <<~ERROR.strip
+              Invalid formatter parameters, valid parameters signatures:
+              - (object)          # one positional parameter
+              - (object, context) # two positional parameters
+              - (object, :ctx)    # one positional parameter and :ctx keyword
+            ERROR
+          end
         end
       end
     end

data/lib/serega/plugins/if/if.rb

@@ -50,19 +50,6 @@ class Serega
         :if
       end
 
-      # Checks requirements to load plugin
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] plugin options
-      #
-      # @return [void]
-      #
-      def self.before_load_plugin(serializer_class, **opts)
-        if serializer_class.plugin_used?(:batch)
-          raise SeregaError, "Plugin #{plugin_name.inspect} must be loaded before the :batch plugin"
-        end
-      end
-
       #
       # Applies plugin code to specific serializer
       #
@@ -116,18 +103,34 @@ class Serega
           }.freeze
         end
 
+        #
+        # Returns method signatures for all if options for optimized calling
+        #
+        # @return [Hash] Hash with signatures for each if option type
+        #
+        def if_options_signatures
+          @if_options_signatures ||= {
+            if: if_option_signature(:if),
+            unless: if_option_signature(:unless),
+            if_value: if_option_signature(:if_value),
+            unless_value: if_option_signature(:unless_value)
+          }.freeze
+        end
+
         private
 
+        def if_option_signature(option_name)
+          callable = if_options[option_name]
+          return unless callable
+
+          SeregaUtils::MethodSignature.call(callable, pos_limit: 2, keyword_args: [:ctx])
+        end
+
         def prepare_if_option(if_option)
           return unless if_option
           return proc { |val| val.public_send(if_option) } if if_option.is_a?(Symbol)
 
-          params_count = SeregaUtils::ParamsCount.call(if_option, max_count: 2)
-          case params_count
-          when 0 then proc { if_option.call }
-          when 1 then proc { |obj| if_option.call(obj) }
-          else if_option
-          end
+          if_option
         end
       end
 
@@ -137,14 +140,18 @@ class Serega
       # @see Serega::SeregaAttribute
       #
       module AttributeInstanceMethods
-        # @return provided :if options
+        # @return [Hash] provided :if options
         attr_reader :opt_if
 
+        # @return [Hash] signatures for provided :if options
+        attr_reader :opt_if_signatures
+
         private
 
         def set_normalized_vars(normalizer)
           super
           @opt_if = normalizer.if_options
+          @opt_if_signatures = normalizer.if_options_signatures
         end
       end
 
@@ -177,10 +184,22 @@ class Serega
           opt_unless = attribute.opt_if[opt_unless_name]
           return true if opt_if.nil? && opt_unless.nil?
 
-          res_if = opt_if ? opt_if.call(obj, ctx) : true
-          res_unless = opt_unless ? !opt_unless.call(obj, ctx) : true
+          res_if = opt_if ? check_condition(opt_if, opt_if_name, obj, ctx) : true
+          res_unless = opt_unless ? !check_condition(opt_unless, opt_unless_name, obj, ctx) : true
           res_if && res_unless
         end
+
+        def check_condition(condition, condition_name, object, context)
+          signature = attribute.opt_if_signatures[condition_name]
+
+          case signature
+          when "1" then condition.call(object)
+          when "2" then condition.call(object, context)
+          when "1_ctx" then condition.call(object, ctx: context)
+          else # "0"
+            condition.call
+          end
+        end
       end
 
       #

data/lib/serega/plugins/if/validations/check_opt_if.rb

@@ -29,17 +29,38 @@ class Serega
             return if value.is_a?(Symbol)
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":if option")
-            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
-
-            if params_count > 2
-              raise SeregaError, "Option :if value should have up to 2 parameters (object, context)"
-            end
+            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error unless valid_signature?(signature)
           end
 
           def must_be_callable
             "Invalid attribute option :if. It must be a Symbol, a Proc or respond to :call"
           end
+
+          def valid_signature?(signature)
+            case signature
+            when "0"      # no parameters
+              true
+            when "1"      # (object)
+              true
+            when "2"      # (object, context)
+              true
+            when "1_ctx"  # (object, :ctx)
+              true
+            else
+              false
+            end
+          end
+
+          def signature_error
+            <<~ERROR.strip
+              Invalid attribute option :if parameters, valid parameters signatures:
+              - ()                # no parameters
+              - (object)          # one positional parameter
+              - (object, context) # two positional parameters
+              - (object, :ctx)    # one positional parameter and :ctx keyword
+            ERROR
+          end
         end
       end
     end

data/lib/serega/plugins/if/validations/check_opt_if_value.rb

@@ -34,17 +34,38 @@ class Serega
             return if value.is_a?(Symbol)
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":if_value option")
-            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
-
-            if params_count > 2
-              raise SeregaError, "Option :if_value value should have up to 2 parameters (value, context)"
-            end
+            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error unless valid_signature?(signature)
           end
 
           def must_be_callable
             "Invalid attribute option :if_value. It must be a Symbol, a Proc or respond to :call"
           end
+
+          def valid_signature?(signature)
+            case signature
+            when "0"      # no parameters
+              true
+            when "1"      # (value)
+              true
+            when "2"      # (value, context)
+              true
+            when "1_ctx"  # (value, :ctx)
+              true
+            else
+              false
+            end
+          end
+
+          def signature_error
+            <<~ERROR.strip
+              Invalid attribute option :if_value parameters, valid parameters signatures:
+              - ()               # no parameters
+              - (value)          # one positional parameter
+              - (value, context) # two positional parameters
+              - (value, :ctx)    # one positional parameter and :ctx keyword
+            ERROR
+          end
         end
       end
     end

data/lib/serega/plugins/if/validations/check_opt_unless.rb

@@ -29,17 +29,38 @@ class Serega
             return if value.is_a?(Symbol)
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":unless option")
-            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
-
-            if params_count > 2
-              raise SeregaError, "Option :unless value should have up to 2 parameters (object, context)"
-            end
+            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error unless valid_signature?(signature)
           end
 
           def must_be_callable
             "Invalid attribute option :unless. It must be a Symbol, a Proc or respond to :call"
           end
+
+          def valid_signature?(signature)
+            case signature
+            when "0"      # no parameters
+              true
+            when "1"      # (object)
+              true
+            when "2"      # (object, context)
+              true
+            when "1_ctx"  # (object, :ctx)
+              true
+            else
+              false
+            end
+          end
+
+          def signature_error
+            <<~ERROR.strip
+              Invalid attribute option :unless parameters, valid parameters signatures:
+              - ()                # no parameters
+              - (object)          # one positional parameter
+              - (object, context) # two positional parameters
+              - (object, :ctx)    # one positional parameter and :ctx keyword
+            ERROR
+          end
         end
       end
     end

data/lib/serega/plugins/if/validations/check_opt_unless_value.rb

@@ -34,17 +34,38 @@ class Serega
             return if value.is_a?(Symbol)
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":unless_value option")
-            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
-
-            if params_count > 2
-              raise SeregaError, "Option :unless_value value should have up to 2 parameters (value, context)"
-            end
+            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error unless valid_signature?(signature)
           end
 
           def must_be_callable
             "Invalid attribute option :unless_value. It must be a Symbol, a Proc or respond to :call"
           end
+
+          def valid_signature?(signature)
+            case signature
+            when "0"      # no parameters
+              true
+            when "1"      # (value)
+              true
+            when "2"      # (value, context)
+              true
+            when "1_ctx"  # (value, :ctx)
+              true
+            else
+              false
+            end
+          end
+
+          def signature_error
+            <<~ERROR.strip
+              Invalid attribute option :unless_value parameters, valid parameters signatures:
+              - ()               # no parameters
+              - (value)          # one positional parameter
+              - (value, context) # two positional parameters
+              - (value, :ctx)    # one positional parameter and :ctx keyword
+            ERROR
+          end
         end
       end
     end

data/lib/serega/plugins/metadata/meta_attribute.rb

@@ -40,6 +40,8 @@ class Serega
             @opts = SeregaUtils::EnumDeepDup.call(opts)
             @block = block
             @normalized_block = normalize_block(opts[:value], opts[:const], block)
+            @normalized_block_signature =
+              SeregaUtils::MethodSignature.call(@normalized_block, pos_limit: 2, keyword_args: [])
           end
 
           #
@@ -51,7 +53,11 @@ class Serega
           # @return [Object] Serialized meta attribute value
           #
           def value(object, context)
-            normalized_block.call(object, context)
+            case normalized_block_signature
+            when "0" then normalized_block.call
+            when "1" then normalized_block.call(object)
+            else normalized_block.call(object, context)
+            end
           end
 
           def hide?(value)
@@ -60,19 +66,12 @@ class Serega
 
           private
 
-          attr_reader :normalized_block
+          attr_reader :normalized_block, :normalized_block_signature
 
           def normalize_block(value, const, block)
             return proc { const } if const
 
-            callable = value || block
-            params_count = SeregaUtils::ParamsCount.call(callable, max_count: 2)
-
-            case params_count
-            when 0 then proc { callable.call }
-            when 1 then proc { |obj| callable.call(obj) }
-            else callable
-            end
+            value || block
           end
 
           def check(path, opts, block)

data/lib/serega/plugins/metadata/validations/check_block.rb

@@ -29,10 +29,8 @@ class Serega
             # @return [void]
             #
             def call(block)
-              SeregaValidations::Utils::CheckExtraKeywordArg.call(block, "block")
-              params_count = SeregaUtils::ParamsCount.call(block, max_count: 2)
-
-              raise SeregaError, block_error if params_count > 2
+              signature = SeregaUtils::MethodSignature.call(block, pos_limit: 2, keyword_args: [])
+              raise SeregaError, block_error unless %w[0 1 2].include?(signature)
             end
 
             private

data/lib/serega/plugins/metadata/validations/check_opt_value.rb

@@ -36,10 +36,9 @@ class Serega
             def check_value(value)
               check_value_type(value)
 
-              SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":value option")
-              params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
+              signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [])
 
-              raise SeregaError, params_count_error if params_count > 2
+              raise SeregaError, params_count_error unless %w[0 1 2].include?(signature)
             end
 
             def check_value_type(value)