serega 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b291b12115b8ca239642972b103f896f13f02874acdc5663a8f404e02673ca8d
-  data.tar.gz: 18bd88ca4bd77ca147161189efe57b2c544da6cc1b460fc7c694855d4b22edc9
+  metadata.gz: 60cc0f4e593d4600bf316e9c18bd93804008e28deebd5f51c231b632bb3a4eff
+  data.tar.gz: e3bdc8e6a0489a14916d84781dcf61c6a82dedb246a0b5366f324d78ca81d9b2
 SHA512:
-  metadata.gz: d5c5114ed1c1b8b5a0714a340aca263983f5f8cdb24d15c8138124d64520ebafe03f6c64a7985f131ee399fab287ee578889b1affa1e2aa6f4ddacfbb9c8517e
-  data.tar.gz: 4d8191c7081b4650e3328141ec3cc2dc9128a7c4da3a38107e5f2c107d1d70446b67e718a3ffa2ff76e700f80dbdf975da9512d089c86ec552c3dc8a390345d1
+  metadata.gz: 879f46f3bface078c156ad0c89e71b4abc08945754034235d03a688c5613e549d477ae1d24bfa6d0f2c44de1def6266d9b18677ab9fab53ef8341510075806d5
+  data.tar.gz: 45b302b1efc001b9ff3ef35bb9d71bf05e3dcfffbfd35938cf938448b308e9c6c0f74a8f1c1eeceabf8a3bd0eb759f50dd053948664565fbeef2f4b8502841b2

data/README.md

@@ -73,7 +73,8 @@ class UserSerializer < Serega
   # Block is used to define attribute value
   attribute(:first_name) { |user| user.profile&.first_name }
 
-  # Option :value can be used with callable object to define attribute value
+  # Option :value can be used with proc or callable object to define attribute value
+  attribute :first_name, value: UserProfile.new # must have #call method
   attribute :first_name, value: proc { |user| user.profile&.first_name }
 
   # Option :delegate can be used to define attribute value.
@@ -538,118 +539,165 @@ UserSerializer.to_h(user)
 
 ### Plugin :batch
 
-Adds ability to load nested attributes values in batches.
+Must be used to omit N+1 when loading attributes values.
 
-It can be used to find value for attributes in optimal way:
+User must provide batch loader object to attribute -
+`attribute :foo, batch: {loader: SomeLoader, id_method: :id}`.
 
-- load associations for multiple objects
-- load counters for multiple objects
-- make any heavy calculations for multiple objects only once
-
-After including plugin, attributes gain new `:batch` option:
+Result must be returned as Hash, where each key is one of provided ids.
 
 ```ruby
-attribute :name, batch: { loader: :name_loader, key: :id, default: nil }
+class AppSerializer
+  plugin :batch
+end
+
+class UserSerializer < AppSerializer
+  attribute :comments_count,
+    batch: { loader: SomeLoader, id_method: :id }
+
+  attribute :company,
+    batch: { loader: SomeLoader, id_method: :id },
+    serializer: CompanySerializer
+end
 ```
 
-`:batch` option must be a hash with this keys:
+#### Option :loader
 
-- `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-  batch of keys. Receives 3 parameters: keys, context, plan_point.
-- `key` (required) [Symbol, Proc, callable] - Defines current object identifier.
-  Key is optional if plugin was defined with `default_key` option.
-- `default` (optional) - Default value for attribute.
-  By default it is `nil` or `[]` when attribute has option `many: true`
-  (ex: `attribute :tags, many: true, batch: { ... }`).
+Loaders can be defined as a Proc, a callable value or a named Symbol
+Named loaders should be predefined with
+`config.batch.define(:loader_name) { |ids| ... })`
 
-If `:loader` was defined using name (as Symbol) then batch loader must be
-defined using `config.batch.define(:loader_name) { ... }` method.
+Loader can accept 1 to 3 arguments:
 
-Result of this `:loader` callable must be a **Hash** where:
+1. List of ids (each id will be found by using `:id_method` option)
+1. Context
+1. PlanPoint - a special object containing information about current
+   attribute and all children and parent attributes. It can be used to preload
+   required associations to batch values.
+   See [example](examples/batch_loader.rb) how
+   to find required preloads when using with `:preloads` plugin.
 
-- keys - provided keys
-- values - values for according keys
+```ruby
+class AppSerializer < Serega
+  plugin :batch, id_method: :id
+end
 
