serega 0.37.2 → 0.39.0

data/lib/serega/validations/attribute/check_opt_base_serializer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaValidations
+    module Attribute
+      #
+      # Attribute `:base_serializer` option validator
+      #
+      class CheckOptBaseSerializer
+        class << self
+          #
+          # Checks attribute :base_serializer option. It specifies the parent
+          # class for the nested serializer defined with the attribute block,
+          # so it makes sense only when a block is provided.
+          #
+          # @param opts [Hash] Attribute options
+          # @param block [nil, Proc] Attribute block (defines a nested serializer)
+          #
+          # @raise [SeregaError] SeregaError that option has invalid value
+          #
+          # @return [void]
+          #
+          def call(opts, block = nil)
+            return unless opts.key?(:base_serializer)
+
+            raise SeregaError, "Option :base_serializer can be used only with a block" unless block
+
+            value = opts[:base_serializer]
+            return if value.is_a?(Class) && (value <= Serega)
+
+            raise SeregaError, "Invalid option :base_serializer => #{value.inspect}. Must be a Serega subclass"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/validations/attribute/check_opt_batch.rb

@@ -17,11 +17,11 @@ class Serega
           #
           # @return [void]
           #
-          def call(serializer_class, opts, block)
+          def call(serializer_class, opts)
             return unless opts.key?(:batch)
 
             check_opt_batch(opts, serializer_class)
-            check_usage_with_other_params(opts, block)
+            check_usage_with_other_params(opts)
           end
 
           private
@@ -72,22 +72,22 @@ class Serega
             Utils::CheckAllowedKeys.call(batch_opts, %i[use id], :batch)
           end
 
-          def check_usage_with_other_params(opts, block)
+          def check_usage_with_other_params(opts)
             batch = opts[:batch]
             use_id = batch.is_a?(Hash) && batch.key?(:id)
             use_multiple = batch.is_a?(Hash) && (Array(batch[:use]).size > 1)
-            value_added = opts.key?(:value) || block
+            value_added = opts.key?(:value)
 
             if use_multiple && use_id
               raise SeregaError, "Option `batch.id` should not be used with multiple loaders provided in `batch.use`"
             end
 
             if use_multiple && !value_added
-              raise SeregaError, "Attribute :value option or block should be provided when selecting multiple batch loaders"
+              raise SeregaError, "Attribute :value option should be provided when selecting multiple batch loaders"
             end
 
             if use_id && value_added
-              raise SeregaError, "Option `batch.id` should not be used when :value or block provided directly"
+              raise SeregaError, "Option `batch.id` should not be used when :value option provided directly"
             end
 
             raise SeregaError, "Option :batch can not be used together with option :method" if opts.key?(:method)

data/lib/serega/validations/attribute/check_opt_const.rb

@@ -17,19 +17,18 @@ class Serega
           #
           # @return [void]
           #
-          def call(opts, block = nil)
+          def call(opts)
             return unless opts.key?(:const)
 
-            check_usage_with_other_params(opts, block)
+            check_usage_with_other_params(opts)
           end
 
           private
 
-          def check_usage_with_other_params(opts, block)
+          def check_usage_with_other_params(opts)
             raise SeregaError, "Option :const can not be used together with option :method" if opts.key?(:method)
             raise SeregaError, "Option :const can not be used together with option :value" if opts.key?(:value)
             raise SeregaError, "Option :const can not be used together with option :batch" if opts.key?(:batch)
-            raise SeregaError, "Option :const can not be used together with block" if block
           end
         end
       end

data/lib/serega/validations/attribute/check_opt_delegate.rb

@@ -18,11 +18,11 @@ class Serega
           #
           # @return [void]
           #
-          def call(opts, block = nil)
+          def call(opts)
             return unless opts.key?(:delegate)
 
             check_opt_delegate(opts)
-            check_usage_with_other_params(opts, block)
+            check_usage_with_other_params(opts)
           end
 
           private
@@ -56,12 +56,11 @@ class Serega
             Utils::CheckAllowedKeys.call(delegate_opts, %i[to method allow_nil], :delegate)
           end
 
