serega 0.15.0 → 0.17.0

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

@@ -10,31 +10,45 @@ class Serega
         class CheckOpts
           class << self
             #
-            # Validates attribute options
+            # Validates meta_attribute options
             # Checks used options are allowed and then checks options values.
             #
             # @param opts [Hash] Attribute options
-            # @param attribute_keys [Array<Symbol>] Allowed options keys
+            # @param block [Proc] Attribute block
+            # @param allowed_keys [Array<Symbol>] Allowed options keys
             #
             # @raise [SeregaError] when attribute has invalid options
             #
             # @return [void]
             #
-            def call(opts, attribute_keys)
+            def call(opts, block, allowed_keys)
+              check_allowed_options_keys(opts, allowed_keys)
+              check_each_opt(opts, block)
+              check_any_value_provided(opts, block)
+            end
+
+            private
+
+            def check_allowed_options_keys(opts, allowed_keys)
               opts.each_key do |key|
-                next if attribute_keys.include?(key.to_sym)
+                next if allowed_keys.include?(key.to_sym)
 
-                raise SeregaError, "Invalid option #{key.inspect}. Allowed options are: #{attribute_keys.map(&:inspect).join(", ")}"
+                allowed = allowed_keys.map(&:inspect).join(", ")
+                raise SeregaError, "Invalid option #{key.inspect}. Allowed options are: #{allowed}"
               end
-
-              check_each_opt(opts)
             end
 
-            private
-
-            def check_each_opt(opts)
+            def check_each_opt(opts, block)
               CheckOptHideEmpty.call(opts)
               CheckOptHideNil.call(opts)
+              CheckOptValue.call(opts, block)
+              CheckOptConst.call(opts, block)
+            end
+
+            def check_any_value_provided(opts, block)
+              return if opts.key?(:const) || opts.key?(:value) || block
+
+              raise SeregaError, "Please provide block argument or add :value or :const option"
             end
           end
         end

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

@@ -36,7 +36,7 @@ class Serega
             if preloads_provided
               opts[:preload]
             elsif opts.key?(:serializer) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_serializer
-              key
+              method_name
             elsif opts.key?(:delegate) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_delegate
               opts[:delegate].fetch(:to)
             end

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

@@ -22,18 +22,25 @@ class Serega
           #
           # Transforms user provided preloads to array of paths
           #
-          # @param value [Array,Hash,String,Symbol,nil,false] preloads
+          # @param preloads [Array,Hash,String,Symbol,nil,false] association(s) to preload
           #
           # @return [Hash] preloads transformed to hash
           #
-          def call(preloads, path = [], result = [])
-            preloads = FormatUserPreloads.call(preloads)
+          def call(preloads)
+            formatted_preloads = FormatUserPreloads.call(preloads)
+            return FROZEN_EMPTY_ARRAY if formatted_preloads.empty?
 
-            preloads.each do |key, nested_preloads|
+            paths(formatted_preloads, [], [])
+          end
+
+          private
+
+          def paths(formatted_preloads, path, result)
+            formatted_preloads.each do |key, nested_preloads|
               path << key
               result << path.dup
 
-              call(nested_preloads, path, result)
+              paths(nested_preloads, path, result)
               path.pop
             end
 

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

@@ -11,7 +11,7 @@ class Serega
           #
           # Constructs preloads hash for given attributes plan
           #
-          # @param plan [Array<Serega::PlanPoint>] Serialization plan
+          # @param plan [Array<SeregaPlanPoint>] Serialization plan
           #
           # @return [Hash]
           #

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

@@ -15,7 +15,7 @@ class Serega
     #
     # This options are very handy if you want to forget about finding preloads manually.
     #
-    # Preloads can be disabled with `preload: false` attribute option option.
+    # Preloads can be disabled with `preload: false` attribute option.
     # Also automatically added preloads can be overwritten with manually specified `preload: :another_value`.
     #
     # Some examples, **please read comments in the code below**
