serega 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b291b12115b8ca239642972b103f896f13f02874acdc5663a8f404e02673ca8d
-  data.tar.gz: 18bd88ca4bd77ca147161189efe57b2c544da6cc1b460fc7c694855d4b22edc9
+  metadata.gz: 47eacc613b0a58af4dc552e09e0f55ed731f7e2a852e5c668794e7eb5128be69
+  data.tar.gz: bb9fec8432d12108e374bf15da74a230a4efda994835e9480e795b7222bb9ced
 SHA512:
-  metadata.gz: d5c5114ed1c1b8b5a0714a340aca263983f5f8cdb24d15c8138124d64520ebafe03f6c64a7985f131ee399fab287ee578889b1affa1e2aa6f4ddacfbb9c8517e
-  data.tar.gz: 4d8191c7081b4650e3328141ec3cc2dc9128a7c4da3a38107e5f2c107d1d70446b67e718a3ffa2ff76e700f80dbdf975da9512d089c86ec552c3dc8a390345d1
+  metadata.gz: d7536453cd03fd6e0f65faf22f85f5a12de61ef2bda50d674cd5b31ab1fba815c4b94d5118d82902f5a434d06112cfdc16757eefd334ba217946f9e920442e05
+  data.tar.gz: 9bcd5c46c1ffa32f95bc02e821e94acd46408e4e65a0861e4738454e24a57767105a5d3a9af48d52c4662a1030819963f11ee8c317c84ed179eb44b282a02c73

data/README.md

@@ -73,7 +73,8 @@ class UserSerializer < Serega
   # Block is used to define attribute value
   attribute(:first_name) { |user| user.profile&.first_name }
 
-  # Option :value can be used with callable object to define attribute value
+  # Option :value can be used with proc or callable object to define attribute value
+  attribute :first_name, value: UserProfile.new # must have #call method
   attribute :first_name, value: proc { |user| user.profile&.first_name }
 
   # Option :delegate can be used to define attribute value.
@@ -555,7 +556,7 @@ attribute :name, batch: { loader: :name_loader, key: :id, default: nil }
 `:batch` option must be a hash with this keys:
 
 - `loader` (required) [Symbol, Proc, callable] - Defines how to fetch values for
-  batch of keys. Receives 3 parameters: keys, context, plan_point.
+  batch of keys. Receives 3 parameters: keys, context, plan.
 - `key` (required) [Symbol, Proc, callable] - Defines current object identifier.
   Key is optional if plugin was defined with `default_key` option.
 - `default` (optional) - Default value for attribute.
@@ -715,17 +716,24 @@ Adds ability to describe metadata and adds it to serialized response
 
 Added class-level method `:meta_attribute`, to define metadata, it accepts:
 
-- *path [Array of Symbols] - nested hash keys.
-- **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
 
 ```ruby
 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)
 
@@ -738,7 +746,7 @@ class AppSerializer < Serega
 end
 
 AppSerializer.to_h(nil)
-# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=>[:foo, :bar]}}
+# => {:data=>nil, :version=>"1.2.3", :ab_tests=>{:names=> ... }}
 ```
 
 ### Plugin :context_metadata
@@ -773,15 +781,18 @@ Allows to define `formatters` and apply them on attribute values.
 
 Config option `config.formatters.add` can be used to add formatters.
 
-Attribute option `:format` now can be used with name of formatter or with
+Attribute option `:format` can be used with name of formatter or with
 callable instance.
 
+Formatters can accept up to 2 parameters (formatted object, context)
+
 ```ruby
 class AppSerializer < Serega
   plugin :formatters, formatters: {
     iso8601: ->(value) { time.iso8601.round(6) },
     on_off: ->(value) { value ? 'ON' : 'OFF' },
-    money: ->(value) { value.round(2) }
+    money: ->(value, ctx) { value / 10**ctx[:digits) }
+    date: DateTypeFormatter # callable
   }
 end
 
@@ -1029,6 +1040,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [batch]: #plugin-batch
 [camel_case]: #plugin-camel_case
 [context_metadata]: #plugin-context_metadata
+[depth_limit]: #plugin-depth_limit
 [formatters]: #plugin-formatters
 [metadata]: #plugin-metadata
 [preloads]: #plugin-preloads

data/VERSION

@@ -1 +1 @@
-0.16.0
+0.17.0

data/lib/serega/attribute.rb

@@ -61,10 +61,10 @@ class Serega
       # Shows specified serializer class
       # @return [Serega, nil] Attribute serializer if exists
       def serializer
-        ser = @serializer
-        return ser if (ser.is_a?(Class) && (ser < Serega)) || !ser
+        serializer = @serializer
+        return serializer if (serializer.is_a?(Class) && (serializer < Serega)) || !serializer
 
-        @serializer = ser.is_a?(String) ? Object.const_get(ser, false) : ser.call
+        @serializer = serializer.is_a?(String) ? Object.const_get(serializer, false) : serializer.call
       end
 
       #

data/lib/serega/attribute_normalizer.rb

@@ -97,8 +97,8 @@ class Serega
       # - plugin :formatters (wraps resulted block in formatter block and formats :const values)
       #
       def prepare_value_block
-        init_block ||
-          init_opts[:value] ||
+        prepare_init_block ||
+          prepare_value_option_block ||
           prepare_const_block ||
           prepare_delegate_block ||
           prepare_keyword_block
@@ -139,6 +139,25 @@ class Serega
         end
       end
 
+      def prepare_init_block
+        prepare_callable_proc(init_block)
+      end
+
+      def prepare_value_option_block
+        prepare_callable_proc(init_opts[:value])
+      end
+
+      def prepare_callable_proc(callable)
+        return unless callable
+
+        params_count = SeregaUtils::ParamsCount.call(callable, max_count: 2)
+        case params_count
+        when 0 then proc { |obj, _ctx| callable.call }
+        when 1 then proc { |obj, _ctx| callable.call(obj) }
+        else callable
+        end
+      end
+
       def prepare_delegate_block
         delegate = init_opts[:delegate]
         return unless delegate

data/lib/serega/plugins/batch/lib/batch_config.rb

@@ -22,17 +22,20 @@ class Serega
         #
         # @return [void]
         #
-        def define(loader_name, &block)
-          unless block
-            raise SeregaError, "Block must be given to #define method"
+        def define(loader_name, callable = nil, &block)
+          if (!callable && !block) || (callable && block)
+            raise SeregaError, "Batch loader can be specified with one of arguments - callable value or &block"
           end
 
-          params = block.parameters
-          if params.count > 3 || !params.all? { |param| (param[0] == :req) || (param[0] == :opt) }
-            raise SeregaError, "Block can have maximum 3 regular parameters"
+          callable ||= block
+          SeregaValidations::Utils::CheckExtraKeywordArg.call(callable, "batch loader `#{loader_name}`")
+          params_count = SeregaUtils::ParamsCount.call(callable, max_count: 3)
+
+          if params_count > 3
+            raise SeregaError, "Batch loader can have maximum 3 parameters (keys, context, plan)"
           end
 