-          def check_usage_with_other_params(opts, block)
+          def check_usage_with_other_params(opts)
             raise SeregaError, "Option :delegate can not be used together with option :method" if opts.key?(:method)
             raise SeregaError, "Option :delegate can not be used together with option :const" if opts.key?(:const)
             raise SeregaError, "Option :delegate can not be used together with option :value" if opts.key?(:value)
             raise SeregaError, "Option :delegate can not be used together with option :batch" if opts.key?(:batch)
-            raise SeregaError, "Option :delegate can not be used together with block" if block
           end
         end
       end

data/lib/serega/validations/attribute/check_opt_many.rb

@@ -12,28 +12,29 @@ class Serega
           # Checks attribute :many option
           #
           # @param opts [Hash] Attribute options
+          # @param block [nil, Proc] Attribute block
           #
           # @raise [SeregaError] SeregaError that option has invalid value
           #
           # @return [void]
           #
-          def call(opts)
+          def call(opts, block = nil)
             return unless opts.key?(:many)
 
-            check_many_option_makes_sence(opts)
+            check_many_option_makes_sence(opts, block)
             Utils::CheckOptIsBool.call(opts, :many)
           end
 
           private
 
-          def check_many_option_makes_sence(opts)
-            return if many_option_makes_sence?(opts)
+          def check_many_option_makes_sence(opts, block)
+            return if many_option_makes_sence?(opts, block)
 
-            raise SeregaError, "Option :many can be provided only together with :serializer or :batch option"
+            raise SeregaError, "Option :many can be provided only together with :serializer, :batch option or a block"
           end
 
-          def many_option_makes_sence?(opts)
-            opts[:serializer] || opts[:batch]
+          def many_option_makes_sence?(opts, block)
+            opts[:serializer] || opts[:batch] || block
           end
         end
       end

data/lib/serega/validations/attribute/check_opt_method.rb

@@ -17,20 +17,19 @@ class Serega
           #
           # @return [void]
           #
-          def call(opts, block = nil)
+          def call(opts)
             return unless opts.key?(:method)
 
-            check_usage_with_other_params(opts, block)
+            check_usage_with_other_params(opts)
             Utils::CheckOptIsStringOrSymbol.call(opts, :method)
           end
 
           private
 
-          def check_usage_with_other_params(opts, block)
+          def check_usage_with_other_params(opts)
             raise SeregaError, "Option :method can not be used together with option :const" if opts.key?(:const)
             raise SeregaError, "Option :method can not be used together with option :value" if opts.key?(:value)
             raise SeregaError, "Option :method can not be used together with option :batch" if opts.key?(:batch)
-            raise SeregaError, "Option :method can not be used together with block" if block
           end
         end
       end

data/lib/serega/validations/attribute/check_opt_serializer.rb

@@ -12,14 +12,17 @@ class Serega
           # Checks attribute :serializer option
           #
           # @param opts [Hash] Attribute options
+          # @param block [nil, Proc] Attribute block (defines a nested serializer)
           #
           # @raise [SeregaError] SeregaError that option has invalid value
           #
           # @return [void]
           #
-          def call(opts)
+          def call(opts, block = nil)
             return unless opts.key?(:serializer)
 
+            raise SeregaError, "Option :serializer can not be used together with block" if block
+
             value = opts[:serializer]
             return if valid_serializer?(value)
 

data/lib/serega/validations/attribute/check_opt_value.rb

@@ -17,20 +17,19 @@ class Serega
           #
           # @return [void]
           #
-          def call(opts, block = nil)
+          def call(opts)
             return unless opts.key?(:value)
 
-            check_usage_with_other_params(opts, block)
+            check_usage_with_other_params(opts)
 
             check_value(opts[:value])
           end
 
           private
 
-          def check_usage_with_other_params(opts, block)
+          def check_usage_with_other_params(opts)
             raise SeregaError, "Option :value can not be used together with option :method" if opts.key?(:method)
             raise SeregaError, "Option :value can not be used together with option :const" if opts.key?(:const)
