serega 0.15.0 → 0.17.0

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

@@ -56,15 +56,16 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
-        require_relative "./validations/check_opt_if"
-        require_relative "./validations/check_opt_if_value"
-        require_relative "./validations/check_opt_unless"
-        require_relative "./validations/check_opt_unless_value"
+        require_relative "validations/check_opt_if"
+        require_relative "validations/check_opt_if_value"
+        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

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

@@ -20,7 +20,7 @@ class Serega
           # @return [Proc] Meta attribute options
           attr_reader :opts
 
-          # @return [Proc] Meta attribute originally added block
+          # @return [Proc,nil] Meta attribute originally added block
           attr_reader :block
 
           #
@@ -39,6 +39,7 @@ class Serega
             @path = SeregaUtils::EnumDeepDup.call(path)
             @opts = SeregaUtils::EnumDeepDup.call(opts)
             @block = block
+            @normalized_block = normalize_block(opts[:value], opts[:const], block)
           end
 
           #
@@ -50,19 +51,34 @@ class Serega
           # @return [Object] Serialized meta attribute value
           #
           def value(object, context)
-            block.call(object, context)
+            normalized_block.call(object, context)
           end
 
           def hide?(value)
-            (opts[:hide_nil] && value.nil?) || (opts[:hide_empty] && value.empty?)
+            (!!opts[:hide_nil] && value.nil?) || (!!opts[:hide_empty] && (value.nil? || (value.respond_to?(:empty?) && value.empty?)))
           end
 
           private
 
+          attr_reader :normalized_block
+
+          def normalize_block(value, const, block)
+            return proc { const } if const
+
+            callable = (value || block)
+            params_count = SeregaUtils::ParamsCount.call(callable, max_count: 2)
+
+            case params_count
+            when 0 then proc { callable.call }
+            when 1 then proc { |obj| callable.call(obj) }
+            else callable
+            end
+          end
+
           def check(path, opts, block)
             CheckPath.call(path) if check_attribute_name
-            CheckOpts.call(opts, attribute_keys)
-            CheckBlock.call(block)
+            CheckOpts.call(opts, block, attribute_keys)
+            CheckBlock.call(block) if block
           end
 
           def attribute_keys

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

@@ -10,17 +10,24 @@ class Serega
     # Adds ability to describe metadata that must be added to serialized response
     #
     # Added class-level method `:meta_attribute`, to define metadata, it accepts:
-    # - *path [Array<Symbol>] - nested hash keys beginning from the root object.
-    # - **options [Hash] - defaults are `hide_nil: false, hide_empty: false`
-    # - &block [Proc] - describes value for current meta attribute
+    #
+    # - `*path` [Array of Symbols] - nested hash keys.
+    # - `**options` [Hash]
+    #
+    #   - `:const` - describes metadata value (if it is constant)
+    #   - `:value` - describes metadata value as any `#callable` instance
+    #   - `:hide_nil` - does not show metadata key if value is nil, `false` by default
+    #   - `:hide_empty`, does not show metadata key if value is nil or empty, `false` by default
+    #
+    # - `&block` [Proc] - describes value for current meta attribute
     #
     # @example
     #  class AppSerializer < Serega
     #    plugin :root
     #    plugin :metadata
     #
-    #    meta_attribute(:version) { '1.2.3' }
-    #    meta_attribute(:ab_tests, :names) { %i[foo bar] }
+    #    meta_attribute(:version, const: '1.2.3')
+    #    meta_attribute(:ab_tests, :names, value: ABTests.new.method(:names))
     #    meta_attribute(:meta, :paging, hide_nil: true) do |records, ctx|
     #      next unless records.respond_to?(:total_count)
     #
@@ -28,7 +35,7 @@ class Serega
     #    end
     #  end
     #
-    #  AppSerializer.to_h(nil) # => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=>[:foo, :bar]}}
+    #  AppSerializer.to_h(nil) # => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=> ... }}
     #
     module Metadata
       # @return [Symbol] Plugin name
@@ -62,12 +69,14 @@ class Serega
         serializer_class.include(InstanceMethods)
         serializer_class::SeregaConfig.include(ConfigInstanceMethods)
 
