serega 0.16.0 → 0.18.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Batch
+      #
+      # Validator for option :id_method in attribute :batch option
+      #
+      class CheckBatchOptIdMethod
+        class << self
+          #
+          # Checks option :id_method of attribute :batch option
+          #
+          # @param id [nil, #call] Attribute :batch option :id_method
+          #
+          # @raise [SeregaError] validation error
+          #
+          # @return [void]
+          #
+          def call(id)
+            return if id.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless id.respond_to?(:call)
+
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(id, "batch option :id_method")
+            params_count = SeregaUtils::ParamsCount.call(id, max_count: 2)
+            raise SeregaError, params_count_error if params_count > 2
+          end
+
+          private
+
+          def params_count_error
+            "Invalid :batch option :id_method. It can accept maximum 2 parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid :batch option :id_method. It must be a Symbol, a Proc or respond to #call"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,13 +17,9 @@ class Serega
           #
           # @return [void]
           #
-          def call(loader)
-            return if loader.is_a?(Symbol)
-
-            raise SeregaError, must_be_callable unless loader.respond_to?(:call)
-
-            if loader.is_a?(Proc)
-              check_block(loader)
+          def call(loader, serializer_class)
+            if loader.is_a?(Symbol)
+              check_symbol(loader, serializer_class)
             else
               check_callable(loader)
             end
@@ -31,36 +27,26 @@ class Serega
 
           private
 
-          def check_block(block)
-            return if valid_parameters?(block, accepted_count: 0..3)
-
-            raise SeregaError, block_parameters_error
-          end
-
-          def check_callable(callable)
-            return if valid_parameters?(callable.method(:call), accepted_count: 3..3)
+          def check_symbol(loader_name, serializer_class)
+            defined_loaders = serializer_class.config.batch.loaders
+            return if defined_loaders[loader_name]
 
-            raise SeregaError, callable_parameters_error
+            raise SeregaError, <<~ERR.strip
+              Please define loader before adding it to attribute.
+                Example: `config.batch.define(:#{loader_name}) { |ids| ... }`
+            ERR
           end
 
-          def valid_parameters?(data, accepted_count:)
-            params = data.parameters
-            accepted_count.include?(params.count) && valid_parameters_types?(params)
-          end
-
-          def valid_parameters_types?(params)
-            params.all? do |param|
-              type = param[0]
-              (type == :req) || (type == :opt)
-            end
-          end
+          def check_callable(loader)
+            raise SeregaError, must_be_callable unless loader.respond_to?(:call)
 
-          def block_parameters_error
-            "Invalid :batch option :loader. When it is a Proc it can have maximum three regular parameters (keys, context, point)"
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(loader, ":batch option :loader")
+            params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
+            raise SeregaError, params_count_error if params_count > 3
           end
 
-          def callable_parameters_error
-            "Invalid :batch option :loader. When it is a callable object it must have three regular parameters (keys, context, point)"
+          def params_count_error
+            "Invalid :batch option :loader. It can accept maximum 3 parameters (ids, context, plan)"
           end
 
           def must_be_callable

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

@@ -23,30 +23,29 @@ class Serega
             SeregaValidations::Utils::CheckOptIsHash.call(opts, :batch)
 
             batch = opts[:batch]
-            SeregaValidations::Utils::CheckAllowedKeys.call(batch, %i[key loader default], :batch)
-
-            check_batch_opt_key(batch, serializer_class)
-            check_batch_opt_loader(batch)
+            SeregaValidations::Utils::CheckAllowedKeys.call(batch, %i[id_method loader default], :batch)
 
+            check_batch_opt_id_method(batch, serializer_class)
+            check_batch_opt_loader(batch, serializer_class)
             check_usage_with_other_params(opts, block)
           end
 
           private
 
-          def check_batch_opt_key(batch, serializer_class)
-            return if !batch.key?(:key) && serializer_class.config.batch.default_key
+          def check_batch_opt_id_method(batch, serializer_class)
+            return if !batch.key?(:id_method) && serializer_class.config.batch.id_method
 
-            key = batch[:key]
-            raise SeregaError, "Option :key must present inside :batch option" unless key
+            id_method = batch[:id_method]
+            raise SeregaError, "Option :id_method must present inside :batch option" unless id_method
 
-            CheckBatchOptKey.call(key)
+            CheckBatchOptIdMethod.call(id_method)
           end
 
-          def check_batch_opt_loader(batch)
+          def check_batch_opt_loader(batch, serializer_class)
             loader = batch[:loader]
             raise SeregaError, "Option :loader must present inside :batch option" unless loader
 
-            CheckBatchOptLoader.call(loader)
+            CheckBatchOptLoader.call(loader, serializer_class)
           end
 
           def check_usage_with_other_params(opts, block)

