serega 0.37.2 → 0.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe536c6d684f24508a5153d1fc679cd451d2360ab3d752ff2ba08a2249b264c9
-  data.tar.gz: 0110de5fca4df251b1101daaba232bf1fcace80b6290bb95e35a8c892fc1ce1b
+  metadata.gz: a223242ae8bce14755fa2cbb444ff78728d95fccb0ce3077c212706e39e4ddcc
+  data.tar.gz: b8e1d3bdf11a57091cfd22eb31bb017979382df4b2166b05f746d064dc486f6e
 SHA512:
-  metadata.gz: 5a7f60a35e6791337f15772efeb2dfa0363ff96bb99f815c849c1fb5b40125854802b39ef492bea078f6bb614171b29b8f0e5409e421c52e6f24bf39eabfffdd
-  data.tar.gz: 2d3adb93d754ed3fb42581e5a45493e30e3f1fbb1cda8c68956e5cc047be42417f8cd487074cae5ce11fe72dbfa633ba32ccdc52dd002de17f349b7532c10f4f
+  metadata.gz: d815a4a17625533c34659451851c33806bd4d1e0bf862945b2118d52315726184322c55d989378cf8ac7f9b4d04a392dfa344af196491b984ddc1d094d15c063
+  data.tar.gz: ecf2be1cff661bfe8e99103748276969f72442b04b8308dd136d137dc88f28dfb543ad73a5e0880a31eb6f6c4a6a51e6ccab307a92f867551ff4b19b56d38f73

data/README.md

@@ -78,8 +78,24 @@ class UserSerializer < Serega
   # serialized object
   attribute :first_name, method: :old_first_name
 
-  # Block is used to define attribute value
-  attribute(:first_name) { |user| user.profile&.first_name }
+  # Attribute blocks below require a base serializer for nested serializers.
+  # See the "Defining a nested serializer with a block" section below.
+  config.base_serializer = Serega
+
+  # Method :itself is handy to serialize the same object with a nested set of
+  # attributes. Note: with the :presenter plugin the serialized value will be
+  # the Presenter instance itself; use `method: :__getobj__` to serialize the
+  # original unwrapped object instead.
+  attribute :statistics, method: :itself do
+    attribute :likes_count
+    attribute :comments_count
+  end
+
+  # Block defines a nested serializer for the attribute value.
+  # See the "Defining a nested serializer with a block" section below.
+  attribute :author do
+    attribute :name
+  end
 
   # Option :value can be used with a Proc or callable object to define
   # attribute value
@@ -114,13 +130,13 @@ class UserSerializer < Serega
 
   # Option `:many` specifies a has_many relationship. It is optional.
   # If not specified, it is defined during serialization by checking
-  # `object.is_a?(Enumerable)`
+  # `object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)`
   # Also the `:many` changes the default value from `nil` to `[]`.
   attribute :posts, serializer: PostSerializer, many: true
 
   # Option `:preload` allows to specify associations to preload to
   # attribute value
-  attribute(:email, preload: :emails) { |user| user.emails.find(&:verified?) }
+  attribute :email, preload: :emails, value: proc { |user| user.emails.find(&:verified?) }
 
   # Options `:if, :unless, :if_value and :unless_value` can be specified
   # when `:if` plugin is enabled. They hide the attribute key and value from the