-          loaders[loader_name] = block
+          loaders[loader_name] = callable
         end
 
         # Shows defined loaders
@@ -48,7 +51,7 @@ class Serega
         #
         # @return [Proc] batch loader block
         def fetch_loader(loader_name)
-          loaders[loader_name] || (raise SeregaError, "Batch loader with name `#{loader_name.inspect}` was not defined. Define example: config.batch.define(:#{loader_name}) { |keys, ctx, points| ... }")
+          loaders[loader_name] || (raise SeregaError, "Batch loader with name `#{loader_name.inspect}` was not defined. Define example: config.batch.define(:#{loader_name}) { |keys| ... }")
         end
 
         # Shows option to auto hide attributes with :batch specified

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

@@ -42,22 +42,37 @@ class Serega
           batch = init_opts[:batch]
           return unless batch
 
-          # take loader
-          loader = batch[:loader]
+          loader = prepare_batch_loader(batch[:loader])
 
-          # take key
           key = batch[:key] || self.class.serializer_class.config.batch.default_key
-          proc_key =
-            if key.is_a?(Symbol)
-              proc { |object| object.public_send(key) }
-            else
-              key
-            end
+          key = prepare_batch_key(key)
 
-          # take default value
           default = batch.fetch(:default) { many ? FROZEN_EMPTY_ARRAY : nil }
 
-          {loader: loader, key: proc_key, default: default}
+          {loader: loader, key: key, default: default}
+        end
+
+        def prepare_batch_key(key)
+          return proc { |object| object.public_send(key) } if key.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(key, max_count: 2)
+          case params_count
+          when 0 then proc { key.call }
+          when 1 then proc { |object| key.call(object) }
+          else key
+          end
+        end
+
+        def prepare_batch_loader(loader)
+          return loader if loader.is_a?(Symbol)
+
+          params_count = SeregaUtils::ParamsCount.call(loader, max_count: 3)
+          case params_count
+          when 0 then proc { loader.call }
+          when 1 then proc { |object| loader.call(object) }
+          when 2 then proc { |object, context| loader.call(object, context) }
+          else loader
+          end
         end
       end
     end

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

@@ -22,45 +22,15 @@ class Serega
 
             raise SeregaError, must_be_callable unless key.respond_to?(:call)
 
-            if key.is_a?(Proc)
-              check_block(key)
-            else
-              check_callable(key)
-            end
+            SeregaValidations::Utils::CheckExtraKeywordArg.call(key, "batch option :key")
+            params_count = SeregaUtils::ParamsCount.call(key, max_count: 2)
+            raise SeregaError, params_count_error if params_count > 2
           end
 
           private
 
-          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)
-            end
-          end
-
-          def block_parameters_error
-            "Invalid :batch option :key. When it is a Proc it can have maximum two regular parameters (object, context)"
-          end
-
-          def callable_parameters_error
-            "Invalid :batch option :key. When it is a callable object it must have two regular parameters (object, context)"
+          def params_count_error
+            "Invalid :batch option :key. It can accept maximum 2 parameters (object, context)"
           end
 
           def must_be_callable

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

@@ -22,45 +22,15 @@ class Serega
 
             raise SeregaError, must_be_callable unless loader.respond_to?(:call)
 
-            if loader.is_a?(Proc)
-              check_block(loader)
-            else
-              check_callable(loader)
-            end
+            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
 
           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)
-
-            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)
-            end
-          end
-
-          def block_parameters_error
-            "Invalid :batch option :loader. When it is a Proc it can have maximum three regular parameters (keys, context, point)"
-          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 (keys, context, plan)"
           end
 
           def must_be_callable

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