serega 0.8.3 → 0.10.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module If
+      #
+      # Validator for attribute :unless_value option
+      #
+      class CheckOptUnlessValue
+        class << self
+          #
+          # Checks attribute :unless_value option that must be [nil, Symbol, Proc, #call]
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:unless_value)
+
+            check_usage_with_other_params(opts)
+            check_type(opts[:unless_value])
+          end
+
+          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 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 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
+        end
+      end
+    end
+  end
+end

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

@@ -60,10 +60,18 @@ class Serega
           private
 
           def check(path, opts, block)
-            CheckPath.call(path)
-            CheckOpts.call(opts, self.class.serializer_class.config.metadata.attribute_keys)
+            CheckPath.call(path) if check_attribute_name
+            CheckOpts.call(opts, attribute_keys)
             CheckBlock.call(block)
           end
+
+          def attribute_keys
+            self.class.serializer_class.config.metadata.attribute_keys
+          end
+
+          def check_attribute_name
+            self.class.serializer_class.config.check_attribute_name
+          end
         end
 
         extend Serega::SeregaHelpers::SerializerClassHelper

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

@@ -130,19 +130,6 @@ class Serega
       # @see Serega::SeregaConfig
       #
       module ClassMethods
-        private def inherited(subclass)
-          super
-
-          meta_attribute_class = Class.new(self::MetaAttribute)
-          meta_attribute_class.serializer_class = subclass
-          subclass.const_set(:MetaAttribute, meta_attribute_class)
-
-          # Assign same metadata attributes
-          meta_attributes.each_value do |attr|
-            subclass.meta_attribute(*attr.path, **attr.opts, &attr.block)
-          end
-        end
-
         #
         # List of added metadata attributes
         #
@@ -165,6 +152,21 @@ class Serega
           attribute = self::MetaAttribute.new(path: path, opts: opts, block: block)
           meta_attributes[attribute.name] = attribute
         end
+
+        private
+
+        def inherited(subclass)
+          super
+
+          meta_attribute_class = Class.new(self::MetaAttribute)
+          meta_attribute_class.serializer_class = subclass
+          subclass.const_set(:MetaAttribute, meta_attribute_class)
+
+          # Assign same metadata attributes
+          meta_attributes.each_value do |attr|
+            subclass.meta_attribute(*attr.path, **attr.opts, &attr.block)
+          end
+        end
       end
 
       #

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

@@ -8,16 +8,15 @@ class Serega
         # Validator for meta_attribute :path parameter
         #
         class CheckPath
-          FORMAT_ONE_CHAR = /\A[a-zA-Z0-9]\z/
-          FORMAT_MANY_CHARS = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*?[a-zA-Z0-9]\z/ # allow '-' and '_' in the middle
+          # Regexp for valid path
+          FORMAT = /\A[\w~-]+\z/
 
-          private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+          private_constant :FORMAT
 
           class << self
             #
-            # Checks allowed characters in specified metadata path parts.
-            # Globally allowed characters: "a-z", "A-Z", "0-9".
-            # Minus and low line "-", "_" also allowed except as the first or last character.
+            # Checks allowed characters.
+            # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
             #
             # @param path [Array<String, Symbol>] Metadata attribute path names
             #
@@ -33,20 +32,14 @@ class Serega
             def check_name(name)
               name = name.to_s
 
-              valid =
-                case name.size
-                when 0 then false
-                when 1 then name.match?(FORMAT_ONE_CHAR)
-                else name.match?(FORMAT_MANY_CHARS)
-                end
-
-              return if valid
-
-              raise SeregaError, message(name)
+              raise SeregaError, message(name) unless FORMAT.match?(name)
             end
 
             def message(name)