-            raise SeregaError, "Option :value can not be used together with block" if block
           end
 
           def check_value(value)

data/lib/serega/validations/check_attribute_params.rb

@@ -59,15 +59,16 @@ class Serega
         def check_opts
           Utils::CheckAllowedKeys.call(opts, allowed_opts_keys, :attribute)
 
-          Attribute::CheckOptConst.call(opts, block)
-          Attribute::CheckOptDelegate.call(opts, block)
+          Attribute::CheckOptBaseSerializer.call(opts, block)
+          Attribute::CheckOptConst.call(opts)
+          Attribute::CheckOptDelegate.call(opts)
           Attribute::CheckOptHide.call(opts)
-          Attribute::CheckOptMethod.call(opts, block)
-          Attribute::CheckOptMany.call(opts)
+          Attribute::CheckOptMethod.call(opts)
+          Attribute::CheckOptMany.call(opts, block)
           Attribute::CheckOptPreload.call(opts)
-          Attribute::CheckOptSerializer.call(opts)
-          Attribute::CheckOptValue.call(opts, block)
-          Attribute::CheckOptBatch.call(self.class.serializer_class, opts, block)
+          Attribute::CheckOptSerializer.call(opts, block)
+          Attribute::CheckOptValue.call(opts)
+          Attribute::CheckOptBatch.call(self.class.serializer_class, opts)
         end
 
         def check_block

data/lib/serega.rb

@@ -19,6 +19,7 @@ end
 
 require_relative "serega/errors"
 require_relative "serega/helpers/serializer_class_helper"
+require_relative "serega/utils/collection_detector"
 require_relative "serega/utils/enum_deep_dup"
 require_relative "serega/utils/enum_deep_freeze"
 require_relative "serega/utils/method_signature"
@@ -31,16 +32,16 @@ require_relative "serega/attribute_value_resolvers/delegate"
 require_relative "serega/attribute_value_resolvers/keyword"
 require_relative "serega/attribute"
 require_relative "serega/attribute_normalizer"
-require_relative "serega/batch/attribute_loader"
-require_relative "serega/batch/attribute_loaders"
-require_relative "serega/batch/level"
-require_relative "serega/batch/loader"
+require_relative "serega/engine/level_queue"
+require_relative "serega/engine/level"
+require_relative "serega/engine/loader"
 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"
 require_relative "serega/validations/utils/check_opt_is_string_or_symbol"
 require_relative "serega/validations/attribute/check_block"
 require_relative "serega/validations/attribute/check_name"
+require_relative "serega/validations/attribute/check_opt_base_serializer"
 require_relative "serega/validations/attribute/check_opt_const"
 require_relative "serega/validations/attribute/check_opt_hide"
 require_relative "serega/validations/attribute/check_opt_delegate"
@@ -86,15 +87,10 @@ class Serega
   check_batch_loader_params_class.serializer_class = self
   const_set(:CheckBatchLoaderParams, check_batch_loader_params_class)
 
-  # Assigns `SeregaBatchLoader` constant to current class
-  batch_loader_class = Class.new(SeregaBatch::Loader)
-  batch_loader_class.serializer_class = self
-  const_set(:SeregaBatchLoader, batch_loader_class)
-
-  # Assigns `SeregaBatchAttributeLoader` constant to current class
-  batch_attribute_loader_class = Class.new(SeregaBatch::AttributeLoader)
-  batch_attribute_loader_class.serializer_class = self
-  const_set(:SeregaBatchAttributeLoader, batch_attribute_loader_class)
+  # Assigns `SeregaEngineLoader` constant to current class
+  engine_loader_class = Class.new(SeregaEngine::Loader)
+  engine_loader_class.serializer_class = self
+  const_set(:SeregaEngineLoader, engine_loader_class)
 
   #
   # Serializers class methods
@@ -174,7 +170,19 @@ class Serega
     #
     # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
     # @param opts [Hash] Options to serialize attribute
