serega 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d35551791e1f846527be7fa3176db641f292dae4e5d8108464e52af67cd5025d
-  data.tar.gz: 729261f9aa1a2734e40390ea0a253bd7e931a7bd31665cbd7846394b51042fa4
+  metadata.gz: ad827e730d35f4e1805b7a0c59e8a8eeec87a91bb426ada370ea4a632516f40c
+  data.tar.gz: 681deb3a954453740ac3256614684601aeb18027423352ca05cc62c82ff37784
 SHA512:
-  metadata.gz: 878c59b774c71dabfe9ebf745a0349ebd25fb329e44cd9cba53e2f405844e6639d6f153813e0c475fc03f158b5c04a3fdfad4f41c952d1cd4afcddaed251fbcb
-  data.tar.gz: 4fac4c3293292a6644c2976cfbb65ba91c2b8aa0ed8dddd5e24b3ac9ed01b9c954973cce94095a63c377c373f3a26c0ac6ee397109b5f79414f1ef6b0e066632
+  metadata.gz: 6f279fecc4038a162b33d97001fa993758eb4d687c0a7b83f9555f20781e3ece12b1381ba9765993cf5a4d7a31a5dee66f29d3279e1198a6ddf6b6d19b977682
+  data.tar.gz: c1ed8f5f7e06ff2df08f2f5fb8ee587d062e3197399475c55d1383ab0fcb6c4c8f5224363ef202ecccdab063964a9e5cf98581ecdacfa5ac5caafa02277c93c6

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.4

data/lib/serega/attribute.rb

@@ -33,11 +33,11 @@ class Serega
       # @param block [Proc] Proc that receives object and context and finds attribute value
       #
       def initialize(name:, opts: {}, block: nil)
-        check(name, opts, block)
+        self.class.serializer_class::CheckAttributeParams.new(name, opts, block).validate
 
         @name = name.to_sym
         @opts = Utils::EnumDeepDup.call(opts)
-        @block = opts[:value] || block
+        @block = block
       end
 
       # @return [Symbol] Object method name to will be used to get attribute value unless block provided
@@ -77,7 +77,7 @@ class Serega
       def value_block
         return @value_block if instance_variable_defined?(:@value_block)
 
-        @value_block = block || keyword_block
+        @value_block = block || opts[:value] || const_block || keyword_block
       end
 
       #
@@ -112,16 +112,17 @@ class Serega
 
       private
 
+      def const_block
+        return unless opts.key?(:const)
+
+        const = opts[:const]
+        proc { const }
+      end
+
       def keyword_block
         key_method_name = key
         proc { |object| object.public_send(key_method_name) }
       end
-
-      def check(name, opts, block)
-        CheckName.call(name)
-        CheckOpts.call(opts, self.class.serializer_class.config[:attribute_keys])
-        CheckBlock.call(opts, block)
-      end
     end
 
     extend Serega::Helpers::SerializerClassHelper

data/lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb

@@ -37,7 +37,7 @@ class Serega
         # Override original #to_h method
         # @see Serega#to_h
         #
-        def to_h(object, **opts)
+        def to_h(object, *)
           object = add_preloads(object)
           super
         end

data/lib/serega/plugins/context_metadata/context_metadata.rb

@@ -14,8 +14,8 @@ class Serega
       end
 
       def self.load_plugin(serializer_class, **_opts)
-        serializer_class.include(InstanceMethods)
         serializer_class::Convert.include(ConvertInstanceMethods)
+        serializer_class::CheckSerializeParams.extend(CheckSerializeParamsClassMethods)
       end
 
       def self.after_load_plugin(serializer_class, **opts)
@@ -25,16 +25,12 @@ class Serega
         config[:serialize_keys] << meta_key
       end
 
-      module InstanceMethods
-        def to_h(object, **opts)
-          meta_key = self.class.config[:context_metadata][:key]
-          meta = opts[meta_key]
-
-          if meta && !meta.is_a?(Hash)
-            raise Serega::Error, "Option :#{meta_key} must be a Hash, but #{meta.class} was given"
-          end
-
+      module CheckSerializeParamsClassMethods
+        def check_opts(opts)
           super
