serega 0.42.0 → 0.50.0

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

@@ -1,31 +1,20 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `name` parameter validator
       #
-      # @private
-      class CheckName
+      class CheckName # :nodoc:
         # Regexp for valid attribute name
         FORMAT = /\A[\w~-]+\z/
 
         class << self
-          #
           # Checks allowed characters.
           # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
-          #
-          # @param name [String, Symbol] Attribute name
-          #
-          # @raise [SeregaError] when name has invalid format
-          # @return [void]
-          #
           def call(name)
-            name = SeregaUtils::SymbolName.call(name)
-            raise SeregaError, message(name) unless FORMAT.match?(name)
+            raise SeregaError, message(name.to_s) unless FORMAT.match?(name)
           end
 
           private

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

@@ -1,28 +1,16 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:base_serializer` option validator
       #
-      # @private
-      class CheckOptBaseSerializer
+      class CheckOptBaseSerializer # :nodoc:
         class << self
-          #
           # Checks attribute :base_serializer option. It specifies the parent
           # class for the nested serializer defined with the attribute block,
           # so it makes sense only when a block is provided.
-          #
-          # @param opts [Hash] Attribute options
-          # @param block [nil, Proc] Attribute block (defines a nested serializer)
-          #
-          # @raise [SeregaError] SeregaError that option has invalid value
-          #
-          # @return [void]
-          #
           def call(opts, block = nil)
             return unless opts.key?(:base_serializer)
 

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

@@ -1,84 +1,58 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:batch` option validator
       #
-      # @private
-      class CheckOptBatch
+      class CheckOptBatch # :nodoc:
         class << self
-          #
           # Checks attribute :batch option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] Attribute validation error
-          #
-          # @return [void]
-          #
-          def call(serializer_class, opts)
+          def call(serializer_class, name, opts)
             return unless opts.key?(:batch)
 
-            check_opt_batch(opts, serializer_class)
-            check_usage_with_other_params(opts)
+            check_type(opts)
+            batch = AttributeNormalizers::Batch.new(opts[:batch], name)
+            check_loaders_exist(serializer_class, batch)
+            check_usage_with_other_params(opts, batch)
           end
 
           private
 
-          def check_opt_batch(opts, serializer_class)
-            batch_opts = opts[:batch]
-            return if batch_opts == true
-            return if batch_opts.respond_to?(:call)
-
-            if batch_opts.is_a?(Symbol) || batch_opts.is_a?(String)
-              check_loader_exists?(serializer_class, batch_opts)
-            else
-              Utils::CheckOptIsHash.call(opts, :batch)
-              check_opt_batch_use(serializer_class, batch_opts)
-              check_opt_batch_id(batch_opts)
-              check_opt_batch_extra_opts(batch_opts)
-            end
-          end
-
-          def check_opt_batch_use(serializer_class, batch_opts)
-            return unless batch_opts.key?(:use)
-
-            batch_loader_name = batch_opts[:use]
-            return if batch_loader_name.respond_to?(:call)
+          # `true`, a loader name, a callable or a Hash with :use and :id
+          def check_type(opts)
+            batch = opts[:batch]
+            return if batch == true || batch.is_a?(Symbol) || batch.is_a?(String) || batch.respond_to?(:call)
 
-            check_loader_exists?(serializer_class, batch_loader_name)
+            Utils::CheckOptIsHash.call(opts, :batch)
+            Utils::CheckAllowedKeys.call(batch, %i[use id], :batch)
+            check_id(batch)
           end
 
-          def check_opt_batch_id(batch_opts)
-            return unless batch_opts.key?(:id)
+          def check_id(batch)
+            return unless batch.key?(:id)
 
-            id_method_name = batch_opts[:id]
+            id_method_name = batch[:id]
             return if id_method_name.is_a?(Symbol) || id_method_name.is_a?(String)
 
             raise SeregaError, "Invalid batch option `:id` value, it can be a Symbol or a String"
           end
 
-          def check_loader_exists?(serializer_class, value)
-            values = Array(value)
-            values.each do |batch_loader_name|
+          # Checks the names as given, thus the error shows a String name as a String
+          def check_loaders_exist(serializer_class, batch)
+            return if batch.inline?
+
+            Array(batch.use).each do |batch_loader_name|
               next if serializer_class.batch_loaders.key?(batch_loader_name.to_sym)
 
               raise SeregaError, "Batch loader with name `#{batch_loader_name.inspect}` is not defined"
             end
           end
 