data/lib/serega/plugins/formatters/formatters.rb

@@ -11,12 +11,15 @@ class Serega
     #
     # Attribute option `:format` now can be used with name of formatter or with callable instance.
     #
+    # Formatters can accept up to 2 parameters (formatted object, context)
+    #
     # @example
     #   class AppSerializer < Serega
     #     plugin :formatters, formatters: {
     #       iso8601: ->(value) { time.iso8601.round(6) },
     #       on_off: ->(value) { value ? 'ON' : 'OFF' },
     #       money: ->(value) { value.round(2) }
+    #       date: DateTypeFormatter # callable
     #     }
     #   end
     #
@@ -35,6 +38,7 @@ class Serega
     #     attribute :updated_at, format: :iso8601
     #
     #     # Using `callable` formatter
+    #     attribute :score_percent, format: PercentFormmatter # callable class
     #     attribute :score_percent, format: proc { |percent| "#{percent.round(2)}%" }
     #   end
     #
@@ -68,6 +72,7 @@ class Serega
       def self.load_plugin(serializer_class, **_opts)
         serializer_class::SeregaConfig.include(ConfigInstanceMethods)
         serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
+        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
       end
 
       #
@@ -107,6 +112,7 @@ class Serega
         # @return [void]
         def add(formatters)
           formatters.each_pair do |key, value|
+            CheckFormatter.call(key, value)
             opts[key] = value
           end
         end
@@ -124,6 +130,21 @@ class Serega
         end
       end
 
+      #
+      # Serega::SeregaValidations::CheckAttributeParams additional/patched class methods
+      #
+      # @see Serega::SeregaValidations::CheckAttributeParams
+      #
+      module CheckAttributeParamsInstanceMethods
+        private
+
+        def check_opts
+          super
+
+          CheckOptFormat.call(opts, self.class.serializer_class)
+        end
+      end
+
       #
       # Attribute class additional/patched instance methods
       #
@@ -143,16 +164,10 @@ class Serega
         def prepare_value_block
           return super unless formatter
 
-          if init_opts.key?(:const)
-            # Format const value in advance
-            const_value = formatter.call(init_opts[:const])
-            proc { const_value }
-          else
-            # Wrap original block into formatter block
-            proc do |object, context|
-              value = super.call(object, context)
-              formatter.call(value)
-            end
+          # Wrap original block into formatter block
+          proc do |object, context|
+            value = super.call(object, context)
+            formatter.call(value, context)
           end
         end
 
@@ -160,10 +175,69 @@ class Serega
           formatter = init_opts[:format]
           return unless formatter
 
-          if formatter.is_a?(Symbol)
-            self.class.serializer_class.config.formatters.opts.fetch(formatter)
-          else
-            formatter # already callable
+          formatter = self.class.serializer_class.config.formatters.opts.fetch(formatter) if formatter.is_a?(Symbol)
+          prepare_callable_proc(formatter)
+        end
+      end
+
+      #
+      # Validator for attribute :format option
+      #
+      class CheckOptFormat
+        class << self
+          #
+          # Checks attribute :format option must be registered or valid callable with maximum 2 args
+          #
+          # @param opts [value] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          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(:format, formatter)
+            end
+          end
+
+          private
+
+          def check_formatter_defined(serializer_class, formatter)
+            return if serializer_class.config.formatters.opts.key?(formatter)
+
+            raise Serega::SeregaError, "Formatter `#{formatter.inspect}` was not defined"
+          end
+        end
+      end
+
+      #
+      # Validator for formatters defined as config options or directly as attribute :format option
+      #
+      class CheckFormatter
+        class << self
+          #
+          # Check formatter type and parameters
+          #
+          # @param formatter_name [Symbol] Name of formatter
+          # @param formatter [#call] Formatter callable object
+          #
+          # @return [void]
+          #
+          def call(formatter_name, formatter)
+            raise Serega::SeregaError, "Option #{formatter_name.inspect} must have callable value" unless formatter.respond_to?(:call)
+
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(formatter, "#{formatter_name.inspect} value")
+            params_count = SeregaUtils::ParamsCount.call(formatter, max_count: 2)
+
+            if params_count > 2
+              raise SeregaError, "Formatter can have maximum 2 parameters (value to format, context)"
+            end
           end
         end
       end

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

@@ -61,10 +61,11 @@ class Serega
         require_relative "validations/check_opt_unless"
         require_relative "validations/check_opt_unless_value"
 