+
+          meta_key = serializer_class.config[:context_metadata][:key]
+          Validations::Utils::CheckOptIsHash.call(opts, meta_key)
         end
       end
 

data/lib/serega/plugins/hide_nil/hide_nil.rb

@@ -22,7 +22,7 @@ class Serega
       #
       def self.load_plugin(serializer_class, **_opts)
         serializer_class::Attribute.include(AttributeMethods)
-        serializer_class::Attribute::CheckOpts.extend(CheckOptsClassMethods)
+        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
         serializer_class::ConvertItem.extend(ConvertItemClassMethods)
       end
 
@@ -37,10 +37,10 @@ class Serega
         end
       end
 
-      module CheckOptsClassMethods
+      module CheckAttributeParamsInstanceMethods
         private
 
-        def check_each_opt(opts)
+        def check_opts
           super
           CheckOptHideNil.call(opts)
         end

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

@@ -23,7 +23,7 @@ class Serega
         serializer_class.include(InstanceMethods)
         serializer_class::Attribute.include(AttributeMethods)
 
-        serializer_class::Attribute::CheckOpts.extend(CheckOptsClassMethods)
+        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
 
         require_relative "./lib/enum_deep_freeze"
         require_relative "./lib/format_user_preloads"
@@ -85,10 +85,10 @@ class Serega
         end
       end
 
-      module CheckOptsClassMethods
+      module CheckAttributeParamsInstanceMethods
         private
 
-        def check_each_opt(opts)
+        def check_opts
           super
           CheckOptPreloadPath.call(opts)
         end

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

@@ -1,79 +1,49 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckBlock
-      class << self
-        #
-        # Checks :value option or a block 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 }
-        #
-        # @example with one argument
-        #   attribute(:email) { |obj| obj.confirmed_email }
-        #
-        # @example with two arguments
-        #   attribute(:email) { |obj, context| context['is_current'] ? obj.email : nil }
-        #
-        # @param opts [Proc] Attribute opts, we will check :value option
-        # @param block [Proc] Block that returns serialized attribute value
-        #
-        # @raise [Error] Error that block has invalid arguments
-        #
-        # @return [void]
-        #
-        def call(opts, block)
-          check_both_provided(opts, block)
+  module Validations
+    module Attribute
+      class CheckBlock
+        class << self
+          #
+          # Checks :value option or a block 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 }
+          #
+          # @example with one argument
+          #   attribute(:email) { |obj| obj.confirmed_email }
+          #
+          # @example with two arguments
+          #   attribute(:email) { |obj, context| context['is_current'] ? obj.email : nil }
+          #
+          # @param opts [Proc] Attribute opts, we will check :value option
+          # @param block [Proc] Block that returns serialized attribute value
+          #
+          # @raise [Error] Error that block has invalid arguments
+          #
+          # @return [void]
+          #
+          def call(block)
+            return unless block
 
-          if block
             check_block(block)
-          elsif opts.key?(:value)
-            check_value(opts[:value])
           end
-        end
-
-        private
-
-        def check_both_provided(opts, block)
-          if opts.key?(:value) && block
-            raise Error, both_error
-          end
-        end
-
-        def check_block(block)
-          params = block.parameters
-          return if (params.count <= 2) && params.all? { |par| par[0] == :opt }
-
-          raise Error, block_error
-        end
 
-        def check_value(value)
-          raise Error, value_error unless value.is_a?(Proc)
+          private
 
-          params = value.parameters
+          def check_block(block)
+            params = block.parameters
+            return if (params.count <= 2) && params.all? { |par| par[0] == :opt }
 
-          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
+            raise Error, block_error
           end
 
-          raise Error, value_error
-        end
-
-        def block_error
-          "Block can have maximum two regular parameters (no **keyword or *array args)"
-        end
-
-        def value_error
-          "Option :value must be a Proc that is able to accept two parameters (no **keyword or *array args)"
-        end
-
-        def both_error
-          "Block and a :value option can not be provided together"
+          def block_error
+            "Block can have maximum two regular parameters (no **keyword or *array args)"
+          end
         end
       end
     end

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