-          def check_opt_batch_extra_opts(batch_opts)
-            Utils::CheckAllowedKeys.call(batch_opts, %i[use id], :batch)
-          end
-
-          def check_usage_with_other_params(opts)
-            batch = opts[:batch]
-            use_id = batch.is_a?(Hash) && batch.key?(:id)
-            use_multiple = batch.is_a?(Hash) && (Array(batch[:use]).size > 1)
+          def check_usage_with_other_params(opts, batch)
+            use_id = !batch.id.nil?
+            use_multiple = Array(batch.use).size > 1
             value_added = opts.key?(:value)
 
             if use_multiple && use_id
@@ -92,10 +66,6 @@ class Serega
             if use_id && value_added
               raise SeregaError, "Option `batch.id` should not be used when :value option provided directly"
             end
-
-            raise SeregaError, "Option :batch can not be used together with option :method" if opts.key?(:method)
-            raise SeregaError, "Option :batch can not be used together with option :const" if opts.key?(:const)
-            raise SeregaError, "Option :batch can not be used together with option :delegate" if opts.key?(:delegate)
           end
         end
       end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
+      #
+      # Validator for attribute :if, :unless, :if_value and :unless_value options
+      #
+      class CheckOptCondition # :nodoc:
+        # Options whose condition receives the serialized value, not the object
+        VALUE_OPTIONS = %i[if_value unless_value].freeze
+
+        # Signatures from MethodSignature: up to two positional parameters and
+        # the :ctx keyword
+        VALID_SIGNATURES = %w[0 1 2 1_ctx 2_ctx].freeze
+
+        class << self
+          # Checks the condition option `name`: a Symbol, a Proc or an object
+          # that responds to :call
+          def call(opts, name)
+            return unless opts.key?(name)
+
+            parameter = VALUE_OPTIONS.include?(name) ? "value" : "object"
+            check_type(opts[name], name, parameter)
+          end
+
+          private
+
+          def check_type(condition, name, parameter)
+            return if condition.is_a?(Symbol)
+            raise SeregaError, must_be_callable(name) unless condition.respond_to?(:call)
+
+            signature = SeregaUtils::MethodSignature.call(condition, pos_limit: 2, keyword_args: [:ctx])
+            raise SeregaError, signature_error(name, parameter) unless VALID_SIGNATURES.include?(signature)
+          end
+
+          def must_be_callable(name)
+            "Invalid attribute option #{name.inspect}. It must be a Symbol, a Proc or respond to :call"
+          end
+
+          def signature_error(name, parameter)
+            <<~ERROR.strip
+              Invalid attribute option #{name.inspect} parameters, valid parameters signatures:
+              - ()
+              - (#{parameter})
+              - (#{parameter}, context)
+              - (#{parameter}, :ctx)
+              - (#{parameter}, context, :ctx)
+            ERROR
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,47 +1,30 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:delegate` option validator
       #
-      # @private
-      class CheckOptDelegate
+      class CheckOptDelegate # :nodoc:
         class << self
-          #
           # Checks attribute :delegate option
           # It must have :to option and can have :optional allow_nil option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] Attribute validation error
-          #
-          # @return [void]
-          #
           def call(opts)
             return unless opts.key?(:delegate)
 
-            check_opt_delegate(opts)
-            check_usage_with_other_params(opts)
-          end
-
-          private
-
-          def check_opt_delegate(opts)
             Utils::CheckOptIsHash.call(opts, :delegate)
 
             delegate_opts = opts[:delegate]
             check_opt_delegate_to(delegate_opts)
             check_opt_delegate_method(delegate_opts)
             check_opt_delegate_allow_nil(delegate_opts)
-            check_opt_delegate_to_hash_access(delegate_opts)
             check_opt_delegate_hash_access(delegate_opts)
             check_opt_delegate_extra_opts(delegate_opts)
           end
 
+          private
+
           def check_opt_delegate_to(delegate_opts)
             to_exist = delegate_opts.key?(:to)
             raise SeregaError, "Option :delegate must have a :to option" unless to_exist
@@ -59,53 +42,17 @@ class Serega
             Utils::CheckOptIsBool.call(delegate_opts, :allow_nil)
           end
 
-          # Hash access of the intermediate (:to) step. Accepts the same
-          # forms as the final (:method) step.
-          def check_opt_delegate_to_hash_access(delegate_opts)
-            check_hash_access_value(delegate_opts, :to_hash_access)
-          end
-
-          # Hash access of the final (:method) step. Accepts the same forms
-          # as the attribute :hash_access option.
+          # Hash access of the intermediate (:to) step and of the final
+          # (:method) step. Both accept the forms of the attribute :hash_access
+          # option.
           def check_opt_delegate_hash_access(delegate_opts)
-            check_hash_access_value(delegate_opts, :hash_access)
-          end
-
-          def check_hash_access_value(delegate_opts, opt_name)
-            return unless delegate_opts.key?(opt_name)
-
-            value = delegate_opts[opt_name]
-            case value
-            when true, false then nil
-            when Symbol then check_hash_access_mode(value)
-            when Hash
-              Utils::CheckAllowedKeys.call(value, %i[mode allow_missing_key], opt_name)
-              check_hash_access_mode(value[:mode]) if value.key?(:mode)
-              Utils::CheckOptIsBool.call(value, :allow_missing_key)
-            else
-              raise SeregaError,
-                "Invalid delegate option :#{opt_name} => #{value.inspect}." \
-                " It must be a Boolean, a Symbol mode (:symbol, :string)" \
-                " or a Hash with :mode and :allow_missing_key keys"
-            end
-          end
-
-          def check_hash_access_mode(mode)
-            return true if AttributeValueResolvers::HashAccessResolver::MODES.include?(mode)
-
-            raise SeregaError, "Invalid :hash_access mode #{mode.inspect}. Allowed modes: :symbol, :string"
+            Utils::CheckHashAccessValue.call(delegate_opts, :to_hash_access)
+            Utils::CheckHashAccessValue.call(delegate_opts, :hash_access)
           end
 
           def check_opt_delegate_extra_opts(delegate_opts)
             Utils::CheckAllowedKeys.call(delegate_opts, %i[to method allow_nil to_hash_access hash_access], :delegate)
           end
-
-          def check_usage_with_other_params(opts)
-            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 option :batch" if opts.key?(:batch)
-          end
         end
       end
     end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
+      #
+      # Validator for attribute :format option
+      #
+      class CheckOptFormat # :nodoc:
+        class << self
+          # Checks attribute :format option is the name of an added formatter
+          # or a valid formatter
+          def call(opts, serializer_class)
+            return unless opts.key?(:format)
+
+            formatter = opts[:format]
+
+            if formatter.is_a?(Symbol)
+              check_formatter_defined(serializer_class, formatter)
+            else
+              CheckFormatter.call(nil, formatter)
+            end
+          end
+
+          private
+
+          def check_formatter_defined(serializer_class, formatter)
+            return if serializer_class.formatters.key?(formatter)
+
+            raise SeregaError, "Formatter `#{formatter.inspect}` was not defined"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,30 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:hash_access` option validator
       #
-      # @private
-      class CheckOptHashAccess
+      class CheckOptHashAccess # :nodoc:
         class << self
-          #
           # Checks attribute :hash_access option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] Attribute validation error
-          #
-          # @return [void]
-          #
           def call(opts)
-            return unless opts.key?(:hash_access)
-
-            value = opts[:hash_access]
-            check_value(value)
-            check_usage_with_other_params(opts) if value
+            Utils::CheckHashAccessValue.call(opts, :hash_access)
+            check_usage_with_delegate(opts) if opts[:hash_access]
           end
 
           private
 
-          def check_value(value)
-            case value
-            when true, false then nil
-            when Symbol then check_mode(value)
-            when Hash
-              Utils::CheckAllowedKeys.call(value, %i[mode allow_missing_key], :hash_access)
-              check_mode(value[:mode]) if value.key?(:mode)
-              check_allow_missing_key(value[:allow_missing_key]) if value.key?(:allow_missing_key)
-            else
-              raise SeregaError,
-                "Invalid option :hash_access => #{value.inspect}." \
-                " It must be a Boolean, a Symbol mode (:symbol, :string)" \
-                " or a Hash with :mode and :allow_missing_key keys"
-            end
-          end
-
-          def check_mode(mode)
-            return if AttributeValueResolvers::HashAccessResolver::MODES.include?(mode)
-
-            raise SeregaError, "Invalid :hash_access mode #{mode.inspect}. Allowed modes: :symbol, :string"
-          end
-
-          def check_allow_missing_key(allow_missing_key)
-            return if allow_missing_key == true || allow_missing_key == false
-
-            raise SeregaError, "Invalid :hash_access option :allow_missing_key => #{allow_missing_key.inspect}. Must be a Boolean"
-          end
-
-          # The :const, :value and :batch options do not read the serialized
-          # object by attribute name, so hash access can not affect them.
           # Delegated attributes configure hash access per step with the
           # `delegate: {to_hash_access:, hash_access:}` sub-options.
-          def check_usage_with_other_params(opts)
-            raise SeregaError, "Option :hash_access can not be used together with option :const" if opts.key?(:const)
-            raise SeregaError, "Option :hash_access can not be used together with option :value" if opts.key?(:value)
-            raise SeregaError, "Option :hash_access can not be used together with option :batch" if opts.key?(:batch)
+          def check_usage_with_delegate(opts)
+            return unless opts.key?(:delegate)
 
-            if opts.key?(:delegate)
-              raise SeregaError,
-                "Option :hash_access can not be used together with option :delegate." \
-                " Use the delegate :to_hash_access (intermediate step) and" \
-                " :hash_access (final step) sub-options instead"
-            end
+            raise SeregaError,
+              "Option :hash_access can not be used together with option :delegate." \
+              " Use the delegate :to_hash_access (intermediate step) and" \
+              " :hash_access (final step) sub-options instead"
           end
         end
       end

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

@@ -1,24 +1,13 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:hide` option validator
       #
-      # @private
-      class CheckOptHide
-        #
+      class CheckOptHide # :nodoc:
         # Checks attribute :hide option
-        #
-        # @param opts [Hash] Attribute options
-        #
-        # @raise [SeregaError] SeregaError that option has invalid value
-        #
-        # @return [void]
-        #
         def self.call(opts)
           Utils::CheckOptIsBool.call(opts, :hide)
         end

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

@@ -1,35 +1,33 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:many` option validator
       #
-      # @private
-      class CheckOptMany
+      class CheckOptMany # :nodoc:
         class << self
-          #
           # Checks attribute :many option
-          #
-          # @param opts [Hash] Attribute options
-          # @param block [nil, Proc] Attribute block
-          #
-          # @raise [SeregaError] SeregaError that option has invalid value
-          #
-          # @return [void]
-          #
-          def call(opts, block = nil)
-            return unless opts.key?(:many)
-
-            check_many_option_makes_sence(opts, block)
-            Utils::CheckOptIsBool.call(opts, :many)
+          def call(opts, block = nil, required = false)
+            if opts.key?(:many)
+              check_many_option_makes_sence(opts, block)
+              Utils::CheckOptIsBool.call(opts, :many)
+            elsif required
+              check_many_option_not_required(opts, block)
+            end
           end
 
           private
 
+          def check_many_option_not_required(opts, block)
+            return if !opts[:serializer] && !block
+
+            raise SeregaError,
+              "Attribute option :many [Boolean] must be provided" \
+              " for attributes with :serializer option or a block"
+          end
+
           def check_many_option_makes_sence(opts, block)
             return if many_option_makes_sence?(opts, block)
 

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

@@ -1,39 +1,17 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Attribute `:method` option validator
       #
-      # @private
-      class CheckOptMethod
+      class CheckOptMethod # :nodoc:
         class << self
-          #
           # Checks attribute :method option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] SeregaError that option has invalid value
-          #
-          # @return [void]
-          #
           def call(opts)
-            return unless opts.key?(:method)
-
-            check_usage_with_other_params(opts)
             Utils::CheckOptIsStringOrSymbol.call(opts, :method)
           end
-
-          private
-
-          def check_usage_with_other_params(opts)
-            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 option :batch" if opts.key?(:batch)
-          end
         end
       end
     end

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

@@ -1,40 +1,17 @@
 # frozen_string_literal: true
 
 class Serega
-  # @private
-  module SeregaValidations
-    # @private
-    module Attribute
+  module SeregaValidations # :nodoc:
+    module Attribute # :nodoc:
       #
       # Validator for attribute :preload option
       #
-      # @private
-      class CheckOptPreload
+      class CheckOptPreload # :nodoc:
         class << self
-          #
           # Checks :preload option
-          #
-          # @param opts [Hash] Attribute options
-          #
-          # @raise [SeregaError] validation error
-          #
-          # @return [void]
           def call(opts)
-            return unless opts.key?(:preload)
-
-            check_opt_preload(opts)
-            check_usage_with_other_params(opts)
-          end
-
-          private
-
-          def check_opt_preload(opts)
             raise SeregaError, "Option :preload value can not be `true`" if opts[:preload] == true
           end
-
-          def check_usage_with_other_params(opts)
-            raise SeregaError, "Option :preload can not be used together with option :const" if opts.key?(:const)
-          end
         end
       end
     end