@@ -139,6 +155,70 @@ class UserSerializer < Serega
 end
 ```
 
+### Defining a nested serializer with a block
+
+An attribute block defines an anonymous nested serializer. The attribute value
+is found as usual — by the attribute name or the `:method`, `:value`,
+`:delegate`, `:batch` option — and is serialized by this nested serializer.
+
+The nested serializer is a regular subclass of an explicitly chosen **base
+serializer** — usually a settings-only serializer holding your plugins and
+configuration. Choose it with the `base_serializer:` attribute option or the
+`config.base_serializer` setting (attribute option wins; an error is raised
+when none is set):
+
+```ruby
+class AppSerializer < Serega
+  plugin :activerecord_preloads
+
+  # Nested serializers defined with attribute blocks will inherit from
+  # AppSerializer
+  config.base_serializer = self
+end
+
+class UserSerializer < AppSerializer
+  attribute :first_name
+
+  # Serializes user.author with a nested serializer inherited from AppSerializer
+  attribute :author do
+    attribute :name
+  end
+
+  # Serializes the user itself, exposing only counters
+  attribute :statistics, method: :itself, base_serializer: StatsBaseSerializer do
+    attribute :likes_count
+    attribute :comments_count
+  end
+end
+
+UserSerializer.to_h(user)
+# => {first_name: "Bruce", author: {name: "Bob"}, statistics: {likes_count: 10, comments_count: 3}}
+```
+
+The nested serializer inherits everything the base serializer has — plugins,
+config, attributes, batch loaders, the preload handler — through the regular
+inheritance mechanism. Any serializer can be used as a base: if it has
+attributes, they are serialized by the nested serializer too, together with
+the attributes defined in the block. Anything the base does not provide can
+be declared inside the block:
+
+```ruby
+attribute :statistics, method: :itself do
+  batch(:stats) { |users| Stats.for_users(users) } # => { user_id => stat }
+
+  attribute :likes_count, batch: :stats, value: proc { |user, batches:| batches[:stats][user.id].likes }
+end
+```
+
+Things to keep in mind:
+
+- The nested serializer is created at the moment the attribute is defined.
+  Changes made to the base serializer later do not affect already defined
+  nested serializers.
+- Errors raised while serializing nested attributes are reported with a
+  readable serializer label, for example:
+  `(when serializing 'comments_count' attribute in UserSerializer.<statistics>)`.
+
 ### Serializing
 
 We can serialize objects using class method `.call` aliased as `.to_h` and
@@ -183,15 +263,6 @@ serializer.to_h(user1)
 serializer.to_h(user2)
 ```
 
----
-⚠️ When you serialize the `Struct` object, specify manually `many: false`. As Struct
-is Enumerable and we check `object.is_a?(Enumerable)` to detect if we should
-return array.
-
-```ruby
-UserSerializer.to_h(user_struct, many: false)
-```
-
 ### Selecting Fields
 
 By default, all attributes are serialized (except marked as `hide: true`).
@@ -312,9 +383,9 @@ current_user or any.
 
 ```ruby
 class UserSerializer < Serega
-  attribute(:email) do |user, ctx|
+  attribute :email, value: proc { |user, ctx|
     user.email if ctx[:current_user] == user
-  end
+  }
 end
 
 user = OpenStruct.new(email: 'email@example.com')
@@ -339,15 +410,18 @@ class UserSerializer < Serega
   batch :comments_count, ->(users) { Comment.where(user: users).group(:user_id).count }
   batch :comments_count, CommentsCountLoader # Example with callable class
 
-  # Full attribute example
-  attribute :comments_count, batch: { use: :comments_count },
-    value: proc { |user, batch:| batch[:comments_count][user.id] }
+  # Use a loader by its name
+  attribute :comments_count, batch: :comments_count
 
-  # Shorter version
-  attribute :comments_count, batch: { use: :comments_count, id: :id } # Equivalent, id: :id is default
+  # Equivalent — when the attribute name matches the loader name
+  attribute :comments_count, batch: true
 
-  # Shortest version
-  attribute :comments_count, batch: true # Equivalent
+  # Equivalent — the default value resolution spelled out
+  attribute :comments_count, batch: :comments_count,
+    value: proc { |user, batches:| batches[:comments_count][user.id] }
+
+  # Hash form — needed only for sub-options, for example a custom `:id` method
+  attribute :comments_count, batch: { use: :comments_count, id: :uuid }
 end
 ```
 
@@ -382,7 +456,7 @@ class UserSerializer < Serega
   # Summarize likes
   attribute :likes_count,
     batch: { use: [:facebook_likes, :twitter_likes] },
-    value: { |user, batch:| batch[:facebook_likes][user.id] + batch[:twitter_likes][user.id] }
+    value: proc { |user, batches:| batches[:facebook_likes][user.id] + batches[:twitter_likes][user.id] }
 end
 ```
 
@@ -390,6 +464,13 @@ end
 
 Here are the default options. Other options can be added with plugins.
 
+⚠️ Attributes are prepared at the moment they are defined. If a config option
+influences attributes (`auto_preload`, `hide_by_default`, `batch_id_option`,
+formatters, etc.), changing it affects only attributes defined **after** the
+change — including nested serializers defined with attribute blocks, which
+are created at their definition point. Configure the serializer before
+defining attributes.
+
 ```ruby
 class AppSerializer < Serega
   # With `activerecord_preloads` plugin it automatically adds `preload` option