@@ -1,43 +1,45 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckName
-      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
-
-      private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
-
-      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.
-        #
-        # @param name [String, Symbol] Attribute name
-        #
-        # @raise [Error] when name has invalid format
-        # @return [void]
-        #
-        def call(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 Error, message(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)
+  module Validations
+    module Attribute
+      class CheckName
+        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
+
+        private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+
+        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.
+          #
+          # @param name [String, Symbol] Attribute name
+          #
+          # @raise [Error] when name has invalid format
+          # @return [void]
+          #
+          def call(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 Error, message(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)
+          end
         end
       end
     end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Attribute
+      class CheckOptConst
+        #
+        # Checks attribute :const option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Attribute validation error
+        #
+        # @return [void]
+        #
+        class << self
+          def call(opts, block = nil)
+            return unless opts.key?(:const)
+
+            check_usage_with_other_params(opts, block)
+          end
+
+          private
+
+          def check_usage_with_other_params(opts, block)
+            raise Error, "Option :const can not be used together with option :key" if opts.key?(:key)
+            raise Error, "Option :const can not be used together with option :value" if opts.key?(:value)
+            raise Error, "Option :const can not be used together with block" if block
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckOptHide
-      #
-      # Checks attribute :hide option
-      #
-      # @param opts [Hash] Attribute options
-      #
-      # @raise [Error] Error that option has invalid value
-      #
-      # @return [void]
-      #
-      def self.call(opts)
-        CheckOptIsBool.call(opts, :hide)
+  module Validations
+    module Attribute
+      class CheckOptHide
+        #
+        # Checks attribute :hide option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Error that option has invalid value
+        #
+        # @return [void]
+        #
+        def self.call(opts)
+          Utils::CheckOptIsBool.call(opts, :hide)
+        end
       end
     end
   end

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

@@ -1,24 +1,34 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckOptKey
-      #
-      # Checks attribute :key option
-      #
-      # @param opts [Hash] Attribute options
-      #
-      # @raise [Error] Error that option has invalid value
-      #
-      # @return [void]
-      #
-      def self.call(opts)
-        return unless opts.key?(:key)
+  module Validations
+    module Attribute
+      class CheckOptKey
+        #
+        # Checks attribute :key option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Error that option has invalid value
+        #
+        # @return [void]
+        #
+        class << self
+          def call(opts, block = nil)
+            return unless opts.key?(:key)
 
-        value = opts[:key]
-        return if value.is_a?(String) || value.is_a?(Symbol)
+            check_usage_with_other_params(opts, block)
+            Utils::CheckOptIsStringOrSymbol.call(opts, :key)
+          end
 
-        raise Error, "Invalid option :key => #{value.inspect}. Must be a String or a Symbol"
+          private
+
+          def check_usage_with_other_params(opts, block)
+            raise Error, "Option :key can not be used together with option :const" if opts.key?(:const)
+            raise Error, "Option :key can not be used together with option :value" if opts.key?(:value)
+            raise Error, "Option :key can not be used together with block" if block
+          end
+        end
       end
     end
   end

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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckOptMany
-      #
-      # Checks attribute :many option
-      #
-      # @param opts [Hash] Attribute options
-      #
-      # @raise [Error] Error that option has invalid value
-      #
-      # @return [void]
-      #
-      def self.call(opts)
-        CheckOptIsBool.call(opts, :many)
+  module Validations
+    module Attribute
+      class CheckOptMany
+        #
+        # Checks attribute :many option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Error that option has invalid value
+        #
+        # @return [void]
+        #
+        def self.call(opts)
+          Utils::CheckOptIsBool.call(opts, :many)
+        end
       end
     end
   end

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

@@ -1,34 +1,36 @@
 # frozen_string_literal: true
 
 class Serega
-  class Attribute
-    class CheckOptSerializer
-      class << self
-        #
-        # Checks attribute :serializer option
-        #
-        # @param opts [Hash] Attribute options
-        #
-        # @raise [Error] Error that option has invalid value
-        #
-        # @return [void]
-        #
-        def call(opts)
-          return unless opts.key?(:serializer)
+  module Validations
+    module Attribute
+      class CheckOptSerializer
+        class << self
+          #
+          # Checks attribute :serializer option
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [Error] Error that option has invalid value
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:serializer)
 
-          value = opts[:serializer]
-          return if valid_serializer?(value)
+            value = opts[:serializer]
+            return if valid_serializer?(value)
 
-          raise Error, "Invalid option :serializer => #{value.inspect}." \
-            " Can be a Serega subclass, a String or a Proc without arguments"
-        end
+            raise Error, "Invalid option :serializer => #{value.inspect}." \
+              " Can be a Serega subclass, a String or a Proc without arguments"
+          end
 
-        private
+          private
 
-        def valid_serializer?(value)
-          value.is_a?(String) ||
-            (value.is_a?(Proc) && (value.parameters.count == 0)) ||
-            (value.is_a?(Class) && (value < Serega))
+          def valid_serializer?(value)
+            value.is_a?(String) ||
+              (value.is_a?(Proc) && (value.parameters.count == 0)) ||
+              (value.is_a?(Class) && (value < Serega))
+          end
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Attribute
+      class CheckOptValue
+        #
+        # Checks attribute :value option
+        #
+        # @param opts [Hash] Attribute options
+        #
+        # @raise [Error] Error that option has invalid value
+        #
+        # @return [void]
+        #
+        class << self
+          def call(opts, block = nil)
+            return unless opts.key?(:value)
+
+            check_usage_with_other_params(opts, block)
+            check_proc(opts[:value])
+          end
+
+          private
+
+          def check_usage_with_other_params(opts, block)
+            raise Error, "Option :value can not be used together with option :key" if opts.key?(:key)
+            raise Error, "Option :value can not be used together with option :const" if opts.key?(:const)
+            raise Error, "Option :value can not be used together with block" if block
+          end
+
+          def check_proc(value)
+            raise Error, value_error unless value.is_a?(Proc)
+
+            params = value.parameters
+
+            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
+
+            raise Error, value_error
+          end
+
+          def value_error
+            "Option :value must be a Proc that is able to accept two parameters (no **keyword or *array args)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serega/validations/check_attribute_params.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    class CheckAttributeParams
+      module InstanceMethods
+        attr_reader :name, :opts, :block
+
+        def initialize(name, opts, block)
+          @name = name
+          @opts = opts
+          @block = block
+        end
+
+        def validate
+          check_name
+          check_opts
+          check_block
+        end
+
+        private
+
+        def check_name
+          Attribute::CheckName.call(name)
+        end
+
+        def check_opts
+          Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+
+          Attribute::CheckOptConst.call(opts, block)
+          Attribute::CheckOptHide.call(opts)
+          Attribute::CheckOptKey.call(opts, block)
+          Attribute::CheckOptMany.call(opts)
+          Attribute::CheckOptSerializer.call(opts)
+          Attribute::CheckOptValue.call(opts, block)
+        end
+
+        def check_block
+          Attribute::CheckBlock.call(block)
+        end
+
+        def allowed_opts_keys
+          self.class.serializer_class.config[:attribute_keys]
+        end
+      end
+
+      include InstanceMethods
+      extend Serega::Helpers::SerializerClassHelper
+    end
+  end
+end

data/lib/serega/validations/check_initiate_params.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    class CheckInitiateParams
+      module ClassMethods
+        def call(opts)
+          check_opts(opts)
+        end
+
+        private
+
+        def check_opts(opts)
+          Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+        end
+
+        def allowed_opts_keys
+          serializer_class.config[:initiate_keys]
+        end
+      end
+
+      extend ClassMethods
+      extend Serega::Helpers::SerializerClassHelper
+    end
+  end
+end

data/lib/serega/validations/check_serialize_params.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    class CheckSerializeParams
+      module ClassMethods
+        def call(opts)
+          check_opts(opts)
+        end
+
+        private
+
+        def check_opts(opts)
+          Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+
+          Utils::CheckOptIsHash.call(opts, :context)
+          Utils::CheckOptIsBool.call(opts, :many)
+        end
+
+        def allowed_opts_keys
+          serializer_class.config[:serialize_keys]
+        end
+      end
+
+      extend ClassMethods
+      extend Serega::Helpers::SerializerClassHelper
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Utils
+      class CheckAllowedKeys
+        def self.call(opts, allowed_keys)
+          opts.each_key do |key|
+            next if allowed_keys.include?(key)
+
+            raise Error, "Invalid option #{key.inspect}. Allowed options are: #{allowed_keys.map(&:inspect).join(", ")}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Utils
+      class CheckOptIsBool
+        def self.call(opts, key)
+          return unless opts.key?(key)
+
+          value = opts[key]
+          return if value.equal?(true) || value.equal?(false)
+
+          raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a boolean value"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Utils
+      class CheckOptIsHash
+        def self.call(opts, key)
+          return unless opts.key?(key)
+
+          value = opts[key]
+          return if value.is_a?(Hash)
+
+          raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a Hash value"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Serega
+  module Validations
+    module Utils
+      class CheckOptIsStringOrSymbol
+        def self.call(opts, key)
+          return unless opts.key?(key)
+
+          value = opts[key]
+          return if value.is_a?(String) || value.is_a?(Symbol)
+
+          raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must be a String or a Symbol"
+        end
+      end
+    end
+  end
+end

data/lib/serega.rb

@@ -21,16 +21,21 @@ require_relative "serega/utils/to_json"
 require_relative "serega/utils/as_json"
 
 require_relative "serega/attribute"
-require_relative "serega/validations/check_allowed_keys"
-require_relative "serega/validations/check_opt_is_bool"
-require_relative "serega/validations/check_opt_is_hash"
+require_relative "serega/validations/utils/check_allowed_keys"
+require_relative "serega/validations/utils/check_opt_is_bool"
+require_relative "serega/validations/utils/check_opt_is_hash"
+require_relative "serega/validations/utils/check_opt_is_string_or_symbol"
 require_relative "serega/validations/attribute/check_block"
 require_relative "serega/validations/attribute/check_name"
+require_relative "serega/validations/attribute/check_opt_const"
 require_relative "serega/validations/attribute/check_opt_hide"
 require_relative "serega/validations/attribute/check_opt_key"
 require_relative "serega/validations/attribute/check_opt_many"
 require_relative "serega/validations/attribute/check_opt_serializer"
-require_relative "serega/validations/attribute/check_opts"
+require_relative "serega/validations/attribute/check_opt_value"
+require_relative "serega/validations/check_attribute_params"
+require_relative "serega/validations/check_initiate_params"
+require_relative "serega/validations/check_serialize_params"
 
 require_relative "serega/config"
 require_relative "serega/convert"
@@ -43,13 +48,25 @@ class Serega
     {
       plugins: [],
       initiate_keys: %i[only with except],
-      attribute_keys: %i[key value serializer many hide],
+      attribute_keys: %i[key value serializer many hide const],
       serialize_keys: %i[context many],
       max_cached_map_per_serializer_count: 50,
       to_json: ->(data) { Utils::ToJSON.call(data) }
     }
   )
 