@@ -79,17 +79,17 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
-        require_relative "./lib/format_user_preloads"
-        require_relative "./lib/modules/attribute"
-        require_relative "./lib/modules/attribute_normalizer"
-        require_relative "./lib/modules/check_attribute_params"
-        require_relative "./lib/modules/config"
-        require_relative "./lib/modules/plan_point"
-        require_relative "./lib/preload_paths"
-        require_relative "./lib/preloads_config"
-        require_relative "./lib/preloads_constructor"
-        require_relative "./validations/check_opt_preload"
-        require_relative "./validations/check_opt_preload_path"
+        require_relative "lib/format_user_preloads"
+        require_relative "lib/modules/attribute"
+        require_relative "lib/modules/attribute_normalizer"
+        require_relative "lib/modules/check_attribute_params"
+        require_relative "lib/modules/config"
+        require_relative "lib/modules/plan_point"
+        require_relative "lib/preload_paths"
+        require_relative "lib/preloads_config"
+        require_relative "lib/preloads_constructor"
+        require_relative "validations/check_opt_preload"
+        require_relative "validations/check_opt_preload_path"
 
         serializer_class.include(InstanceMethods)
         serializer_class::SeregaAttribute.include(AttributeInstanceMethods)

data/lib/serega/plugins/root/root.rb

@@ -127,7 +127,7 @@ class Serega
         # @option opts [Symbol, String, nil] :one root for single-object serialization
         # @option opts [Symbol, String, nil] :many root for many-objects serialization
         #
-        # @return [Serega::SeregaPlugins::Root::RootConfig] RootConfig object
+        # @return [SeregaPlugins::Root::RootConfig] RootConfig object
         #
         def initialize(opts)
           @opts = opts

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

@@ -18,7 +18,7 @@ class Serega
       #
       def self.load_plugin(serializer_class, **_opts)
         serializer_class.include(InstanceMethods)
-        require_relative "./parse_string_modifiers"
+        require_relative "parse_string_modifiers"
       end
 
       #

data/lib/serega/utils/params_count.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Utilities
+  #
+  module SeregaUtils
+    #
+    # Utility to count regular parameters of callable object
+    #
+    class ParamsCount
+      NO_NAMED_REST_PARAM = [:rest].freeze
+      private_constant :NO_NAMED_REST_PARAM
+
+      class << self
+        #
+        # Count parameters for callable object
+        #
+        # @param object [#call] callable object
+        #
+        # @return [Integer] count of regular parameters
+        #
+        def call(object, max_count:)
+          # Procs (but not lambdas) can accept all provided parameters
+          parameters = object.is_a?(Proc) ? object.parameters : object.method(:call).parameters
+          return 1 if parameters[0] == NO_NAMED_REST_PARAM
+          return max_count if object.is_a?(Proc) && !object.lambda?
+
+          count = 0
+
+          # If all we have is no-name *rest parameters, then we assume we need to provide
+          # 1 argument. It is now always correct, but in serialization context it's most common that
+          # only one argument is needed.
+          parameters.each do |parameter|
+            next if parameter == NO_NAMED_REST_PARAM # Workaround for procs like :odd?.to_proc
+            param_type = parameter[0]
+
+            case param_type
+            when :req then count += 1
+            when :opt then count += 1 if count < max_count
+            when :rest then count += max_count - count if max_count > count
+            end # else :opt, :keyreq, :key, :keyrest, :block - do nothing
+          end
+
+          count
+        end
+      end
+    end
+  end
+end

data/lib/serega/utils/to_hash.rb

@@ -31,7 +31,7 @@ class Serega
           when NilClass, FalseClass then nil_to_hash(value)
           when String then string_to_hash(value)
           when Symbol then symbol_to_hash(value)
-          else raise SeregaError, "Cant convert #{value.class} class object to hash"
+          else raise SeregaError, "Can't convert #{value.class} class object to hash"
           end
         end
 

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

@@ -14,7 +14,6 @@ class Serega
           #
           # Checks block parameter provided with attribute.
           # Must have up to two arguments - object and context.
-          # It should not have any *rest or **key arguments
           #
           # @example without arguments
           #   attribute(:email) { CONSTANT_EMAIL }
@@ -40,14 +39,14 @@ class Serega
           private
 
           def check_block(block)
-            params = block.parameters
-            return if (params.count <= 2) && params.all? { |par| par[0] == :opt }
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(block, "block")
+            params_count = SeregaUtils::ParamsCount.call(block, max_count: 2)
 
-            raise SeregaError, block_error
+            raise SeregaError, block_error if params_count > 2
           end
 
           def block_error
-            "Block can have maximum two regular parameters (no **keyword or *array args)"
+            "Block can have maximum two parameters (object, context)"
           end
         end
       end

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

@@ -26,7 +26,7 @@ class Serega
           private
 
           def check_usage_with_other_params(opts, block)
-            raise SeregaError, "Option :const can not be used together with option :key" if opts.key?(:key)
+            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 block" if block
           end

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