-        serializer_class::SeregaAttribute.include(SeregaAttributeInstanceMethods)
+        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
+        serializer_class::SeregaAttributeNormalizer.include(AttributeNormalizerInstanceMethods)
         serializer_class::SeregaPlanPoint.include(PlanPointInstanceMethods)
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-        serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
+        serializer_class::SeregaObjectSerializer.include(ObjectSerializerInstanceMethods)
       end
 
       #
@@ -79,12 +80,47 @@ class Serega
         serializer_class.config.attribute_keys << :if << :if_value << :unless << :unless_value
       end
 
+      #
+      # SeregaAttributeNormalizer additional/patched instance methods
+      #
+      # @see SeregaAttributeNormalizer::AttributeInstanceMethods
+      #
+      module AttributeNormalizerInstanceMethods
+        #
+        # Returns prepared attribute :if_options.
+        #
+        # @return [Hash] prepared options for :if plugin
+        #
+        def if_options
+          @if_options ||= {
+            if: prepare_if_option(init_opts[:if]),
+            unless: prepare_if_option(init_opts[:unless]),
+            if_value: prepare_if_option(init_opts[:if_value]),
+            unless_value: prepare_if_option(init_opts[:unless_value])
+          }.freeze
+        end
+
+        private
+
+        def prepare_if_option(if_option)
+          return unless if_option
+          return proc { |val| val.public_send(if_option) } if if_option.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(if_option, max_count: 2)
+          case params_count
+          when 0 then proc { if_option.call }
+          when 1 then proc { |obj| if_option.call(obj) }
+          else if_option
+          end
+        end
+      end
+
       #
       # SeregaAttribute additional/patched instance methods
       #
       # @see Serega::SeregaAttribute
       #
-      module SeregaAttributeInstanceMethods
+      module AttributeInstanceMethods
         # @return provided :if options
         attr_reader :opt_if
 
@@ -92,7 +128,7 @@ class Serega
 
         def set_normalized_vars(normalizer)
           super
-          @opt_if = initials[:opts].slice(:if, :if_value, :unless, :unless_value).freeze
+          @opt_if = normalizer.if_options
         end
       end
 
@@ -125,20 +161,8 @@ class Serega
           opt_unless = attribute.opt_if[opt_unless_name]
           return true if opt_if.nil? && opt_unless.nil?
 
-          res_if =
-            case opt_if
-            when NilClass then true
-            when Symbol then obj.public_send(opt_if)
-            else opt_if.call(obj, ctx)
-            end
-
-          res_unless =
-            case opt_unless
-            when NilClass then true
-            when Symbol then !obj.public_send(opt_unless)
-            else !opt_unless.call(obj, ctx)
-            end
-
+          res_if = opt_if ? opt_if.call(obj, ctx) : true
+          res_unless = opt_unless ? !opt_unless.call(obj, ctx) : true
           res_if && res_unless
         end
       end
@@ -166,7 +190,7 @@ class Serega
       #
       # @see Serega::SeregaObjectSerializer
       #
-      module SeregaObjectSerializerInstanceMethods
+      module ObjectSerializerInstanceMethods
         private
 
         def serialize_point(object, point, _container)

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

@@ -27,48 +27,16 @@ class Serega
 
           def check_type(value)
             return if value.is_a?(Symbol)
-
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            if value.is_a?(Proc)
-              check_block(value)
-            else
-              check_callable(value)
-            end
-          end
-
-          def check_block(block)
-            return if valid_parameters?(block, accepted_count: 0..2)
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":if option")
+            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
 
-            raise SeregaError, block_parameters_error
-          end
-
-          def check_callable(callable)
-            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
-
-            raise SeregaError, callable_parameters_error
-          end
-
-          def valid_parameters?(data, accepted_count:)
-            params = data.parameters
-            accepted_count.include?(params.count) && valid_parameters_types?(params)
-          end
-
-          def valid_parameters_types?(params)
-            params.all? do |param|
-              type = param[0]
-              (type == :req) || (type == :opt)
+            if params_count > 2
+              raise SeregaError, "Option :if value should have up to 2 parameters (object, context)"
             end
           end
 
-          def block_parameters_error
-            "Invalid attribute option :if. When it is a Proc it can have maximum two regular parameters (object, context)"
-          end
-
-          def callable_parameters_error
-            "Invalid attribute option :if. When it is a callable object it must have two regular parameters (object, context)"
-          end
-
           def must_be_callable
             "Invalid attribute option :if. It must be a Symbol, a Proc or respond to :call"
           end

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

@@ -26,54 +26,22 @@ class Serega
 
           private
 
-          def check_type(value)
-            return if value.is_a?(Symbol)
-
-            raise SeregaError, must_be_callable unless value.respond_to?(:call)
-
-            if value.is_a?(Proc)
-              check_block(value)
-            else
-              check_callable(value)
-            end
-          end
-
           def check_usage_with_other_params(opts)
             raise SeregaError, "Option :if_value can not be used together with option :serializer" if opts.key?(:serializer)
           end
 