+  check_attribute_params_class = Class.new(Validations::CheckAttributeParams)
+  check_attribute_params_class.serializer_class = self
+  const_set(:CheckAttributeParams, check_attribute_params_class)
+
+  check_initiate_params_class = Class.new(Validations::CheckInitiateParams)
+  check_initiate_params_class.serializer_class = self
+  const_set(:CheckInitiateParams, check_initiate_params_class)
+
+  check_serialize_params_class = Class.new(Validations::CheckSerializeParams)
+  check_serialize_params_class.serializer_class = self
+  const_set(:CheckSerializeParams, check_serialize_params_class)
+
   # Core serializer class methods
   module ClassMethods
     # @return [Config] current serializer config
@@ -77,6 +94,18 @@ class Serega
       convert_item_class.serializer_class = subclass
       subclass.const_set(:ConvertItem, convert_item_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)
@@ -167,11 +196,15 @@ class Serega
       attribute(name, serializer: serializer, **opts, &block)
     end
 
-    def to_h(object, opts = FROZEN_EMPTY_HASH)
+    def call(object, opts = FROZEN_EMPTY_HASH)
       initiate_keys = config[:initiate_keys]
       new(opts.slice(*initiate_keys)).to_h(object, opts.except(*initiate_keys))
     end
 
+    def to_h(object, opts = FROZEN_EMPTY_HASH)
+      call(object, opts)
+    end
+
     def to_json(object, opts = FROZEN_EMPTY_HASH)
       initiate_keys = config[:initiate_keys]
       new(opts.slice(*initiate_keys)).to_json(object, opts.except(*initiate_keys))