@@ -32,8 +32,9 @@ class Serega
 
             delegate_opts = opts[:delegate]
             check_opt_delegate_to(delegate_opts)
-            check_opt_delegate_key(delegate_opts)
+            check_opt_delegate_method(delegate_opts)
             check_opt_delegate_allow_nil(delegate_opts)
+            check_opt_delegate_extra_opts(delegate_opts)
           end
 
           def check_opt_delegate_to(delegate_opts)
@@ -43,16 +44,20 @@ class Serega
             Utils::CheckOptIsStringOrSymbol.call(delegate_opts, :to)
           end
 
-          def check_opt_delegate_key(delegate_opts)
-            Utils::CheckOptIsStringOrSymbol.call(delegate_opts, :key)
+          def check_opt_delegate_method(delegate_opts)
+            Utils::CheckOptIsStringOrSymbol.call(delegate_opts, :method)
           end
 
           def check_opt_delegate_allow_nil(delegate_opts)
             Utils::CheckOptIsBool.call(delegate_opts, :allow_nil)
           end
 
+          def check_opt_delegate_extra_opts(delegate_opts)
+            Utils::CheckAllowedKeys.call(delegate_opts, %i[to method allow_nil], :delegate)
+          end
+
           def check_usage_with_other_params(opts, block)
-            raise SeregaError, "Option :delegate can not be used together with option :key" if opts.key?(:key)
+            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 block" if block

data/lib/serega/validations/attribute/{check_opt_key.rb → check_opt_method.rb}

@@ -4,12 +4,12 @@ class Serega
   module SeregaValidations
     module Attribute
       #
-      # Attribute `:key` option validator
+      # Attribute `:method` option validator
       #
-      class CheckOptKey
+      class CheckOptMethod
         class << self
           #
-          # Checks attribute :key option
+          # Checks attribute :method option
           #
           # @param opts [Hash] Attribute options
           #
@@ -18,18 +18,18 @@ class Serega
           # @return [void]
           #
           def call(opts, block = nil)
-            return unless opts.key?(:key)
+            return unless opts.key?(:method)
 
             check_usage_with_other_params(opts, block)
-            Utils::CheckOptIsStringOrSymbol.call(opts, :key)
+            Utils::CheckOptIsStringOrSymbol.call(opts, :method)
           end
 
           private
 
           def check_usage_with_other_params(opts, block)
-            raise SeregaError, "Option :key can not be used together with option :const" if opts.key?(:const)
-            raise SeregaError, "Option :key can not be used together with option :value" if opts.key?(:value)
-            raise SeregaError, "Option :key can not be used together with block" if block
+            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 block" if block
           end
         end
       end

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

@@ -21,33 +21,37 @@ class Serega
             return unless opts.key?(:value)
 
             check_usage_with_other_params(opts, block)
-            check_proc(opts[:value])
+
+            check_value(opts[:value])
           end
 
           private
 
           def check_usage_with_other_params(opts, block)
-            raise SeregaError, "Option :value can not be used together with option :key" if opts.key?(:key)
+            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_proc(value)
-            raise SeregaError, value_error unless value.is_a?(Proc)
+          def check_value(value)
+            check_value_type(value)
+
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":value option")
+            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
 
-            params = value.parameters
+            raise SeregaError, params_count_error if params_count > 2
+          end
 
-            if value.lambda?
-              return if (params.count == 2) && params.all? { |par| par[0] == :req }
-            elsif (params.count <= 2) && params.all? { |par| par[0] == :opt }
-              return
-            end
+          def check_value_type(value)
+            raise SeregaError, type_error if !value.is_a?(Proc) && !value.respond_to?(:call)
+          end
 
-            raise SeregaError, value_error
+          def type_error
+            "Option :value value must be a Proc or respond to #call"
           end
 
-          def value_error
-            "Option :value must be a Proc that is able to accept two parameters (no **keyword or *array args)"
+          def params_count_error
+            "Option :value value can have maximum 2 parameters (object, context)"
           end
         end
       end

data/lib/serega/validations/check_attribute_params.rb

@@ -55,15 +55,16 @@ class Serega
         # Patched in:
         # - plugin :batch (checks :batch option)
         # - plugin :context_metadata (checks context metadata option which is :meta by default)
+        # - plugin :formatters (checks :format option)
         # - 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)