-          def check_block(block)
-            return if valid_parameters?(block, accepted_count: 0..2)
-
-            raise SeregaError, block_parameters_error
-          end
-
-          def check_callable(callable)
-            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
-
-            raise SeregaError, callable_parameters_error
-          end
+          def check_type(value)
+            return if value.is_a?(Symbol)
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-          def valid_parameters?(data, accepted_count:)
-            params = data.parameters
-            accepted_count.include?(params.count) && valid_parameters_types?(params)
-          end
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":if_value option")
+            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
 
-          def valid_parameters_types?(params)
-            params.all? do |param|
-              type = param[0]
-              (type == :req) || (type == :opt)
+            if params_count > 2
+              raise SeregaError, "Option :if_value value should have up to 2 parameters (value, context)"
             end
           end
 
-          def block_parameters_error
-            "Invalid attribute option :if_value. When it is a Proc it can have maximum two regular parameters (object, context)"
-          end
-
-          def callable_parameters_error
-            "Invalid attribute option :if_value. When it is a callable object it must have two regular parameters (object, context)"
-          end
-
           def must_be_callable
             "Invalid attribute option :if_value. It must be a Symbol, a Proc or respond to :call"
           end

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

@@ -25,59 +25,18 @@ class Serega
 
           private
 
-          #
-          # Checks attribute :unless option
-          #
-          # @param value [nil, Symbol, Proc, #call] Attribute :unless option
-          #
-          # @raise [SeregaError] validation error
-          #
-          # @return [void]
-          #
           def check_type(value)
             return if value.is_a?(Symbol)
-
             raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-            if value.is_a?(Proc)
-              check_block(value)
-            else
-              check_callable(value)
-            end
-          end
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":unless option")
+            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
 
-          def check_block(block)
-            return if valid_parameters?(block, accepted_count: 0..2)
-
-            raise SeregaError, block_parameters_error
-          end
-
-          def check_callable(callable)
-            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
-
-            raise SeregaError, callable_parameters_error
-          end
-
-          def valid_parameters?(data, accepted_count:)
-            params = data.parameters
-            accepted_count.include?(params.count) && valid_parameters_types?(params)
-          end
-
-          def valid_parameters_types?(params)
-            params.all? do |param|
-              type = param[0]
-              (type == :req) || (type == :opt)
+            if params_count > 2
+              raise SeregaError, "Option :unless value should have up to 2 parameters (object, context)"
             end
           end
 
-          def block_parameters_error
-            "Invalid attribute option :unless. When it is a Proc it can have maximum two regular parameters (object, context)"
-          end
-
-          def callable_parameters_error
-            "Invalid attribute option :unless. When it is a callable object it must have two regular parameters (object, context)"
-          end
-
           def must_be_callable
             "Invalid attribute option :unless. It must be a Symbol, a Proc or respond to :call"
           end

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

@@ -26,54 +26,22 @@ class Serega
 
           private
 
-          def check_type(value)
-            return if value.is_a?(Symbol)
-
-            raise SeregaError, must_be_callable unless value.respond_to?(:call)
-
-            if value.is_a?(Proc)
-              check_block(value)
-            else
-              check_callable(value)
-            end
-          end
-
           def check_usage_with_other_params(opts)
             raise SeregaError, "Option :unless_value can not be used together with option :serializer" if opts.key?(:serializer)
           end
 
-          def check_block(block)
-            return if valid_parameters?(block, accepted_count: 0..2)
-
-            raise SeregaError, block_parameters_error
-          end
-
-          def check_callable(callable)
-            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
-
-            raise SeregaError, callable_parameters_error
-          end
+          def check_type(value)
+            return if value.is_a?(Symbol)
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
 
-          def valid_parameters?(data, accepted_count:)
-            params = data.parameters
-            accepted_count.include?(params.count) && valid_parameters_types?(params)
-          end
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":unless_value option")
+            params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
 
-          def valid_parameters_types?(params)
-            params.all? do |param|
-              type = param[0]
-              (type == :req) || (type == :opt)
+            if params_count > 2
+              raise SeregaError, "Option :unless_value value should have up to 2 parameters (value, context)"
             end
           end
 
-          def block_parameters_error
-            "Invalid attribute option :unless_value. When it is a Proc it can have maximum two regular parameters (object, context)"
-          end
-
-          def callable_parameters_error
-            "Invalid attribute option :unless_value. When it is a callable object it must have two regular parameters (object, context)"
-          end
-
           def must_be_callable
             "Invalid attribute option :unless_value. It must be a Symbol, a Proc or respond to :call"
           end