-    # @param block [Proc] Custom block to find attribute value. Accepts object and context.
+    # @param block [Proc] Defines attributes of a nested anonymous serializer.
+    #   The block is executed in the context of that serializer, so everything
+    #   available in a serializer class body can be used inside. The attribute
+    #   value (found by name/:method/:value/:delegate/:const/:batch as usual)
+    #   is serialized with this nested serializer. The nested serializer
+    #   inherits from the `:base_serializer` attribute option or
+    #   `config.base_serializer` (one of them is required).
+    #
+    # @example
+    #   attribute :statistics, method: :itself do
+    #     attribute :likes_count
+    #     attribute :comments_count
+    #   end
     #
     # @return [Serega::SeregaAttribute] Added attribute
     #
@@ -214,7 +222,7 @@ class Serega
     def batch(name, value = nil, &block)
       raise SeregaError, "Batch loader must be defined with a callable value or block" if (value && block) || (!value && !block)
 
-      batch_loader = self::SeregaBatchLoader.new(name: name, block: value || block)
+      batch_loader = self::SeregaEngineLoader.new(name: name, block: value || block)
       batch_loaders[batch_loader.name] = batch_loader
     end
 
@@ -260,7 +268,7 @@ class Serega
     # @option opts [Array, Hash, String, Symbol] :with Attributes (usually hidden) to serialize additionally
     # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
     # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
+    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)`)
     #
     # @return [Hash] Serialization result
     #
@@ -281,7 +289,7 @@ class Serega
     # @option opts [Array, Hash, String, Symbol] :with Attributes (usually hidden) to serialize additionally
     # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
     # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
+    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)`)
     #
     # @return [Data, Array<Data>, nil] Serialization result as Data object(s)
     #
@@ -333,13 +341,9 @@ class Serega
       plan_point_class.serializer_class = subclass
       subclass.const_set(:SeregaPlanPoint, plan_point_class)
 
-      batch_loader_class = Class.new(self::SeregaBatchLoader)
-      batch_loader_class.serializer_class = subclass
-      subclass.const_set(:SeregaBatchLoader, batch_loader_class)
-
-      batch_attribute_loader_class = Class.new(self::SeregaBatchAttributeLoader)
-      batch_attribute_loader_class.serializer_class = subclass
-      subclass.const_set(:SeregaBatchAttributeLoader, batch_attribute_loader_class)
+      engine_loader_class = Class.new(self::SeregaEngineLoader)
+      engine_loader_class.serializer_class = subclass
+      subclass.const_set(:SeregaEngineLoader, engine_loader_class)
 
       object_serializer_class = Class.new(self::SeregaObjectSerializer)
       object_serializer_class.serializer_class = subclass
@@ -419,7 +423,7 @@ class Serega
     # @param object [Object] Serialized object
     # @param opts [Hash, nil] Serializing options
     # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
+    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)`)
     #
     # @return [Hash] Serialization result
     #
@@ -441,7 +445,7 @@ class Serega
     # @param object [Object] Serialized object
     # @param opts [Hash, nil] Serializing options
     # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
+    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)`)
     #
     # @return [Data] Serialization result
     #
@@ -481,8 +485,8 @@ class Serega
       self.class::CheckSerializeParams.new(opts).validate unless opts.empty?
 
       opts[:context] ||= {}
-      opts[:batch_loaders] = SeregaBatch::AttributeLoaders.new(opts[:context])
-      opts[:many] = object.is_a?(Enumerable) unless opts.key?(:many)
+      opts[:level_queue] = SeregaEngine::LevelQueue.new
+      opts[:many] = SeregaUtils::CollectionDetector.call(object) unless opts.key?(:many)
       opts[:plan] = plan
       opts
     end
@@ -493,7 +497,7 @@ class Serega
     # - plugin :metadata (adds metadata to final result)
     def serialize(object, opts)
       result = self.class::SeregaObjectSerializer.new(**opts).serialize(object)