-`Batch` plugin can be defined with two specific attributes:
+class UserSerializer < Serega
+  # Define loader as callable object
+  attribute :comments_count,
+    batch: { loader: CountLoader }
 
-- `auto_hide: true` - Marks attributes with defined :batch as hidden, so it
-  will not be serialized by default
-- `default_key: :id` - Set default object key (in this case :id) that will be
-  used for all attributes with :batch option specified.
+  # Define loader as a Proc
+  attribute :comments_count,
+    batch: { loader: proc { |ids| CountLoader.call(ids) } }
 
-```ruby
-  plugin :batch, auto_hide: true, default_key: :id
+  # Define loader as a Symbol
+  config.batch.define(:comments_count_loader) { |ids| CountLoader.call(ids }
+  attribute :comments_count, batch: { loader: :comments_count_loader }
+end
+
+class CountLoader
+  def self.call(user_ids)
+    Comment.where(user_id: user_ids).group(:user_id).count
+  end
+end
 ```
 
-Options `auto_hide` and `default_key` can be overwritten in nested serializers.
+#### Option :id_method
+
+Batch plugin can be added with global `:id_method` option. It can be a Symbol,
+Proc or any callable value, which can accept current object and current context.
 
 ```ruby
-class AppSerializer
-  plugin :batch, auto_hide: true, default_key: :id
+class SomeSerializer
+  plugin :batch, id_method: :id
 end
 
 class UserSerializer < AppSerializer
-  config.batch.auto_hide = false
-  config.batch.default_key = :user_id
+  attribute :comments_count,
+    batch: { loader: CommentsCountBatchLoader } # no :id_method here anymore
+
+  attribute :company,
+    batch: { loader: UserCompanyBatchLoader }, # no :id_method here anymore
+    serializer: CompanySerializer
 end
+
 ```
 
----
-⚠️ ATTENTION: `Batch` plugin must be added to serializers which have no
-`:batch` attributes, but have nested serializers, that have some. For example
-when you serialize `User -> Album -> Song` and Song has `:batch` attribute, then
-`:batch` plugin must be added to the User serializer also. \
-Best way would be to create one parent `AppSerializer < Serega` for all your
-serializers and add `:batch` plugin only to this parent `AppSerializer`
+However, global `id_method` option can be overwritten via `config.batch.id_method=`
+method or in specific attributes with `id_method` option.
 
 ```ruby
-class AppSerializer < Serega
-  plugin :batch, auto_hide: true, default_key: :id
+class SomeSerializer
+  plugin :batch, id_method: :id # global id_method is `:id`
 end
 
-class PostSerializer < AppSerializer
-  attribute :comments_count,
-    batch: {
-      loader: CommentsCountBatchLoader, # callable(keys, context, plan_point)
-      key: :id, # can be skipped (as :id value is same as configured :default_key)
-      default: 0
-    }
+class UserSerializer < AppSerializer
+  # :user_id will be used as default `id_method` for all batch attributes
+  config.batch.id_method = :user_id
 
-  # Define batch loader via Symbol, later we should define this loader via
-  # `config.batch.define(:posts_comments_counter) { ... }`
-  #
-  # Loader will receive array of ids, as `default_key: :id` plugin option was specified.
-  # Default value for not found counters is nil, as `:default` option not defined
+  # id_method is :user_id
   attribute :comments_count,
-    batch: { loader: :posts_comments_counter }
+    batch: { loader: CommentsCountBatchLoader }
 
-  # Define batch loader with serializer
-  attribute :comments,
-    serializer: CommentSerializer,
-    batch: {loader: :posts_comments, default: []}
 
-  # Resulted block must return hash like { key => value(s) }
-  config.batch.define(:posts_comments_counter) do |keys|
-    Comment.group(:post_id).where(post_id: keys).count
-  end
+  # id_method is :user_id
+  attribute :company,
+    batch: { loader: UserCompanyBatchLoader }, serializer: CompanySerializer
 
-  # We can return objects that will be automatically serialized if attribute
-  # defined with :serializer
-  # Parameter `context` can be used when loading batch
-  # Parameter `point` can be used to find nested attributes to serialize
-  config.batch.define(:posts_comments) do |keys, context, point|
-    # point.child_plan - if you need to manually check all nested attributes
-    # point.preloads - nested preloads (works with :preloads plugin only)
-
-    Comment
-      .preload(point.preloads) # Skip if :activerecord_preloads plugin used
-      .where(post_id: keys)
-      .where(is_spam: false)
-      .group_by(&:post_id)
-  end
+  # id_method is :uuid
+  attribute :points_amount,
+    batch: { loader: PointsBatchLoader, id_method: :uuid }
+end
+```
+
+#### Option :default
+
+The default value for attributes without found value can be specified via
+`:default` option. By default attributes without found value will be
+serialized as `nil`. Attribute marked as `many: true` will be
+serialized as empty array `[]`
+
+```ruby
+class UserSerializer < AppSerializer
+  # Missing values become empty arrays, as `many: true` option specified
+  attribute :companies,
+    batch: {loader: proc {}},
+    serializer: CompanySerializer,
+    many: true
+
+  # Missing values become `0` as specified directly
+  attribute :points_amount,
+    batch: { loader: proc {}, default: 0 }
+end
+```
+
+Batch attributes can be marked as hidden by default if plugin specified with
+`auto_hide` option. Also `auto_hide` option can be changed with
+`config.batch.auto_hide=` method.
+
+Look at [select serialized fields](#selecting-fields) for more information
+about hiding/showing attributes.
+
+```ruby
+class AppSerializer
+  plugin :batch, auto_hide: true
+end
+
+class UserSerializer < AppSerializer
+  config.batch.auto_hide = false
 end
 ```
 
+---
+⚠️ ATTENTION: `Batch` plugin must be added to all serializers that have
+`:batch` attributes inside nested serializers. For example when you serialize
+`User -> Album -> Song` and Song has `batch` attribute, then
+`batch` plugin must be added to the User serializer also.
+
+Best way would be to create one parent `AppSerializer < Serega` serializer
+and add `:batch` plugin once to this parent serializer.
+
 ### Plugin :root
 
 Allows to add root key to your serialized data
@@ -715,17 +763,24 @@ Adds ability to describe metadata and adds it to serialized response
 
 Added class-level method `:meta_attribute`, to define metadata, it accepts:
 
-- *path [Array of Symbols] - nested hash keys.
-- **options [Hash] - defaults are `hide_nil: false, hide_empty: false`
-- &block [Proc] - describes value for current meta attribute
+- `*path` [Array of Symbols] - nested hash keys.
+- `**options` [Hash]
+
+   - `:const` - describes metadata value (if it is constant)
+   - `:value` - describes metadata value as any `#callable` instance
+   - `:hide_nil` - does not show metadata key if value is nil, `false` by default
+   - `:hide_empty`, does not show metadata key if value is nil or empty,
+     `false` by default
+
+- `&block` [Proc] - describes value for current meta attribute
 
 ```ruby
 class AppSerializer < Serega
   plugin :root
   plugin :metadata
 
-  meta_attribute(:version) { '1.2.3' }
-  meta_attribute(:ab_tests, :names) { %i[foo bar] }
+  meta_attribute(:version, const: '1.2.3')
+  meta_attribute(:ab_tests, :names, value: ABTests.new.method(:names))
   meta_attribute(:meta, :paging, hide_nil: true) do |records, ctx|
     next unless records.respond_to?(:total_count)
 
@@ -738,7 +793,7 @@ class AppSerializer < Serega
 end
 
 AppSerializer.to_h(nil)
-# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=>[:foo, :bar]}}
+# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=> ... }}
 ```
 
 ### Plugin :context_metadata
@@ -773,15 +828,18 @@ Allows to define `formatters` and apply them on attribute values.
 
 Config option `config.formatters.add` can be used to add formatters.
 
-Attribute option `:format` now can be used with name of formatter or with
+Attribute option `:format` can be used with name of formatter or with
 callable instance.
 
+Formatters can accept up to 2 parameters (formatted object, context)
+
 ```ruby
 class AppSerializer < Serega
   plugin :formatters, formatters: {
     iso8601: ->(value) { time.iso8601.round(6) },
     on_off: ->(value) { value ? 'ON' : 'OFF' },
-    money: ->(value) { value.round(2) }
+    money: ->(value, ctx) { value / 10**ctx[:digits) }
+    date: DateTypeFormatter # callable
   }
 end
 
@@ -1029,6 +1087,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [batch]: #plugin-batch
 [camel_case]: #plugin-camel_case
 [context_metadata]: #plugin-context_metadata
+[depth_limit]: #plugin-depth_limit
 [formatters]: #plugin-formatters
 [metadata]: #plugin-metadata
 [preloads]: #plugin-preloads

data/VERSION

@@ -1 +1 @@
-0.16.0
+0.18.0

data/lib/serega/attribute.rb

@@ -61,10 +61,10 @@ class Serega
       # Shows specified serializer class
       # @return [Serega, nil] Attribute serializer if exists
       def serializer
-        ser = @serializer
-        return ser if (ser.is_a?(Class) && (ser < Serega)) || !ser
+        serializer = @serializer
+        return serializer if (serializer.is_a?(Class) && (serializer < Serega)) || !serializer
 
-        @serializer = ser.is_a?(String) ? Object.const_get(ser, false) : ser.call
+        @serializer = serializer.is_a?(String) ? Object.const_get(serializer, false) : serializer.call
       end
 
       #

data/lib/serega/attribute_normalizer.rb

@@ -97,8 +97,8 @@ class Serega
       # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
       #
       def prepare_value_block
-        init_block ||
-          init_opts[:value] ||
+        prepare_init_block ||
+          prepare_value_option_block ||
           prepare_const_block ||
           prepare_delegate_block ||
           prepare_keyword_block
@@ -139,6 +139,25 @@ class Serega
         end
       end
 
+      def prepare_init_block
+        prepare_callable_proc(init_block)
+      end
+
+      def prepare_value_option_block
+        prepare_callable_proc(init_opts[:value])
+      end
+
+      def prepare_callable_proc(callable)
+        return unless callable
+
+        params_count = SeregaUtils::ParamsCount.call(callable, max_count: 2)
+        case params_count
+        when 0 then proc { |obj, _ctx| callable.call }
+        when 1 then proc { |obj, _ctx| callable.call(obj) }
+        else callable
+        end
+      end
+
       def prepare_delegate_block
         delegate = init_opts[:delegate]
         return unless delegate

data/lib/serega/object_serializer.rb

@@ -29,7 +29,7 @@ class Serega
       #
       # @param object [Object] Serialized object
       #
-      # @return [Hash, Array<Hash>] Serialized object(s)
+      # @return [Hash, Array<Hash>, nil] Serialized object(s)
       def serialize(object)
         return if object.nil?
 

data/lib/serega/plugins/batch/batch.rb

@@ -5,62 +5,17 @@ class Serega
     #
     # Plugin `:batch`
     #
-    # Adds ability to load nested attributes values in batches.
+    # Must be used to omit N+1 when loading attributes values.
     #
-    # It can be used to find value for attributes in optimal way:
-    # - load associations for multiple objects
-    # - load counters for multiple objects
-    # - make any heavy calculations for multiple objects only once
+    # @example Quick example
     #
-    # After including plugin, attributes gain new `:batch` option.
-    #
-    # `:batch` option must be a hash with this keys:
-    # - `key` (required) [Symbol, Proc, callable] - Defines current object identifier.
-    #   Later `loader` will accept array of `keys` to find `values`.
-    # - `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-    #   batch of keys. Receives 3 parameters: keys, context, plan_point.
-    # - `default` (optional) - Default value for attribute.
-    #   By default it is `nil` or `[]` when attribute has option `many: true`
-    #
-    # If `:loader` was defined using name (as Symbol) then batch loader must be
-    # defined in serializer config: `config.batch.define(:loader_name) { ... }` method.
-    #
-    # *Result of this `:loader` callable must be a **Hash** where*:
-    # - keys - provided keys
-    # - values - values for according keys
-    #
-    # `Batch` plugin can be defined with two specific attributes:
-    # - `auto_hide: true` - Marks attributes with defined :batch as hidden, so it
-    #   will not be serialized by default
-    # - `default_key: :id` - Set default object key (in this case :id) that will be used for all attributes with :batch option specified.
-    #
-    # This options (`auto_hide`, `default_key`) also can be set as config options in
-    # any nested serializer.
-    #
-    # @example
-    #   class PostSerializer < Serega
-    #     plugin :batch, auto_hide: true, default_key: :id
-    #
-    #     # Define batch loader via callable class, it must accept three args (keys, context, plan_point)
-    #     attribute :comments_count, batch: { loader: PostCommentsCountBatchLoader, default: 0}
-    #
-    #     # Define batch loader via Symbol, later we should define this loader via config.batch.define(:posts_comments_counter) { ... }
-    #     attribute :comments_count, batch: { loader: :posts_comments_counter, default: 0}
-    #
-    #     # Define batch loader with serializer
-    #     attribute :comments, serializer: CommentSerializer, batch: { loader: :posts_comments, default: []}
-    #
-    #     # Resulted block must return hash like { key => value(s) }
-    #     config.batch.define(:posts_comments_counter) do |keys|
-    #       Comment.group(:post_id).where(post_id: keys).count
-    #     end
+    #   class AppSerializer
+    #     plugin :batch, id_method: :id
+    #   end
     #
-    #     # We can return objects that will be automatically serialized if attribute defined with :serializer
-    #     # Parameter `context` can be used when loading batch
-    #     # Parameter `plan_point` can be used to find nested attributes that will be serialized (`plan_point.preloads`)
-    #     config.batch.define(:posts_comments) do |keys, context, plan_point|
-    #       Comment.where(post_id: keys).where(is_spam: false).group_by(&:post_id)
-    #     end
+    #   class UserSerializer < AppSerializer
+    #     attribute :comments_count, batch: { loader: CommentsCountBatchLoader, default: 0 }
+    #     attribute :company, serializer: CompanySerializer, batch: { loader: UserCompanyBatchLoader }
     #   end
     #
     module Batch
@@ -88,7 +43,7 @@ class Serega
         require_relative "lib/modules/config"
         require_relative "lib/modules/object_serializer"
         require_relative "lib/modules/plan_point"
-        require_relative "lib/validations/check_batch_opt_key"
+        require_relative "lib/validations/check_batch_opt_id_method"
         require_relative "lib/validations/check_batch_opt_loader"
         require_relative "lib/validations/check_opt_batch"
 
@@ -138,9 +93,9 @@ class Serega
 
         config = serializer_class.config
         config.attribute_keys << :batch
-        config.opts[:batch] = {loaders: {}, default_key: nil, auto_hide: false}
+        config.opts[:batch] = {loaders: {}, id_method: nil, auto_hide: false}
         config.batch.auto_hide = opts[:auto_hide] if opts.key?(:auto_hide)
-        config.batch.default_key = opts[:default_key] if opts.key?(:default_key)
+        config.batch.id_method = opts[:id_method] if opts.key?(:id_method)
       end
 
       #

data/lib/serega/plugins/batch/lib/batch_config.rb

@@ -17,22 +17,25 @@ class Serega
         # Defines batch loader
         #
         # @param loader_name [Symbol] Batch loader name, that is used when defining attribute with batch loader.
-        # @param block [Proc] Block that can accept 3 parameters - keys, context, plan_point
-        #   and returns hash where ids are keys and values are batch loaded objects/
+        # @param block [Proc] Block that can accept 3 parameters - ids, context, plan_point
+        #   and returns hash with ids as keys and values are batch loaded objects
         #
         # @return [void]
         #
-        def define(loader_name, &block)
-          unless block
-            raise SeregaError, "Block must be given to #define method"
+        def define(loader_name, callable = nil, &block)
+          if (!callable && !block) || (callable && block)
+            raise SeregaError, "Batch loader can be specified with one of arguments - callable value or &block"
           end
 
-          params = block.parameters
-          if params.count > 3 || !params.all? { |param| (param[0] == :req) || (param[0] == :opt) }
-            raise SeregaError, "Block can have maximum 3 regular parameters"
+          callable ||= block
+          SeregaValidations::Utils::CheckExtraKeywordArg.call(callable, "batch loader `#{loader_name}`")
+          params_count = SeregaUtils::ParamsCount.call(callable, max_count: 3)
+
+          if params_count > 3
+            raise SeregaError, "Batch loader can have maximum 3 parameters (ids, context, plan)"
           end
 
-          loaders[loader_name] = block
+          loaders[loader_name] = callable
         end
 
         # Shows defined loaders
@@ -41,16 +44,6 @@ class Serega
           opts[:loaders]
         end
 
-        #
-        # Finds previously defined batch loader by name
-        #
-        # @param loader_name [Symbol]
-        #
-        # @return [Proc] batch loader block
-        def fetch_loader(loader_name)
-          loaders[loader_name] || (raise SeregaError, "Batch loader with name `#{loader_name.inspect}` was not defined. Define example: config.batch.define(:#{loader_name}) { |keys, ctx, points| ... }")
-        end
-
         # Shows option to auto hide attributes with :batch specified
         # @return [Boolean, nil] option value
         def auto_hide
@@ -64,17 +57,19 @@ class Serega
           opts[:auto_hide] = value
         end
 
-        # Shows default key for :batch option
-        # @return [Symbol, nil] default key for :batch option
-        def default_key
-          opts[:default_key]
+        # Shows method name or callable object needed to get object identifier for batch load
+        # @return [Symbol, #call, nil] Default method name or callable object to get identifier
+        def id_method
+          opts[:id_method]
         end
 
-        # @param value [Symbol] New :default_key option value
+        # Sets new identifier method name or callable value needed for batch loading
+        #
+        # @param value [Symbol, #call] New :id_method value
         # @return [Boolean] New option value
-        def default_key=(value)
-          raise SeregaError, "Must be a Symbol, #{value.inspect} provided" unless value.is_a?(Symbol)
-          opts[:default_key] = value
+        def id_method=(value)
+          CheckBatchOptIdMethod.call(value)
+          opts[:id_method] = value
         end
       end
     end

data/lib/serega/plugins/batch/lib/modules/attribute_normalizer.rb

@@ -42,22 +42,37 @@ class Serega
           batch = init_opts[:batch]
           return unless batch
 
-          # take loader
-          loader = batch[:loader]
+          loader = prepare_batch_loader(batch[:loader])
 
-          # take key
-          key = batch[:key] || self.class.serializer_class.config.batch.default_key
-          proc_key =
-            if key.is_a?(Symbol)
-              proc { |object| object.public_send(key) }
-            else
-              key
-            end
+          id_method = batch[:id_method] || self.class.serializer_class.config.batch.id_method
+          id_method = prepare_batch_id_method(id_method)
 
-          # take default value
           default = batch.fetch(:default) { many ? FROZEN_EMPTY_ARRAY : nil }
 
-          {loader: loader, key: proc_key, default: default}
+          {loader: loader, id_method: id_method, default: default}
+        end
+
+        def prepare_batch_id_method(id_method)
+          return proc { |object| object.public_send(id_method) } if id_method.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(id_method, max_count: 2)
+          case params_count
+          when 0 then proc { id_method.call }
+          when 1 then proc { |object| id_method.call(object) }
+          else id_method
+          end
+        end
+
+        def prepare_batch_loader(loader)
+          loader = self.class.serializer_class.config.batch.loaders.fetch(loader) if loader.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
+          case params_count
+          when 0 then proc { loader.call }
+          when 1 then proc { |object| loader.call(object) }
+          when 2 then proc { |object, context| loader.call(object, context) }
+          else loader
+          end
         end
       end
     end

data/lib/serega/plugins/batch/lib/modules/object_serializer.rb

@@ -19,8 +19,8 @@ class Serega
         end
 
         def remember_key_for_batch_loading(batch, object, point, container)
-          key = batch[:key].call(object, context)
-          batch_loader(point).remember(key, container)
+          id = batch[:id_method].call(object, context)
+          batch_loader(point).remember(id, container)
           container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
         end
 

data/lib/serega/plugins/batch/lib/modules/plan_point.rb

@@ -13,25 +13,8 @@ class Serega
         # Returns attribute :batch option with prepared loader
         # @return [Hash] attribute :batch option
         #
-        attr_reader :batch
-
-        private
-
-        def set_normalized_vars
-          super
-          @batch = prepare_batch
-        end
-
-        def prepare_batch
-          batch = attribute.batch
-          if batch
-            loader = batch[:loader]
-            if loader.is_a?(Symbol)
-              batch_config = attribute.class.serializer_class.config.batch
-              batch[:loader] = batch_config.fetch_loader(loader)
-            end
-          end
-          batch
+        def batch
+          attribute.batch
         end
       end
     end