+          Utils::CheckAllowedKeys.call(opts, allowed_opts_keys, :attribute)
 
           Attribute::CheckOptConst.call(opts, block)
           Attribute::CheckOptDelegate.call(opts, block)
           Attribute::CheckOptHide.call(opts)
-          Attribute::CheckOptKey.call(opts, block)
+          Attribute::CheckOptMethod.call(opts, block)
           Attribute::CheckOptMany.call(opts)
           Attribute::CheckOptSerializer.call(opts)
           Attribute::CheckOptValue.call(opts, block)

data/lib/serega/validations/check_initiate_params.rb

@@ -35,7 +35,7 @@ class Serega
         private
 
         def check_allowed_keys
-          Utils::CheckAllowedKeys.call(opts, serializer_class.config.initiate_keys)
+          Utils::CheckAllowedKeys.call(opts, serializer_class.config.initiate_keys, :initiate)
         end
 
         def check_modifiers

data/lib/serega/validations/check_serialize_params.rb

@@ -33,7 +33,7 @@ class Serega
         private
 
         def check_opts
-          Utils::CheckAllowedKeys.call(opts, serializer_class.config.serialize_keys)
+          Utils::CheckAllowedKeys.call(opts, serializer_class.config.serialize_keys, :serialize)
 
           Utils::CheckOptIsHash.call(opts, :context)
           Utils::CheckOptIsBool.call(opts, :many)

data/lib/serega/validations/utils/check_allowed_keys.rb

@@ -18,11 +18,13 @@ class Serega
         # @raise [Serega::SeregaError] error when any hash key is not allowed
         #
         # @return [void]
-        def self.call(opts, allowed_keys)
+        def self.call(opts, allowed_keys, parameter_name)
           opts.each_key do |key|
             next if allowed_keys.include?(key)
 
-            raise SeregaError, "Invalid option #{key.inspect}. Allowed options are: #{allowed_keys.map(&:inspect).join(", ")}"
+            raise SeregaError,
+              "Invalid #{parameter_name} option #{key.inspect}." \
+              " Allowed options are: #{allowed_keys.map(&:inspect).sort.join(", ")}"
           end
         end
       end

data/lib/serega/validations/utils/check_extra_keyword_arg.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaValidations
+    #
+    # Validations Utilities
+    #
+    module Utils
+      #
+      # Utility to check that callable object has no required keyword arguments
+      #
+      class CheckExtraKeywordArg
+        # Checks hash keys are allowed
+        #
+        # @param callable [#call] Callable object
+        # @param callable_description [Symbol] Callable object description
+        #
+        # @raise [Serega::SeregaError] error if callable accepts required keyword argument
+        #
+        # @return [void]
+        def self.call(callable, callable_description)
+          parameters = callable.is_a?(Proc) ? callable.parameters : callable.method(:call).parameters
+
+          parameters.each do |parameter|
+            next unless parameter[0] == :keyreq
+
+            raise Serega::SeregaError, "Invalid #{callable_description}. It should not have any required keyword arguments"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega.rb

@@ -17,6 +17,7 @@ require_relative "serega/errors"
 require_relative "serega/helpers/serializer_class_helper"
 require_relative "serega/utils/enum_deep_dup"
 require_relative "serega/utils/enum_deep_freeze"
+require_relative "serega/utils/params_count"
 require_relative "serega/utils/symbol_name"
 require_relative "serega/utils/to_hash"
 require_relative "serega/json/adapter"
@@ -24,6 +25,7 @@ require_relative "serega/json/adapter"
 require_relative "serega/attribute"
 require_relative "serega/attribute_normalizer"
 require_relative "serega/validations/utils/check_allowed_keys"
+require_relative "serega/validations/utils/check_extra_keyword_arg"
 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"
@@ -32,8 +34,8 @@ require_relative "serega/validations/attribute/check_name"
 require_relative "serega/validations/attribute/check_opt_const"
 require_relative "serega/validations/attribute/check_opt_hide"
 require_relative "serega/validations/attribute/check_opt_delegate"
-require_relative "serega/validations/attribute/check_opt_key"
 require_relative "serega/validations/attribute/check_opt_many"
+require_relative "serega/validations/attribute/check_opt_method"
 require_relative "serega/validations/attribute/check_opt_serializer"
 require_relative "serega/validations/attribute/check_opt_value"
 require_relative "serega/validations/initiate/check_modifiers"
@@ -172,7 +174,20 @@ class Serega
       new(modifiers_opts).to_h(object, serialize_opts)
     end
 