-      opts[:batch_loaders].load_all
+      opts[:level_queue].run
       result
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.37.2
+  version: 0.39.0
 platform: ruby
 authors:
 - Andrey Glushkov
@@ -33,12 +33,11 @@ files:
 - lib/serega/attribute_value_resolvers/const.rb
 - lib/serega/attribute_value_resolvers/delegate.rb
 - lib/serega/attribute_value_resolvers/keyword.rb
-- lib/serega/batch/attribute_loader.rb
-- lib/serega/batch/attribute_loaders.rb
-- lib/serega/batch/level.rb
-- lib/serega/batch/loader.rb
 - lib/serega/config.rb
 - lib/serega/data_builder.rb
+- lib/serega/engine/level.rb
+- lib/serega/engine/level_queue.rb
+- lib/serega/engine/loader.rb
 - lib/serega/errors.rb
 - lib/serega/helpers/serializer_class_helper.rb
 - lib/serega/object_serializer.rb
@@ -71,6 +70,7 @@ files:
 - lib/serega/plugins/root/root.rb
 - lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
+- lib/serega/utils/collection_detector.rb
 - lib/serega/utils/enum_deep_dup.rb
 - lib/serega/utils/enum_deep_freeze.rb
 - lib/serega/utils/method_signature.rb
@@ -79,6 +79,7 @@ files:
 - lib/serega/utils/to_hash.rb
 - lib/serega/validations/attribute/check_block.rb
 - lib/serega/validations/attribute/check_name.rb
+- lib/serega/validations/attribute/check_opt_base_serializer.rb
 - lib/serega/validations/attribute/check_opt_batch.rb
 - lib/serega/validations/attribute/check_opt_const.rb
 - lib/serega/validations/attribute/check_opt_delegate.rb

data/lib/serega/batch/attribute_loader.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # Batch feature main module
-  #
-  module SeregaBatch
-    # Remembers data required to batch load single attribute
-    class AttributeLoader
-      # Instance methods for AttributeLoader
-      module InstanceMethods
-        # @param point [SeregaPlanPoint]
-        # @param level [SeregaBatch::Level] Shared objects and results for this point's plan level
-        def initialize(point, level)
-          @point = point
-          @level = level
-          @serialized_object_attachers = []
-        end
-
-        # Stores object with attacher to find and attach attribute values in batch later.
-        # @param object [Object] Serialized object
-        # @param attacher [Proc] Proc that attaches found values to originated attributes
-        # @return [void]
-        def store(object, attacher)
-          serialized_object_attachers << [object, attacher]
-        end
-
-        # Preloads this attribute's associations onto the level's objects, once for
-        # the attribute (not per named batch loader), via the serializer's registered
-        # `preload_with` handler. Raises when `:preload` is declared but no handler
-        # exists, so a declared preload never silently does nothing.
-        # @return [void]
-        def preload_associations
-          preloads = point.attribute.preloads
-          return unless preloads
-
-          handler = point.class.serializer_class.preload_with
-          unless handler
-            raise SeregaError, "The :preload option requires a preload handler. Register one with `preload_with` (the :activerecord_preloads plugin does this for you)."
-          end
-
-          handler.call(level.objects, preloads)
-        rescue => error
-          SeregaUtils::SerializedAttributeError.call(error, point)
-        end
-
-        # Loads a single named batch for this level's objects. Caching across
-        # attributes that reuse the loader is handled by the Level.
-        # @param loader [SeregaBatch::Loader] Named batch loader
-        # @return [Object] Loaded batch values
-        def load_batch(loader)
-          level.load(loader)
-        rescue => error
-          SeregaUtils::SerializedAttributeError.call(error, point)
-        end
-
-        # Attaches already loaded batch values to every stored object.
-        # Value resolution happens here (inside the attacher), so errors are
-        # annotated with the attribute, matching the synchronous walk.
-        # @param batches [Hash] Loaded values grouped by batch loader name
-        # @return [void]
-        def attach(batches)
-          serialized_object_attachers.each do |object, attacher|
-            attacher.call(object, batches)
-          end
-        rescue => error
-          SeregaUtils::SerializedAttributeError.call(error, point)
-        end
-
-        attr_reader :point
-        attr_reader :level
-
-        private
-
-        attr_reader :serialized_object_attachers
-      end
-
-      extend SeregaHelpers::SerializerClassHelper
-      include InstanceMethods
-    end
-  end
-end

data/lib/serega/batch/attribute_loaders.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # Batch feature main module
-  #
-  module SeregaBatch
-    # Reserved batch-loader name that marks relation/preload attributes as
-    # batch-processed. It has no registered loader — the attribute's value comes
-    # from its own resolver — so `load_batches` skips it (nothing to load).
-    AUTO_BATCH_LOADER_NAME = :__auto_batch__
-
-    #
-    # Batch loaders
-    #
-    # Remembers data required to batch load all attributes
-    class AttributeLoaders
-      #
-      # Initializes new batch loaders
-      #
-      # @param context [Hash] Serialization context, constant for the whole run
-      #
-      def initialize(context)
-        @context = context
-        @attribute_loaders = []
-        @point_index = {}.compare_by_identity
-        @levels = {}.compare_by_identity
-      end
-
-      # Gathers a chunk of objects serialized at a plan level, so every attribute at
-      # that level shares one set of objects to batch load against.
-      #
-      # @param plan [SeregaPlan] Plan serializing these objects
-      # @param objects [Array] Objects being serialized at this level
-      #
-      # @return [void]
-      def add_objects(plan, objects)
-        level_for(plan).add_objects(objects)
-      end
-
-      # Remembers data for batch serialization:
-      #
-      # @param point [SeregaPlanPoint] Serialization plan point
-      # @param object [Object] Serialized object
-      # @param attacher [Proc] Serialized value attacher
-      #
-      # @return [void]
-      def remember(point, object, attacher)
-        attribute_loader = point_index[point]
-
-        unless attribute_loader
-          serializer_class = point.class.serializer_class
-          attribute_loader = serializer_class::SeregaBatchAttributeLoader.new(point, level_for(point.plan))
-          attribute_loaders << attribute_loader
-          point_index[point] = attribute_loader
-        end
-
-        attribute_loader.store(object, attacher)
-      end
-
-      #
-      # Loads all registered batches and attaches loaded values.
-      #
-      # Iterates over each loader including loaders added during iteration
-      # (child serializers discovered inside a batch flush add new loaders).
-      def load_all
-        i = 0
-        while i < attribute_loaders.size
-          attribute_loader = attribute_loaders[i]
-          attribute_loader.attach(load_batches(attribute_loader))
-          i += 1
-        end
-      end
-
-      private
-
-      # Serialization context shared by every level
-      attr_reader :context
-
-      # keeps all AttributeLoader instances
-      attr_reader :attribute_loaders
-
-      # keeps tracking of already added points
-      attr_reader :point_index
-
-      # keeps one Level per plan (compare_by_identity: plan instance identifies a level)
-      attr_reader :levels
-
-      def level_for(plan)
-        levels[plan] ||= Level.new(context)
-      end
-
-      # Builds the { batch_loader_name => loaded_values } hash for one attribute.
-      #
-      # Loading is delegated to the attribute's Level, which loads each named batch
-      # once for the whole level: attributes sharing a loader over the same objects
-      # reuse a single result, deeper levels load separately.
-      def load_batches(attribute_loader)
-        attribute_loader.preload_associations
-
-        point = attribute_loader.point
-        serializer_class = point.class.serializer_class
-
-        batches = {}
-        point.batch_loaders.each do |batch_loader_name|
-          # Auto-batched relations/preloads carry the marker, not a real loader:
-          # their value comes from their own resolver, so there is nothing to load.
-          next if batch_loader_name == AUTO_BATCH_LOADER_NAME
-
-          loader = serializer_class.batch_loaders[batch_loader_name]
-          batches[batch_loader_name] = attribute_loader.load_batch(loader)
-        end
-        batches
-      end
-    end
-  end
-end