-        require_relative "./meta_attribute"
-        require_relative "./validations/check_block"
-        require_relative "./validations/check_opt_hide_nil"
-        require_relative "./validations/check_opt_hide_empty"
-        require_relative "./validations/check_opts"
-        require_relative "./validations/check_path"
+        require_relative "meta_attribute"
+        require_relative "validations/check_block"
+        require_relative "validations/check_opt_const"
+        require_relative "validations/check_opt_hide_nil"
+        require_relative "validations/check_opt_hide_empty"
+        require_relative "validations/check_opt_value"
+        require_relative "validations/check_opts"
+        require_relative "validations/check_path"
 
         meta_attribute_class = Class.new(MetaAttribute)
         meta_attribute_class.serializer_class = serializer_class
@@ -83,7 +92,7 @@ class Serega
       # @return [void]
       #
       def self.after_load_plugin(serializer_class, **_opts)
-        serializer_class.config.opts[:metadata] = {attribute_keys: %i[path hide_nil hide_empty]}
+        serializer_class.config.opts[:metadata] = {attribute_keys: %i[const hide_nil hide_empty value]}
       end
 
       #

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

@@ -8,14 +8,10 @@ class Serega
         # Validator for meta_attribute block parameter
         #
         class CheckBlock
-          ALLOWED_PARAM_TYPES = %i[opt req]
-          private_constant :ALLOWED_PARAM_TYPES
-
           class << self
             #
             # Checks block provided with attribute
-            # Block must have up to two arguments - object and context.
-            # It should not have any *rest or **key arguments
+            # Block must have up to two arguments - object(s) and context.
             #
             # @example without arguments
             #   metadata(:version) { CONSTANT_VERSION }
@@ -24,7 +20,7 @@ class Serega
             #   metadata(:paging) { |scope| { { page: scope.page, per_page: scope.per_page, total_count: scope.total_count } }
             #
             # @example with two arguments
-            #   metadata(:paging) { |scope, context| { { ... } if context[:with_paging] }
+            #   metadata(:paging) { |scope, context| { { ... } if context[:pagy] }
             #
             # @param block [Proc] Block that returns serialized meta attribute value
             #
@@ -33,12 +29,16 @@ class Serega
             # @return [void]
             #
             def call(block)
-              raise SeregaError, "Block must be provided when defining meta attribute" unless block
+              SeregaValidations::Utils::CheckExtraKeywordArg.call(block, "block")
+              params_count = SeregaUtils::ParamsCount.call(block, max_count: 2)
+
+              raise SeregaError, block_error if params_count > 2
+            end
 
-              params = block.parameters
-              return if (params.count <= 2) && params.all? { |par| ALLOWED_PARAM_TYPES.include?(par[0]) }
+            private
 
-              raise SeregaError, "Block can have maximum 2 regular parameters (no **keyword or *array args)"
+            def block_error
+              "Block can have maximum two parameters (object(s), context)"
             end
           end
         end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Metadata
+      class MetaAttribute
+        #
+        # MetaAttribute `:const` option validator
+        #
+        class CheckOptConst
+          class << self
+            #
+            # Checks meta_attribute :const option
+            #
+            # @param opts [Hash] MetaAttribute options
+            #
+            # @raise [SeregaError] validation error
+            #
+            # @return [void]
+            #
+            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 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module Metadata
+      class MetaAttribute
+        #
+        # Validator for meta_attribute :value option
+        #
+        class CheckOptValue
+          class << self
+            #
+            # Checks attribute :value option
+            #
+            # @param opts [Hash] Attribute options
+            #
+            # @raise [SeregaError] SeregaError that option has invalid value
+            #
+            # @return [void]
+            #
+            def call(opts, block = nil)
+              return unless opts.key?(:value)
+
+              check_usage_with_other_params(opts, block)
+
+              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 :const" if opts.key?(:const)
+              raise SeregaError, "Option :value can not be used together with block" if block
+            end
+
+            def check_value(value)
+              check_value_type(value)
+
+              SeregaValidations::Utils::CheckExtraKeywordArg.call(value, ":value option")
+              params_count = SeregaUtils::ParamsCount.call(value, max_count: 2)
+
+              raise SeregaError, params_count_error if params_count > 2
+            end
+
+            def check_value_type(value)
+              raise SeregaError, type_error if !value.is_a?(Proc) && !value.respond_to?(:call)
+            end
+
+            def type_error
+              "Option :value value must be a Proc or respond to #call"
+            end
+
+            def params_count_error
+              "Option :value value can have maximum 2 parameters (object(s), context)"
+            end
+          end
+        end
+      end
+    end
+  end
+end