serega 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b6c3672a4fc40557f4fef3e650de56c84bf23d96defabd3f3f04aa5f273aa90
-  data.tar.gz: 79bcc2c3526b0ae141de69003e0834c94f9b7bade028cbc85bed20c3f3ba1757
+  metadata.gz: 6a94d74dd45c74e499cd1a3abec082d8776019538b67bf24fc840512271adb6b
+  data.tar.gz: a22bc547e6ac94b0988e2cfef2af31ad659beb53058a90159e7f46f6470c3390
 SHA512:
-  metadata.gz: edcc6856f212848b721af517bb0f77695e6e7f2adbc7bb687e4573a62efe84e02266301cc3e70647b7cd8385b96901436ce1ded9446e9712f3884d8d6348c855
-  data.tar.gz: e0fec25bc4471ebbf3b6fbfb1967101af7f8cd7e703cb56eba935fd51bc6de0efe87d802be8257a950648afc633ed3ceb3bfc78f67b3905197ffa0a6e39ada32
+  metadata.gz: d89c6180d4af0273eee6dd6179a0ac6f0157409f07ae6c18985941ecd8971bd17eb8b547a764d97afd12cdc08e565cb8749e9d9e0a70d8ab8add5dbad3e349db
+  data.tar.gz: 4cd808491f38a469ac705f6884007a3d71cead7f12d8e9730ec8c15ee1da97cb2d0d7503aafc0925a5bf41c7b660f7aa71a62da6fda295e713b62114ee83842a

data/README.md

@@ -111,6 +111,23 @@ class UserSerializer < Serega
 end
 ```
 
+---
+
+⚠️ Attribute names are checked to include only "a-z", "A-Z", "0-9", "_", "-", "~" characters.
+We have this check as:
+- Attributes names can be used in URL without encoding.
+- Plugin [string_modifiers][string_modifiers] already uses "," and "()" as attribute names delimeters.
+- We are protected from errors when added some non-english character looking as english.
+
+This names check can be disabled globally or per-serializer via:
+```ruby
+Serega.config.check_attribute_name = false
+
+class SomeSerializer < Serega
+  config.check_attribute_name = false
+end
+```
+
 ### Serializing
 
 We can serialize objects using class methods `.to_h`, `.to_json`, `.as_json` and same instance methods `#to_h`, `#to_json`, `#as_json`.

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.10.0

data/lib/serega/attribute.rb

@@ -51,6 +51,10 @@ class Serega
       end
 
       # Shows current opts[:hide] option
+      #
+      # Patched in:
+      # - plugin :preloads (returns true by default if config option auto_hide_attribute_with_preloads is enabled)
+      #
       # @return [Boolean, nil] Attribute :hide option value
       def hide
         opts[:hide]
@@ -82,7 +86,11 @@ class Serega
           end
       end
 
-      # Returns final block that will be used to find attribute value
+      # Returns final block used to find attribute value
+      #
+      # Patched in:
+      # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
+      #
       # @return [Proc] Proc to find attribute value
       def value_block
         return @value_block if instance_variable_defined?(:@value_block)

data/lib/serega/config.rb

@@ -17,6 +17,7 @@ class Serega
       initiate_keys: %i[only with except check_initiate_params].freeze,
       attribute_keys: %i[key value serializer many hide const delegate].freeze,
       serialize_keys: %i[context many].freeze,
+      check_attribute_name: true,
       check_initiate_params: true,
       max_cached_map_per_serializer_count: 0,
       to_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
@@ -102,6 +103,21 @@ class Serega
         opts[:max_cached_map_per_serializer_count] = value
       end
 
+      # Returns whether attributes names check is disabled
+      def check_attribute_name
+        opts.fetch(:check_attribute_name)
+      end
+
+      # Sets :check_attribute_name config option
+      #
+      # @param value [Boolean] Set :check_attribute_name config option
+      #
+      # @return [Boolean] New :check_attribute_name config option
+      def check_attribute_name=(value)
+        raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
+        opts[:check_attribute_name] = value
+      end
+
       # Returns current `to_json` adapter
       # @return [#call] Callable that used to construct JSON
       def to_json