@@ -197,7 +230,7 @@ class Serega
     # @param with [Array, Hash, String, Symbol] Attributes (usually hidden) to serialize additionally
     #
     def initialize(opts = FROZEN_EMPTY_HASH)
-      CheckAllowedKeys.call(opts, self.class.config[:initiate_keys])
+      self.class::CheckInitiateParams.call(opts)
       opts = prepare_modifiers(opts) if opts && (opts != FROZEN_EMPTY_HASH)
       @opts = opts
     end
@@ -210,15 +243,18 @@ class Serega
     #
     # @return [Hash] Serialization result
     #
-    def to_h(object, opts = {})
-      CheckAllowedKeys.call(opts, self.class.config[:serialize_keys])
-      CheckOptIsHash.call(opts, :context)
-      CheckOptIsBool.call(opts, :many)
+    def call(object, opts = {})
+      self.class::CheckSerializeParams.call(opts)
       opts[:context] ||= {}
 
       self.class::Convert.call(object, **opts, map: map)
     end
 
+    # @see #call
+    def to_h(object, opts = {})
+      call(object, opts)
+    end
+
     #
     # Serializes provided object to json
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-13 00:00:00.000000000 Z
+date: 2022-07-25 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -56,14 +56,19 @@ files:
 - lib/serega/utils/to_json.rb
 - lib/serega/validations/attribute/check_block.rb
 - lib/serega/validations/attribute/check_name.rb
+- lib/serega/validations/attribute/check_opt_const.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_serializer.rb
-- lib/serega/validations/attribute/check_opts.rb
-- lib/serega/validations/check_allowed_keys.rb
-- lib/serega/validations/check_opt_is_bool.rb
-- lib/serega/validations/check_opt_is_hash.rb
+- lib/serega/validations/attribute/check_opt_value.rb
+- lib/serega/validations/check_attribute_params.rb
+- lib/serega/validations/check_initiate_params.rb
+- lib/serega/validations/check_serialize_params.rb
+- lib/serega/validations/utils/check_allowed_keys.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
 - lib/serega/version.rb
 homepage: https://github.com/aglushkov/serega
 licenses:

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  class Attribute
-    class CheckOpts
-      module ClassMethods
-        #
-        # Validates 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
-        #
-        # @raise [Error] when attribute has invalid options
-        #
-        # @return [void]
-        #
-        def call(opts, attribute_keys)
-          CheckAllowedKeys.call(opts, attribute_keys)
-          check_each_opt(opts)
-        end
-
-        private
-
-        def check_each_opt(opts)
-          CheckOptHide.call(opts)
-          CheckOptKey.call(opts)
-          CheckOptMany.call(opts)
-          CheckOptSerializer.call(opts)
-        end
-      end
-
-      extend ClassMethods
-    end
-  end
-end

data/lib/serega/validations/check_allowed_keys.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  class CheckAllowedKeys
-    def self.call(opts, allowed_keys)
-      opts.each_key do |key|
-        next if allowed_keys.include?(key)
-
-        raise Error, "Invalid option #{key.inspect}. Allowed options are: #{allowed_keys.map(&:inspect).join(", ")}"
-      end
-    end
-  end
-end

data/lib/serega/validations/check_opt_is_bool.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  class CheckOptIsBool
-    def self.call(opts, key)
-      return unless opts.key?(key)
-
-      value = opts[key]
-      return if value.equal?(true) || value.equal?(false)
-
-      raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a boolean value"
-    end
-  end
-end

data/lib/serega/validations/check_opt_is_hash.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  class CheckOptIsHash
-    def self.call(opts, key)
-      return unless opts.key?(key)
-
-      value = opts[key]
-      return if value.is_a?(Hash)
-
-      raise Error, "Invalid option #{key.inspect} => #{value.inspect}. Must have a Hash value"
-    end
-  end
-end