@@ -413,6 +494,13 @@ class AppSerializer < Serega
   #   proc { |object, batches:| batches[:counter][object.id] }
   config.batch_id_option = :id
 
+  # Parent class for nested serializers defined with attribute blocks.
+  # Usually a settings-only serializer, e.g. `config.base_serializer = self`
+  # in an application base serializer class. There is no default — an
+  # attribute block raises an error when no base serializer is chosen (it can
+  # also be provided per-attribute with the `base_serializer:` option).
+  config.base_serializer = self
+
   # Disable/enable validation of modifiers (`:with, :except, :only`)
   # By default, this validation is enabled.
   # After disabling, all requested incorrect attributes will be skipped.
@@ -793,7 +881,7 @@ class UserSerializer < Serega
 end
 ```
 
-With the plugin, they move into a clean class:
+With the plugin, they move into a `presenter do ... end` block:
 
 ```ruby
 class UserSerializer < Serega
@@ -802,7 +890,7 @@ class UserSerializer < Serega
   attribute :name
   attribute :role
 
-  class Presenter
+  presenter do
     def name
       [first_name, last_name].compact.join(' ')
     end
@@ -814,6 +902,9 @@ class UserSerializer < Serega
 end
 ```
 
+The block is evaluated inside the serializer's own `Presenter` class, so
+multiple `presenter` blocks accumulate.
+
 `Presenter` inherits from `SimpleDelegator`, so every method of the serialized
 object is available directly inside presenter methods. Any method not explicitly
 defined on `Presenter` is resolved via `method_missing` on the first call, which
@@ -825,6 +916,12 @@ The original wrapped object is accessible via `__getobj__` (standard
 
 The serialization context is accessible via the private method `__ctx__`.
 
+Objects are wrapped in the `Presenter` only when the serializer's `Presenter`
+class (or an inherited one) actually defines custom methods. Loading the
+plugin in a base serializer adds no overhead to serializers that don't
+customize their presenters — their attribute values, batch loaders and value
+callables keep receiving the raw objects.
+
 ### Plugin :string_modifiers
 
 Allows to specify modifiers as strings.
@@ -973,7 +1070,8 @@ end
 ### Plugin :explicit_many_option
 
 The plugin requires adding a `:many` option when adding relationships
-(attributes with the `:serializer` option).
+(attributes with the `:serializer` option or a block defining a nested
+serializer).
 
 Adding this plugin makes it clearer to find if some relationship is an array or
 a single object.

data/VERSION

@@ -1 +1 @@
-0.37.2
+0.39.0

data/lib/serega/attribute.rb

@@ -45,10 +45,10 @@ class Serega
       # @option opts [Symbol] :method Object method name to fetch attribute value
       # @option opts [Hash] :delegate Allows to fetch value from nested object
       # @option opts [Boolean] :hide Specify `true` to not serialize this attribute by default
-      # @option opts [Boolean] :many Specifies has_many relationship. By default is detected via object.is_a?(Enumerable)
+      # @option opts [Boolean] :many Specifies has_many relationship. By default is detected via object.is_a?(Enumerable) && !object.is_a?(Hash) && !object.is_a?(Struct)
       # @option opts [Proc, #call] :value Custom block or callable to find attribute value
       # @option opts [Serega, Proc] :serializer Relationship serializer class. Use `proc { MySerializer }` if serializers have cross references
-      # @param block [Proc] Custom block to find attribute value
+      # @param block [Proc] Defines attributes of a nested anonymous serializer
       #
       def initialize(name:, opts: {}, block: nil)
         serializer_class = self.class.serializer_class
@@ -88,7 +88,7 @@ class Serega
       # @return [Object] Serialized attribute value
       #
       def value(object, context, batches: nil)
-        # Signatires should match allowed signatures in CheckOptValue and CheckBlock
+        # Signatures should match allowed signatures in CheckOptValue
         result =
           case value_block_signature
           when "1" then value_block.call(object)

data/lib/serega/attribute_normalizer.rb

@@ -109,9 +109,9 @@ class Serega
       end
 
       #
-      # Shows normalized preloads for current attribute
+      # Preloads declared for this attribute, passed through as provided.
       #
-      # @return [Hash, nil] normalized preloads of current attribute
+      # @return [Object, nil] declared preloads, or nil when the attribute has none
       #
       def preloads
         return @preloads if instance_variable_defined?(:@preloads)
@@ -133,8 +133,7 @@ class Serega
       end
 
       def prepare_value_block
-        init_block \
-          || init_opts[:value] \
+        init_opts[:value] \
           || prepare_const_block \
           || prepare_delegate_block \
           || prepare_batch_loader_block \
@@ -175,7 +174,73 @@ class Serega
       end
 
       def prepare_serializer
-        init_opts[:serializer]
+        block = init_block
+        return init_opts[:serializer] unless block
+
+        prepare_block_serializer(block)
+      end
+
+      # Builds an anonymous nested serializer from the attribute block.
+      #
+      # The serializer is a regular subclass of an explicitly chosen base —
+      # the :base_serializer attribute option or `config.base_serializer` —
+      # so it inherits everything the base has: plugins, config, attributes,
+      # batch loaders, the preload handler. Nested values can be any objects,
+      # which is why the base is chosen explicitly instead of inheriting from
+      # the current serializer. Its `inspect` is overridden to
+      # `CurrentSerializer.<attribute_name>` so error messages and debugging
+      # output point back to the defining attribute.
+      # Guards against cyclic definitions before building: inheriting the base
+      # serializer copies its attributes, and copying a block attribute builds
+      # its nested serializer — meeting the same block again while it is being
+      # built means the base serializer (transitively) contains the block
+      # attribute being built, so inheriting from it would recurse forever.
+      # The "in progress" mark is kept on the block itself — its identity is
+      # what defines the cycle (the same Proc object is shared by all copies
+      # of the attribute).
+      def prepare_block_serializer(block)
+        if block.instance_variable_defined?(:@serega_building_nested_serializer)
+          raise SeregaError,
+            "Can not define a nested serializer for attribute :#{name} —" \
+            " its base serializer #{block_base_serializer.inspect} (transitively)" \
+            " contains this same block attribute (cyclic definition)"
+        end
+
+        block.instance_variable_set(:@serega_building_nested_serializer, true)
+        begin
+          build_block_serializer(block)
+        ensure
+          block.remove_instance_variable(:@serega_building_nested_serializer)
+        end
+      end
+
+      def build_block_serializer(block)
+        label = "#{self.class.serializer_class.inspect}.<#{name}>"
+
+        serializer = Class.new(block_base_serializer) do
+          define_singleton_method(:inspect) { label }
+          define_singleton_method(:to_s) { label }
+          instance_exec(&block)
+        end
+
+        # An empty nested serializer means the block was intended as an
+        # old-style value block — raise the explaining error.
+        raise SeregaError, SeregaValidations::Attribute::CheckBlock::ERROR_MESSAGE if serializer.attributes.empty?
+
+        serializer
+      end
+
+      # Base class for the nested serializer. Must be chosen explicitly —
+      # usually a settings-only serializer holding plugins and configuration
+      # (e.g. `config.base_serializer = self` in an application base class).
+      def block_base_serializer
+        base_serializer = init_opts[:base_serializer] || config.base_serializer
+        return base_serializer if base_serializer
+
+        raise SeregaError,
+          "Attribute block requires a base serializer for the nested serializer." \
+          " Provide the `base_serializer: <SerializerClass>` attribute option" \
+          " or set `config.base_serializer = <SerializerClass>`"
       end
 
       def prepare_method_name
@@ -199,16 +264,14 @@ class Serega
         AttributeValueResolvers::BatchResolver.get(self.class.serializer_class, name, batch_opt)
       end
 
+      # Batch loader names whose loaded data this attribute's value needs. Only
+      # explicit `:batch` attributes have any — everything else resolves its value
+      # from the record itself, so the list is empty (no loader to run).
       def prepare_batch_loaders
         batch_opt = init_opts[:batch]
         return explicit_batch_loaders(batch_opt) if batch_opt
-        return FROZEN_EMPTY_ARRAY unless serializer || preloads
 
-        # Relations and preloads only need to be routed through the batch phase
-        # (so objects are gathered per level and preloads run) — there is nothing
-        # to load, since the value comes from the attribute's own resolver. Mark
-        # them with the reserved marker; the batch machinery skips it.
-        [SeregaBatch::AUTO_BATCH_LOADER_NAME]
+        FROZEN_EMPTY_ARRAY
       end
 
       def explicit_batch_loaders(batch_opt)
@@ -252,16 +315,26 @@ class Serega
 
         # Auto-preload the delegated association
         if config.auto_preload.fetch(:has_delegate_option) && init_opts[:delegate]
-          return init_opts[:delegate][:to]
+          return auto_preload_value(init_opts[:delegate][:to])
         end
 
         # Auto-preload the nested serializer's association
-        if config.auto_preload.fetch(:has_serializer_option) && init_opts[:serializer] && !init_opts.key?(:batch)
-          return method_name
+        # (a block defines a nested serializer, same as the :serializer option)
+        if config.auto_preload.fetch(:has_serializer_option) && (init_opts[:serializer] || init_block) && !init_opts.key?(:batch)
+          return auto_preload_value(method_name)
         end
 
         nil
       end
+
+      # Skips auto-preloading of methods that return the serialized object
+      # itself (:itself by default) — they are not associations,
+      # so preloading them would fail or make no sense.
+      def auto_preload_value(preload_method)
+        return nil if config.auto_preload_excluded_methods.include?(preload_method.to_sym)
+
+        preload_method
+      end
     end
 
     extend Serega::SeregaHelpers::SerializerClassHelper

data/lib/serega/attribute_value_resolvers/batch.rb

@@ -18,6 +18,7 @@ class Serega
       # It handles this cases:
       # - `attribute :foo, batch: true`
       # - `attribute :foo, batch: FooLoader`
+      # - `attribute :foo, batch: :foo_loader`
       # - `attribute :foo, batch: { id: :foo_id }`
       # - `attribute :foo, batch: { use: FooLoader, id: foo_id }`
       # - `attribute :foo, batch: { use: :foo_loader, id: foo_id }`
@@ -32,6 +33,9 @@ class Serega
           serializer_class.batch(attribute_name, batch_opt)
           batch_name = attribute_name
           batch_id_method = default_method
+        elsif batch_opt.is_a?(Symbol) || batch_opt.is_a?(String) # ex: `batch: :foo_loader`
+          batch_name = batch_opt.to_sym
+          batch_id_method = default_method
         else
           use = batch_opt[:use]
           batch_id_method = batch_opt[:id] || default_method

data/lib/serega/config.rb

@@ -24,6 +24,7 @@ class Serega
         default
         preload
         batch
+        base_serializer
       ].freeze,
       serialize_keys: %i[context many].freeze,
       check_attribute_name: true,
@@ -31,8 +32,10 @@ class Serega
       delegate_default_allow_nil: false,
       max_cached_plans_per_serializer_count: 0,
       auto_preload: {has_delegate_option: false, has_serializer_option: false},
+      auto_preload_excluded_methods: %i[itself].freeze,
       hide_by_default: false,
-      batch_id_option: :id
+      batch_id_option: :id,
+      base_serializer: nil
     }.freeze
     # :nocov:
 
@@ -114,6 +117,50 @@ class Serega
         opts[:delegate_default_allow_nil] = value
       end
 
+      # Returns :auto_preload_excluded_methods config option — methods that are
+      # never auto-preloaded, as they return the serialized object itself and
+      # not an association
+      # @return [Array<Symbol>] Current :auto_preload_excluded_methods config option
+      def auto_preload_excluded_methods
+        opts.fetch(:auto_preload_excluded_methods)
+      end
+
+      # Sets :auto_preload_excluded_methods config option — methods that are
+      # never auto-preloaded. Applies to the `:method` option of attributes
+      # with a serializer and to the `delegate: {to: ...}` option.
+      #
+      # @param value [Array<Symbol>] Method names to skip in auto-preload
+      #
+      # @return [Array<Symbol>] New :auto_preload_excluded_methods config option
+      def auto_preload_excluded_methods=(value)
+        unless value.is_a?(Array) && value.all?(Symbol)
+          raise SeregaError, "Must be an Array of Symbols, #{value.inspect} provided"
+        end
+
+        opts[:auto_preload_excluded_methods] = value
+      end
+
+      # Returns :base_serializer config option — the parent class for nested
+      # serializers defined with attribute blocks
+      # @return [Class, nil] Current :base_serializer config option
+      def base_serializer
+        opts.fetch(:base_serializer)
+      end
+
+      # Sets :base_serializer config option — the parent class for nested
+      # serializers defined with attribute blocks. Usually a settings-only
+      # serializer, e.g. `config.base_serializer = self` in an application
+      # base serializer class.
+      #
+      # @param value [Class] Serega or its subclass
+      #
+      # @return [Class] New :base_serializer config option
+      def base_serializer=(value)
+        raise SeregaError, "Must be a Serega subclass, #{value.inspect} provided" if !value.is_a?(Class) || !(value <= Serega)
+
+        opts[:base_serializer] = value
+      end
+
       # Returns :hide_by_default config option
       # @return [Boolean, Symbol] Current :hide_by_default config option
       def hide_by_default

data/lib/serega/engine/level.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Batch feature main module
+  #
+  module SeregaEngine
+    #
+    # One serialization level: all objects serialized under a single plan and the
+    # result containers they fill. Objects from different parents that share a plan
+    # (e.g. every user's posts) accumulate into one level, so a named batch loader
+    # or preload runs once over the whole set. A deeper level (its own plan) loads
+    # separately.
+    #
+    class Level
+      # @param serializer [SeregaObjectSerializer] serializer that resolves this level
+      def initialize(serializer)
+        @serializer = serializer
+        @objects = []
+        @containers = []
+        @results = {}.compare_by_identity
+      end
+
+      # @return [Array] Objects serialized at this level
+      attr_reader :objects
+
+      # @return [Array<Hash>] Result container per object (filled in place)
+      attr_reader :containers
+
+      # Accumulates a chunk of objects into this level, creating one empty result
+      # container per object. The containers are returned so the caller can hand
+      # them to its parent; they are filled in place later during #process.
+      #
+      # @param objects [Array] objects serialized at this level
+      # @return [Array<Hash>] the created containers, aligned with objects
+      def add(objects)
+        containers = Array.new(objects.size) { {} }
+        @objects.concat(objects)
+        @containers.concat(containers)
+        containers
+      end
+
+      # Resolves every attribute of this level onto the containers.
+      # @return [void]
+      def process
+        @serializer.process(self)
+      end
+
+      # Loads a named batch loader once for this level's objects.
+      # @param loader [SeregaEngine::Loader] Named batch loader
+      # @return [Object] Loaded values
+      def fetch(loader)
+        @results[loader] ||= loader.load(@objects, @serializer.context)
+      end
+    end
+  end
+end

data/lib/serega/engine/level_queue.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Batch feature main module
+  #
+  module SeregaEngine
+    #
+    # Level-order queue of serialization levels for one serialization run.
+    #
+    # `#serialize` on the object serializer enqueues a level (objects + their result
+    # containers) instead of resolving values inline. `#run` then processes the
+    # queue: each level resolves its attributes and, for relations, enqueues child
+    # levels — which the loop picks up because it re-reads the size each iteration.
+    # Processing level-by-level lets a named batch loader and preloads run once per
+    # level over all of its objects.
+    #
+    class LevelQueue
+      def initialize
+        @levels = []
+        @levels_by_plan = {}.compare_by_identity
+      end
+
+      # Adds objects to the level for their plan (creating it on first use), so
+      # objects serialized under the same plan — even from different parents —
+      # share one level and load once. The level creates a result container per
+      # object and returns them for the caller to embed in its parent.
+      #
+      # @param serializer [SeregaObjectSerializer] serializer that resolves the level
+      # @param objects [Array] objects serialized at this level
+      #
+      # @return [Array<Hash>] the created result containers, aligned with objects
+      def enqueue(serializer, objects)
+        level = @levels_by_plan[serializer.plan]
+        unless level
+          level = Level.new(serializer)
+          @levels_by_plan[serializer.plan] = level
+          @levels << level
+        end
+        level.add(objects)
+      end
+
+      # Processes every level, including child levels enqueued while processing.
+      # @return [void]
+      def run
+        i = 0
+        while i < @levels.size
+          @levels[i].process
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/serega/{batch → engine}/loader.rb

@@ -4,7 +4,7 @@ class Serega
   #
   # Batch feature main module
   #
-  module SeregaBatch
+  module SeregaEngine
     #
     #  Batch loader
     #