data/lib/serega/object_serializer.rb

@@ -41,22 +41,30 @@ class Serega
         object.map { |obj| serialize_object(obj) }
       end
 
+      # Patched in:
+      # - plugin :presenter (makes presenter_object and serializes it)
       def serialize_object(object)
         points.each_with_object({}) do |point, container|
           serialize_point(object, point, container)
         end
       end
 
+      # Patched in:
+      # - plugin :if (conditionally skips serializing this point)
       def serialize_point(object, point, container)
         attach_value(object, point, container)
       end
 
+      # Patched in:
+      # - plugin :batch (remembers key for batch loading values instead of attaching)
       def attach_value(object, point, container)
         value = point.value(object, context)
         final_value = final_value(value, point)
         attach_final_value(final_value, point, container)
       end
 
+      # Patched in:
+      # - plugin :if (conditionally skips attaching)
       def attach_final_value(final_value, point, container)
         container[point.name] = final_value
       end

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

@@ -262,12 +262,9 @@ class Serega
 
         def attach_value(object, point, container)
           batch = point.batch
+          return super unless batch
 
-          if batch
-            remember_key_for_batch_loading(batch, object, point, container)
-          else
-            super
-          end
+          remember_key_for_batch_loading(batch, object, point, container)
         end
 
         def remember_key_for_batch_loading(batch, object, point, container)

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

@@ -68,6 +68,9 @@ class Serega
             end
           end
 
+          # Patched in:
+          # - plugin batch (extension :activerecord_preloads - preloads data to found values)
+          # - plugin batch (extension :formatters - formats values)
           def keys_values
             ids = keys.keys
 

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

@@ -66,19 +66,6 @@ class Serega
         serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
       end
 
-      # Checks requirements and loads additional plugins
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] loaded plugins opts
-      #
-      # @return [void]
-      #
-      def self.before_load_plugin(serializer_class, **opts)
-        if serializer_class.plugin_used?(:batch)
-          raise SeregaError, "Plugin `#{plugin_name}` must be loaded before `batch`"
-        end
-      end
-
       #
       # Adds config options and runs other callbacks after plugin was loaded
       #

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

@@ -60,10 +60,18 @@ class Serega
           private
 
           def check(path, opts, block)
-            CheckPath.call(path)
-            CheckOpts.call(opts, self.class.serializer_class.config.metadata.attribute_keys)
+            CheckPath.call(path) if check_attribute_name
+            CheckOpts.call(opts, attribute_keys)
             CheckBlock.call(block)
           end
+
+          def attribute_keys
+            self.class.serializer_class.config.metadata.attribute_keys
+          end
+
+          def check_attribute_name
+            self.class.serializer_class.config.check_attribute_name
+          end
         end
 
         extend Serega::SeregaHelpers::SerializerClassHelper

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

@@ -130,19 +130,6 @@ class Serega
       # @see Serega::SeregaConfig
       #
       module ClassMethods
-        private def inherited(subclass)
-          super
-
-          meta_attribute_class = Class.new(self::MetaAttribute)
-          meta_attribute_class.serializer_class = subclass
-          subclass.const_set(:MetaAttribute, meta_attribute_class)
-
-          # Assign same metadata attributes
-          meta_attributes.each_value do |attr|
-            subclass.meta_attribute(*attr.path, **attr.opts, &attr.block)
-          end
-        end
-
         #
         # List of added metadata attributes
         #
@@ -165,6 +152,21 @@ class Serega
           attribute = self::MetaAttribute.new(path: path, opts: opts, block: block)
           meta_attributes[attribute.name] = attribute
         end
+
+        private
+
+        def inherited(subclass)
+          super
+
+          meta_attribute_class = Class.new(self::MetaAttribute)
+          meta_attribute_class.serializer_class = subclass
+          subclass.const_set(:MetaAttribute, meta_attribute_class)
+
+          # Assign same metadata attributes
+          meta_attributes.each_value do |attr|
+            subclass.meta_attribute(*attr.path, **attr.opts, &attr.block)
+          end
+        end
       end
 
       #

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