-              %(Invalid metadata path #{name.inspect}, globally allowed characters: "a-z", "A-Z", "0-9". Minus and low line "-", "_" also allowed except as the first or last character)
+              <<~MESSAGE.tr("\n", "")
+                Invalid metadata path #{name.inspect}.
+                 Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~"
+              MESSAGE
             end
           end
         end

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

@@ -235,6 +235,8 @@ class Serega
           @auto_hide_attribute_with_preloads = auto && !preloads.nil? && (preloads != false) && (preloads != {})
         end
 
+        # Patched in:
+        # - plugin :batch (extension :preloads - skips auto preloads when batch option provided)
         def get_preloads
           preloads_provided = opts.key?(:preload)
           preloads =

data/lib/serega/plugins/presenter/presenter.rb

@@ -80,14 +80,6 @@ class Serega
       # @see Serega
       #
       module ClassMethods
-        private def inherited(subclass)
-          super
-
-          presenter_class = Class.new(self::Presenter)
-          presenter_class.serializer_class = subclass
-          subclass.const_set(:Presenter, presenter_class)
-        end
-
         # Overrides {Serega::ClassMethods#attribute} method, additionally adds method
         # to Presenter to not hit {Serega::SeregaPlugins::Presenter::Presenter#method_missing}
         # @see Serega::ClassMethods#attribute
@@ -96,6 +88,16 @@ class Serega
             self::Presenter.def_delegator(:__getobj__, attribute.key) unless attribute.block
           end
         end
+
+        private
+
+        def inherited(subclass)
+          super
+
+          presenter_class = Class.new(self::Presenter)
+          presenter_class.serializer_class = subclass
+          subclass.const_set(:Presenter, presenter_class)
+        end
       end
 
       #

data/lib/serega/plugins/string_modifiers/parse_string_modifiers.rb

@@ -25,72 +25,61 @@ class Serega
       # Modifiers parser
       #
       class ParseStringModifiers
-        #
-        # Parses provided fields
-        #
-        # @param fields [String,Hash,Array,nil]
-        #
-        # @return [Hash] parsed modifiers in form of nested hash
-        #
-        def self.call(fields)
-          return fields unless fields.is_a?(String)
+        class << self
+          #
+          # Parses string modifiers
+          #
+          # @param fields [String]
+          #
+          # @return [Hash] parsed modifiers in form of nested hash
+          #
+          # @example
+          #   parse("user") => { user: {} }
+          #   parse("user(id)") => { user: { id: {} } }
+          #   parse("user(id,name)") => { user: { id: {}, name: {} } }
+          #   parse("user,comments") => { user: {}, comments: {} }
+          #   parse("user(comments(text))") => { user: { comments: { text: {} } } }
+          def parse(fields)
+            res = {}
+            attribute = +""
+            char = +""
+            path_stack = nil
+            fields = StringIO.new(fields)
 
-          new.parse(fields)
-        end
-
-        #
-        # Parses string modifiers
-        #
-        # @param fields [String]
-        #
-        # @return [Hash] parsed modifiers in form of nested hash
-        #
-        # @example
-        #   parse("user") => { user: {} }
-        #   parse("user(id)") => { user: { id: {} } }
-        #   parse("user(id,name)") => { user: { id: {}, name: {} } }
-        #   parse("user,comments") => { user: {}, comments: {} }
-        #   parse("user(comments(text))") => { user: { comments: { text: {} } } }
-        def parse(fields)
-          res = {}
-          attribute = +""
-          char = +""
-          path_stack = nil
-          fields = StringIO.new(fields)
-
-          while fields.read(1, char)
-            case char
-            when ","
-              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
-            when ")"
-              add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
-              path_stack&.pop
-            when "("
-              name = add_attribute(res, path_stack, attribute, {})
-              (path_stack ||= []).push(name) if name
-            else
-              attribute.insert(-1, char)
+            while fields.read(1, char)
+              case char
+              when ","
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+              when ")"
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+                path_stack&.pop
+              when "("
+                name = add_attribute(res, path_stack, attribute, {})
+                (path_stack ||= []).push(name) if name
+              else
+                attribute.insert(-1, char)
+              end
             end
-          end
 
-          add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+            add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
 
-          res
-        end
+            res
+          end
 
-        private
+          private
 
-        def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
-          attribute.strip!
-          return if attribute.empty?
+          def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
+            attribute.strip!
+            return if attribute.empty?
 
-          name = attribute.to_sym
-          attribute.clear
+            name = attribute.to_sym
+            attribute.clear
 
-          current_attrs = (!path_stack || path_stack.empty?) ? res : res.dig(*path_stack)
-          current_attrs[name] = nested_attributes
+            current_attrs = (!path_stack || path_stack.empty?) ? res : res.dig(*path_stack)
+            current_attrs[name] = nested_attributes
 
-          name
+            name
+          end
         end
       end
     end

data/lib/serega/plugins/string_modifiers/string_modifiers.rb

@@ -29,14 +29,10 @@ class Serega
       module InstanceMethods
         private
 
-        def prepare_modifiers(opts)
-          parsed_opts =
-            opts.each_with_object({}) do |(key, value), obj|
-              value = ParseStringModifiers.call(value) if (key == :only) || (key == :except) || (key == :with)
-              obj[key] = value
-            end
+        def parse_modifier(value)
+          return ParseStringModifiers.parse(value) if value.is_a?(String)
 
-          super(parsed_opts)
+          super
         end
       end
     end

data/lib/serega/utils/enum_deep_dup.rb

@@ -38,8 +38,8 @@ class Serega
         end
 
         def dup_array_values(duplicate_data)
-          duplicate_data.each_with_index do |value, index|
-            duplicate_data[index] = call(value) if value.is_a?(Enumerable)
+          duplicate_data.map! do |value|
+            value.is_a?(Enumerable) ? call(value) : value
           end
         end
       end

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

@@ -7,19 +7,13 @@ class Serega
       # Attribute `name` parameter validator
       #
       class CheckName
-        # Regexp for valid one-char attribute name
-        FORMAT_ONE_CHAR = /\A[a-zA-Z0-9]\z/
-
-        # Regexp for valid multi-chars attribute name
-        FORMAT_MANY_CHARS = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*?[a-zA-Z0-9]\z/ # allow '-' and '_' in the middle
-
-        private_constant :FORMAT_ONE_CHAR, :FORMAT_MANY_CHARS
+        # Regexp for valid attribute name
+        FORMAT = /\A[\w~-]+\z/
 
         class << self
           #
           # Checks allowed characters.
-          # Globally allowed characters: "a-z", "A-Z", "0-9".
-          # Minus and low line "-", "_" also allowed except as the first or last character.
+          # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
           #
           # @param name [String, Symbol] Attribute name
           #
@@ -28,23 +22,16 @@ class Serega
           #
           def call(name)
             name = SeregaUtils::SymbolName.call(name)
-
-            valid =
-              case name.size
-              when 0 then false
-              when 1 then name.match?(FORMAT_ONE_CHAR)
-              else name.match?(FORMAT_MANY_CHARS)
-              end
-
-            return if valid
-
-            raise SeregaError, message(name)
+            raise SeregaError, message(name) unless FORMAT.match?(name)
           end
 
           private
 
           def message(name)
-            %(Invalid attribute name = #{name.inspect}. Globally allowed characters: "a-z", "A-Z", "0-9". Minus and low line "-", "_" also allowed except as the first or last character)
+            <<~MESSAGE.tr("\n", "")
+              Invalid attribute name = #{name.inspect}.
+               Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~"
+            MESSAGE
           end
         end
       end

data/lib/serega/validations/check_attribute_params.rb

@@ -41,7 +41,7 @@ class Serega
         # Validates attribute params
         #
         def validate
-          check_name
+          check_name if check_attribute_name
           check_opts
           check_block
         end
@@ -52,6 +52,11 @@ class Serega
           Attribute::CheckName.call(name)
         end
 
+        # Patched in:
+        # - plugin :batch (checks :batch option)
+        # - plugin :context_metadata (checks context metadata option which is :meta by default)
+        # - plugin :if (checks :if, :if_value, :unless, :unless_value options)
+        # - plugin :preloads (checks :preload option)
         def check_opts
           Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
 
@@ -71,6 +76,10 @@ class Serega
         def allowed_opts_keys
           self.class.serializer_class.config.attribute_keys
         end
+
+        def check_attribute_name
+          self.class.serializer_class.config.check_attribute_name
+        end
       end
 
       include InstanceMethods

data/lib/serega.rb

@@ -70,49 +70,6 @@ class Serega
     # Returns current config
     # @return [SeregaConfig] current serializer config
     attr_reader :config
-
-    private def inherited(subclass)
-      config_class = Class.new(self::SeregaConfig)
-      config_class.serializer_class = subclass
-      subclass.const_set(:SeregaConfig, config_class)
-      subclass.instance_variable_set(:@config, subclass::SeregaConfig.new(config.opts))
-
-      attribute_class = Class.new(self::SeregaAttribute)
-      attribute_class.serializer_class = subclass
-      subclass.const_set(:SeregaAttribute, attribute_class)
-
-      map_class = Class.new(self::SeregaMap)
-      map_class.serializer_class = subclass
-      subclass.const_set(:SeregaMap, map_class)
-
-      map_point_class = Class.new(self::SeregaMapPoint)
-      map_point_class.serializer_class = subclass
-      subclass.const_set(:SeregaMapPoint, map_point_class)
-
-      object_serializer_class = Class.new(self::SeregaObjectSerializer)
-      object_serializer_class.serializer_class = subclass
-      subclass.const_set(:SeregaObjectSerializer, object_serializer_class)
-
-      check_attribute_params_class = Class.new(self::CheckAttributeParams)
-      check_attribute_params_class.serializer_class = subclass
-      subclass.const_set(:CheckAttributeParams, check_attribute_params_class)
-
-      check_initiate_params_class = Class.new(self::CheckInitiateParams)
-      check_initiate_params_class.serializer_class = subclass
-      subclass.const_set(:CheckInitiateParams, check_initiate_params_class)
-
-      check_serialize_params_class = Class.new(self::CheckSerializeParams)
-      check_serialize_params_class.serializer_class = subclass
-      subclass.const_set(:CheckSerializeParams, check_serialize_params_class)
-
-      # Assign same attributes
-      attributes.each_value do |attr|
-        subclass.attribute(attr.name, **attr.opts, &attr.block)
-      end
-
-      super
-    end
-
     #
     # Enables plugin for current serializer
     #
@@ -170,6 +127,9 @@ class Serega
     #
     # Adds attribute
     #
+    # Patched in:
+    # - plugin :presenter (additionally adds method in Presenter class)
+    #
     # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
     # @param opts [Hash] Options to serialize attribute
     # @param block [Proc] Custom block to find attribute value. Accepts object and context.
@@ -250,6 +210,54 @@ class Serega
     def as_json(object, opts = nil)
       config.from_json.call(to_json(object, opts))
     end
+
+    private
+
+    # Patched in:
+    # - plugin :batch (defines SeregaBatchLoaders, SeregaBatchLoader)
+    # - plugin :metadata (defines MetaAttribute and copies meta_attributes to subclasses)
+    # - plugin :presenter (defines Presenter)
+    def inherited(subclass)
+      config_class = Class.new(self::SeregaConfig)
+      config_class.serializer_class = subclass
+      subclass.const_set(:SeregaConfig, config_class)
+      subclass.instance_variable_set(:@config, subclass::SeregaConfig.new(config.opts))
+
+      attribute_class = Class.new(self::SeregaAttribute)
+      attribute_class.serializer_class = subclass
+      subclass.const_set(:SeregaAttribute, attribute_class)
+
+      map_class = Class.new(self::SeregaMap)
+      map_class.serializer_class = subclass
+      subclass.const_set(:SeregaMap, map_class)
+
+      map_point_class = Class.new(self::SeregaMapPoint)
+      map_point_class.serializer_class = subclass
+      subclass.const_set(:SeregaMapPoint, map_point_class)
+
+      object_serializer_class = Class.new(self::SeregaObjectSerializer)
+      object_serializer_class.serializer_class = subclass
+      subclass.const_set(:SeregaObjectSerializer, object_serializer_class)
+
+      check_attribute_params_class = Class.new(self::CheckAttributeParams)
+      check_attribute_params_class.serializer_class = subclass
+      subclass.const_set(:CheckAttributeParams, check_attribute_params_class)
+
+      check_initiate_params_class = Class.new(self::CheckInitiateParams)
+      check_initiate_params_class.serializer_class = subclass
+      subclass.const_set(:CheckInitiateParams, check_initiate_params_class)
+
+      check_serialize_params_class = Class.new(self::CheckSerializeParams)
+      check_serialize_params_class.serializer_class = subclass
+      subclass.const_set(:CheckSerializeParams, check_serialize_params_class)
+
+      # Assign same attributes
+      attributes.each_value do |attr|
+        subclass.attribute(attr.name, **attr.opts, &attr.block)
+      end
+
+      super
+    end
   end
 
   #
@@ -266,7 +274,7 @@ class Serega
     # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
     #
     def initialize(opts = nil)
-      @opts = (opts.nil? || opts.empty?) ? FROZEN_EMPTY_HASH : prepare_modifiers(opts)
+      @opts = (opts.nil? || opts.empty?) ? FROZEN_EMPTY_HASH : parse_modifiers(opts)
       self.class::CheckInitiateParams.new(@opts).validate if opts&.fetch(:check_initiate_params) { config.check_initiate_params }
     end
 
@@ -340,13 +348,29 @@ class Serega
       self.class.config
     end
 
-    def prepare_modifiers(opts)
-      opts.each_with_object({}) do |(key, value), obj|
-        value = SeregaUtils::ToHash.call(value) if (key == :only) || (key == :except) || (key == :with)
-        obj[key] = value
+    def parse_modifiers(opts)
+      result = {}
+
+      opts.each do |key, value|
+        value = parse_modifier(value) if (key == :only) || (key == :except) || (key == :with)
+        result[key] = value
       end
+
+      result
+    end
+
+    # Patched in:
+    # - plugin :string_modifiers (parses string modifiers differently)
+    def parse_modifier(value)
+      SeregaUtils::ToHash.call(value)
     end
 
+    # Patched in:
+    # - plugin :activerecord_preloads (loads defined :preloads to object)
+    # - plugin :batch (runs serialization of collected batches)
+    # - plugin :root (wraps result `{ root => result }`)
+    # - plugin :context_metadata (adds context metadata to final result)
+    # - plugin :metadata (adds metadata to final result)
     def serialize(object, opts)
       self.class::SeregaObjectSerializer
         .new(**opts, points: map)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.10.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-14 00:00:00.000000000 Z
+date: 2023-03-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -53,7 +53,11 @@ files:
 - lib/serega/plugins/batch/lib/validations/check_opt_batch.rb
 - lib/serega/plugins/context_metadata/context_metadata.rb
 - lib/serega/plugins/formatters/formatters.rb
-- lib/serega/plugins/hide_nil/hide_nil.rb
+- lib/serega/plugins/if/if.rb
+- lib/serega/plugins/if/validations/check_opt_if.rb
+- lib/serega/plugins/if/validations/check_opt_if_value.rb
+- lib/serega/plugins/if/validations/check_opt_unless.rb
+- lib/serega/plugins/if/validations/check_opt_unless_value.rb
 - lib/serega/plugins/metadata/meta_attribute.rb
 - lib/serega/plugins/metadata/metadata.rb
 - lib/serega/plugins/metadata/validations/check_block.rb
@@ -115,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.7
 signing_key: 
 specification_version: 4
 summary: JSON Serializer