-    # @see #call
+    #
+    # Serializes provided object to Hash
+    #
+    # @param object [Object] Serialized object
+    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
+    # @option opts [Array, Hash, String, Symbol] :only The only attributes to serialize
+    # @option opts [Array, Hash, String, Symbol] :except Attributes to hide
+    # @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)`)
+    #
+    # @return [Hash] Serialization result
+    #
     def to_h(object, opts = nil)
       call(object, opts)
     end
@@ -283,8 +298,17 @@ class Serega
     def initialize(opts = nil)
       @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 }
+
+      @plan = self.class::SeregaPlan.call(@opts)
     end
 
+    #
+    # Plan for serialization.
+    # This plan can be traversed to find serialized attributes and nested attributes.
+    #
+    # @return [Serega::SeregaPlan] Serialization plan
+    attr_reader :plan
+
     #
     # Serializes provided object to Hash
     #
@@ -338,15 +362,6 @@ class Serega
       config.from_json.call(json)
     end
 
-    #
-    # Plan for serialization.
-    # This plan can be traversed to find serialized attributes and nested attributes.
-    #
-    # @return [Array<Serega::SeregaPlanPoint>] plan
-    def plan
-      @plan ||= self.class::SeregaPlan.call(opts)
-    end
-
     private
 
     attr_reader :opts

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-13 00:00:00.000000000 Z
+date: 2023-11-03 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -58,7 +58,9 @@ files:
 - lib/serega/plugins/batch/lib/validations/check_batch_opt_key.rb
 - lib/serega/plugins/batch/lib/validations/check_batch_opt_loader.rb
 - lib/serega/plugins/batch/lib/validations/check_opt_batch.rb
+- lib/serega/plugins/camel_case/camel_case.rb
 - lib/serega/plugins/context_metadata/context_metadata.rb
+- lib/serega/plugins/depth_limit/depth_limit.rb
 - lib/serega/plugins/explicit_many_option/explicit_many_option.rb
 - lib/serega/plugins/explicit_many_option/validations/check_opt_many.rb
 - lib/serega/plugins/formatters/formatters.rb
@@ -70,8 +72,10 @@ files:
 - lib/serega/plugins/metadata/meta_attribute.rb
 - lib/serega/plugins/metadata/metadata.rb
 - lib/serega/plugins/metadata/validations/check_block.rb
+- lib/serega/plugins/metadata/validations/check_opt_const.rb
 - lib/serega/plugins/metadata/validations/check_opt_hide_empty.rb
 - lib/serega/plugins/metadata/validations/check_opt_hide_nil.rb
+- lib/serega/plugins/metadata/validations/check_opt_value.rb
 - lib/serega/plugins/metadata/validations/check_opts.rb
 - lib/serega/plugins/metadata/validations/check_path.rb
 - lib/serega/plugins/preloads/lib/format_user_preloads.rb
@@ -92,6 +96,7 @@ files:
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
 - lib/serega/utils/enum_deep_dup.rb
 - lib/serega/utils/enum_deep_freeze.rb
+- lib/serega/utils/params_count.rb
 - lib/serega/utils/symbol_name.rb
 - lib/serega/utils/to_hash.rb
 - lib/serega/validations/attribute/check_block.rb
@@ -99,8 +104,8 @@ files:
 - lib/serega/validations/attribute/check_opt_const.rb
 - lib/serega/validations/attribute/check_opt_delegate.rb
 - lib/serega/validations/attribute/check_opt_hide.rb
-- lib/serega/validations/attribute/check_opt_key.rb
 - lib/serega/validations/attribute/check_opt_many.rb
+- lib/serega/validations/attribute/check_opt_method.rb
 - lib/serega/validations/attribute/check_opt_serializer.rb
 - lib/serega/validations/attribute/check_opt_value.rb
 - lib/serega/validations/check_attribute_params.rb
@@ -108,6 +113,7 @@ files:
 - lib/serega/validations/check_serialize_params.rb
 - lib/serega/validations/initiate/check_modifiers.rb
 - lib/serega/validations/utils/check_allowed_keys.rb
+- lib/serega/validations/utils/check_extra_keyword_arg.rb
 - lib/serega/validations/utils/check_opt_is_bool.rb
 - lib/serega/validations/utils/check_opt_is_hash.rb
 - lib/serega/validations/utils/check_opt_is_string_or_symbol.rb
@@ -134,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.21
 signing_key:
 specification_version: 4
 summary: JSON Serializer