@@ -8,16 +8,15 @@ class Serega
         # Validator for meta_attribute :path parameter
         #
         class CheckPath
-          FORMAT_ONE_CHAR = /\A[a-zA-Z0-9]\z/
-          FORMAT_MANY_CHARS = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*?[a-zA-Z0-9]\z/ # allow '-' and '_' in the middle
+          # Regexp for valid path
+          FORMAT = /\A[\w~-]+\z/
 
-          private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+          private_constant :FORMAT
 
           class << self
             #
-            # Checks allowed characters in specified metadata path parts.
-            # Globally allowed characters: "a-z", "A-Z", "0-9".
-            # Minus and low line "-", "_" also allowed except as the first or last character.
+            # Checks allowed characters.
+            # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
             #
             # @param path [Array<String, Symbol>] Metadata attribute path names
             #
@@ -33,20 +32,14 @@ class Serega
             def check_name(name)
               name = name.to_s
 
-              valid =
-                case name.size
-                when 0 then false
-                when 1 then name.match?(FORMAT_ONE_CHAR)
-                else name.match?(FORMAT_MANY_CHARS)
-                end
-
-              return if valid
-
-              raise SeregaError, message(name)
+              raise SeregaError, message(name) unless FORMAT.match?(name)
             end
 
             def message(name)
-              %(Invalid metadata path #{name.inspect}, globally allowed characters: "a-z", "A-Z", "0-9". Minus and low line "-", "_" also allowed except as the first or last character)
+              <<~MESSAGE.tr("\n", "")
+                Invalid metadata path #{name.inspect}.
+                 Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~"
+              MESSAGE
             end
           end
         end

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

@@ -235,6 +235,8 @@ class Serega
           @auto_hide_attribute_with_preloads = auto && !preloads.nil? && (preloads != false) && (preloads != {})
         end
 
+        # Patched in:
+        # - plugin :batch (extension :preloads - skips auto preloads when batch option provided)
         def get_preloads
           preloads_provided = opts.key?(:preload)
           preloads =

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

@@ -80,14 +80,6 @@ class Serega
       # @see Serega
       #
       module ClassMethods
-        private def inherited(subclass)
-          super
-
-          presenter_class = Class.new(self::Presenter)
-          presenter_class.serializer_class = subclass
-          subclass.const_set(:Presenter, presenter_class)
-        end
-
         # Overrides {Serega::ClassMethods#attribute} method, additionally adds method
         # to Presenter to not hit {Serega::SeregaPlugins::Presenter::Presenter#method_missing}
         # @see Serega::ClassMethods#attribute
@@ -96,6 +88,16 @@ class Serega
             self::Presenter.def_delegator(:__getobj__, attribute.key) unless attribute.block
           end
         end
+
+        private
+
+        def inherited(subclass)
+          super
+
+          presenter_class = Class.new(self::Presenter)
+          presenter_class.serializer_class = subclass
+          subclass.const_set(:Presenter, presenter_class)
+        end
       end
 
       #

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

@@ -25,72 +25,61 @@ class Serega
       # Modifiers parser
       #
       class ParseStringModifiers
-        #
-        # Parses provided fields
-        #
-        # @param fields [String,Hash,Array,nil]
-        #
-        # @return [Hash] parsed modifiers in form of nested hash
-        #
-        def self.call(fields)
-          return fields unless fields.is_a?(String)
+        class << self
+          #
+          # Parses string modifiers
+          #
+          # @param fields [String]
+          #
+          # @return [Hash] parsed modifiers in form of nested hash
+          #
+          # @example
+          #   parse("user") => { user: {} }
+          #   parse("user(id)") => { user: { id: {} } }
+          #   parse("user(id,name)") => { user: { id: {}, name: {} } }
+          #   parse("user,comments") => { user: {}, comments: {} }
+          #   parse("user(comments(text))") => { user: { comments: { text: {} } } }
+          def parse(fields)
+            res = {}
+            attribute = +""
+            char = +""
+            path_stack = nil
+            fields = StringIO.new(fields)
 
-          new.parse(fields)
-        end
-
-        #
-        # Parses string modifiers
-        #
-        # @param fields [String]
-        #
-        # @return [Hash] parsed modifiers in form of nested hash
-        #
-        # @example
-        #   parse("user") => { user: {} }
-        #   parse("user(id)") => { user: { id: {} } }
-        #   parse("user(id,name)") => { user: { id: {}, name: {} } }
-        #   parse("user,comments") => { user: {}, comments: {} }
-        #   parse("user(comments(text))") => { user: { comments: { text: {} } } }
-        def parse(fields)
-          res = {}
-          attribute = +""
-          char = +""
-          path_stack = nil
-          fields = StringIO.new(fields)
-
-          while fields.read(1, char)
-            case char
-            when ","
-              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
-            when ")"
-              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
-              path_stack&.pop
-            when "("
-              name = add_attribute(res, path_stack, attribute, {})
-              (path_stack ||= []).push(name) if name
-            else
-              attribute.insert(-1, char)
+            while fields.read(1, char)
+              case char
+              when ","
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+              when ")"
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+                path_stack&.pop
+              when "("
+                name = add_attribute(res, path_stack, attribute, {})
+                (path_stack ||= []).push(name) if name
+              else
+                attribute.insert(-1, char)
+              end
             end
-          end
 
-          add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+            add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
 
-          res
-        end
+            res
+          end
 
-        private
+          private
 
-        def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
-          attribute.strip!
-          return if attribute.empty?
+          def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
+            attribute.strip!
+            return if attribute.empty?
 
-          name = attribute.to_sym
-          attribute.clear
+            name = attribute.to_sym
+            attribute.clear
 
-          current_attrs = (!path_stack || path_stack.empty?) ? res : res.dig(*path_stack)
-          current_attrs[name] = nested_attributes
+            current_attrs = (!path_stack || path_stack.empty?) ? res : res.dig(*path_stack)
+            current_attrs[name] = nested_attributes
 
-          name
+            name
+          end
         end
       end
     end

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

@@ -29,14 +29,10 @@ class Serega
       module InstanceMethods
         private
 
-        def prepare_modifiers(opts)
-          parsed_opts =
-            opts.each_with_object({}) do |(key, value), obj|
-              value = ParseStringModifiers.call(value) if (key == :only) || (key == :except) || (key == :with)
-              obj[key] = value
-            end
+        def parse_modifier(value)
+          return ParseStringModifiers.parse(value) if value.is_a?(String)
 
-          super(parsed_opts)
+          super
         end
       end
     end

data/lib/serega/utils/enum_deep_dup.rb

@@ -38,8 +38,8 @@ class Serega
         end
 
         def dup_array_values(duplicate_data)
-          duplicate_data.each_with_index do |value, index|
-            duplicate_data[index] = call(value) if value.is_a?(Enumerable)
+          duplicate_data.map! do |value|
+            value.is_a?(Enumerable) ? call(value) : value
           end
         end
       end

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

@@ -7,19 +7,13 @@ class Serega
       # Attribute `name` parameter validator
       #
       class CheckName
-        # Regexp for valid one-char attribute name
-        FORMAT_ONE_CHAR = /\A[a-zA-Z0-9]\z/
-
-        # Regexp for valid multi-chars attribute name
-        FORMAT_MANY_CHARS = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*?[a-zA-Z0-9]\z/ # allow '-' and '_' in the middle
-
-        private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+        # Regexp for valid attribute name
+        FORMAT = /\A[\w~-]+\z/
 
         class << self
           #
           # Checks allowed characters.
-          # Globally allowed characters: "a-z", "A-Z", "0-9".
-          # Minus and low line "-", "_" also allowed except as the first or last character.
+          # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
           #
           # @param name [String, Symbol] Attribute name
           #
@@ -28,23 +22,16 @@ class Serega
           #
           def call(name)
             name = SeregaUtils::SymbolName.call(name)
-
-            valid =
-              case name.size
-              when 0 then false
-              when 1 then name.match?(FORMAT_ONE_CHAR)
-              else name.match?(FORMAT_MANY_CHARS)
-              end
-
-            return if valid
-
-            raise SeregaError, message(name)
+            raise SeregaError, message(name) unless FORMAT.match?(name)
           end
 
           private
 
           def message(name)
-            %(Invalid attribute name = #{name.inspect}. Globally allowed characters: "a-z", "A-Z", "0-9". Minus and low line "-", "_" also allowed except as the first or last character)
+            <<~MESSAGE.tr("\n", "")
+              Invalid attribute name = #{name.inspect}.
+               Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~"
+            MESSAGE
           end
         end
       end

data/lib/serega/validations/check_attribute_params.rb

@@ -41,7 +41,7 @@ class Serega
         # Validates attribute params
         #
         def validate
-          check_name
+          check_name if check_attribute_name
           check_opts
           check_block
         end
@@ -52,6 +52,11 @@ class Serega
           Attribute::CheckName.call(name)
         end
 
+        # Patched in:
+        # - plugin :batch (checks :batch option)
+        # - plugin :context_metadata (checks context metadata option which is :meta by default)
+        # - plugin :if (checks :if, :if_value, :unless, :unless_value options)
+        # - plugin :preloads (checks :preload option)
         def check_opts
           Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
 
@@ -71,6 +76,10 @@ class Serega
         def allowed_opts_keys
           self.class.serializer_class.config.attribute_keys
         end
+
+        def check_attribute_name
+          self.class.serializer_class.config.check_attribute_name
+        end
       end
 
       include InstanceMethods

data/lib/serega.rb

@@ -70,49 +70,6 @@ class Serega
     # Returns current config
     # @return [SeregaConfig] current serializer config
     attr_reader :config
-
-    private def inherited(subclass)
-      config_class = Class.new(self::SeregaConfig)
-      config_class.serializer_class = subclass
-      subclass.const_set(:SeregaConfig, config_class)
-      subclass.instance_variable_set(:@config, subclass::SeregaConfig.new(config.opts))
-
-      attribute_class = Class.new(self::SeregaAttribute)
-      attribute_class.serializer_class = subclass
-      subclass.const_set(:SeregaAttribute, attribute_class)
-
-      map_class = Class.new(self::SeregaMap)
-      map_class.serializer_class = subclass
-      subclass.const_set(:SeregaMap, map_class)
-
-      map_point_class = Class.new(self::SeregaMapPoint)
-      map_point_class.serializer_class = subclass
-      subclass.const_set(:SeregaMapPoint, map_point_class)
-
-      object_serializer_class = Class.new(self::SeregaObjectSerializer)
-      object_serializer_class.serializer_class = subclass
-      subclass.const_set(:SeregaObjectSerializer, object_serializer_class)
-
-      check_attribute_params_class = Class.new(self::CheckAttributeParams)
-      check_attribute_params_class.serializer_class = subclass
-      subclass.const_set(:CheckAttributeParams, check_attribute_params_class)
-
-      check_initiate_params_class = Class.new(self::CheckInitiateParams)
-      check_initiate_params_class.serializer_class = subclass
-      subclass.const_set(:CheckInitiateParams, check_initiate_params_class)
-
-      check_serialize_params_class = Class.new(self::CheckSerializeParams)
-      check_serialize_params_class.serializer_class = subclass
-      subclass.const_set(:CheckSerializeParams, check_serialize_params_class)
-
-      # Assign same attributes
-      attributes.each_value do |attr|
-        subclass.attribute(attr.name, **attr.opts, &attr.block)
-      end
-
-      super
-    end
-
     #
     # Enables plugin for current serializer
     #
@@ -170,6 +127,9 @@ class Serega
     #
     # Adds attribute
     #
+    # Patched in:
+    # - plugin :presenter (additionally adds method in Presenter class)
+    #
     # @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.
@@ -250,6 +210,54 @@ class Serega
     def as_json(object, opts = nil)
       config.from_json.call(to_json(object, opts))
     end
+
+    private
+
+    # Patched in:
+    # - plugin :batch (defines SeregaBatchLoaders, SeregaBatchLoader)
+    # - plugin :metadata (defines MetaAttribute and copies meta_attributes to subclasses)
+    # - plugin :presenter (defines Presenter)
+    def inherited(subclass)
+      config_class = Class.new(self::SeregaConfig)
+      config_class.serializer_class = subclass
+      subclass.const_set(:SeregaConfig, config_class)
+      subclass.instance_variable_set(:@config, subclass::SeregaConfig.new(config.opts))
+
+      attribute_class = Class.new(self::SeregaAttribute)
+      attribute_class.serializer_class = subclass
+      subclass.const_set(:SeregaAttribute, attribute_class)
+
+      map_class = Class.new(self::SeregaMap)
+      map_class.serializer_class = subclass
+      subclass.const_set(:SeregaMap, map_class)
+
+      map_point_class = Class.new(self::SeregaMapPoint)
+      map_point_class.serializer_class = subclass
+      subclass.const_set(:SeregaMapPoint, map_point_class)
+
+      object_serializer_class = Class.new(self::SeregaObjectSerializer)
+      object_serializer_class.serializer_class = subclass
+      subclass.const_set(:SeregaObjectSerializer, object_serializer_class)
+
+      check_attribute_params_class = Class.new(self::CheckAttributeParams)
+      check_attribute_params_class.serializer_class = subclass
+      subclass.const_set(:CheckAttributeParams, check_attribute_params_class)
+
+      check_initiate_params_class = Class.new(self::CheckInitiateParams)
+      check_initiate_params_class.serializer_class = subclass
+      subclass.const_set(:CheckInitiateParams, check_initiate_params_class)
+
+      check_serialize_params_class = Class.new(self::CheckSerializeParams)
+      check_serialize_params_class.serializer_class = subclass
+      subclass.const_set(:CheckSerializeParams, check_serialize_params_class)
+
+      # Assign same attributes
+      attributes.each_value do |attr|
+        subclass.attribute(attr.name, **attr.opts, &attr.block)
+      end
+
+      super
+    end
   end
 
   #
@@ -266,7 +274,7 @@ class Serega
     # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
     #
     def initialize(opts = nil)
-      @opts = (opts.nil? || opts.empty?) ? FROZEN_EMPTY_HASH : prepare_modifiers(opts)
+      @opts = (opts.nil? || opts.empty?) ? FROZEN_EMPTY_HASH : parse_modifiers(opts)
       self.class::CheckInitiateParams.new(@opts).validate if opts&.fetch(:check_initiate_params) { config.check_initiate_params }
     end
 
@@ -340,13 +348,29 @@ class Serega
       self.class.config
     end
 
-    def prepare_modifiers(opts)
-      opts.each_with_object({}) do |(key, value), obj|
-        value = SeregaUtils::ToHash.call(value) if (key == :only) || (key == :except) || (key == :with)
-        obj[key] = value
+    def parse_modifiers(opts)
+      result = {}
+
+      opts.each do |key, value|
+        value = parse_modifier(value) if (key == :only) || (key == :except) || (key == :with)
+        result[key] = value
       end
+
+      result
+    end
+
+    # Patched in:
+    # - plugin :string_modifiers (parses string modifiers differently)
+    def parse_modifier(value)
+      SeregaUtils::ToHash.call(value)
     end
 
+    # Patched in:
+    # - plugin :activerecord_preloads (loads defined :preloads to object)
+    # - plugin :batch (runs serialization of collected batches)
+    # - plugin :root (wraps result `{ root => result }`)
+    # - plugin :context_metadata (adds context metadata to final result)
+    # - plugin :metadata (adds metadata to final result)
     def serialize(object, opts)
       self.class::SeregaObjectSerializer
         .new(**opts, points: map)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-22 00:00:00.000000000 Z
+date: 2023-03-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer