serega 0.42.0 → 0.50.0

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module If
-      #
-      # Validator for attribute :if_value option
-      #
-      # @private
-      class CheckOptIfValue
-        class << self
-          #
-          # Checks attribute :if_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?(:if_value)
-
-            check_usage_with_other_params(opts)
-            check_type(opts[:if_value])
-          end
-
-          private
-
-          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_type(value)
-            return if value.is_a?(Symbol)
-            raise SeregaError, must_be_callable unless value.respond_to?(:call)
-
-            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
-            raise SeregaError, signature_error unless valid_signature?(signature)
-          end
-
-          def must_be_callable
-            "Invalid attribute option :if_value. It must be a Symbol, a Proc or respond to :call"
-          end
-
-          def valid_signature?(signature)
-            case signature
-            when "0"      # no parameters
-              true
-            when "1"      # (value)
-              true
-            when "2"      # (value, context)
-              true
-            when "1_ctx"  # (value, :ctx)
-              true
-            when "2_ctx"  # (value, context, :ctx)
-              true
-            else
-              false
-            end
-          end
-
-          def signature_error
-            <<~ERROR.strip
-              Invalid attribute option :if_value parameters, valid parameters signatures:
-              - ()                     # no parameters
-              - (value)                # one positional parameter
-              - (value, context)       # two positional parameters
-              - (value, :ctx)          # one positional parameter and :ctx keyword
-              - (value, context, :ctx) # two positional parameters and :ctx keyword
-            ERROR
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module If
-      #
-      # Validator for attribute :unless option
-      #
-      # @private
-      class CheckOptUnless
-        class << self
-          #
-          # Checks attribute :unless 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)
-
-            check_type(opts[:unless])
-          end
-
-          private
-
-          def check_type(value)
-            return if value.is_a?(Symbol)
-            raise SeregaError, must_be_callable unless value.respond_to?(:call)
-
-            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
-            raise SeregaError, signature_error unless valid_signature?(signature)
-          end
-
-          def must_be_callable
-            "Invalid attribute option :unless. It must be a Symbol, a Proc or respond to :call"
-          end
-
-          def valid_signature?(signature)
-            case signature
-            when "0"      # no parameters
-              true
-            when "1"      # (object)
-              true
-            when "2"      # (object, context)
-              true
-            when "1_ctx"  # (object, :ctx)
-              true
-            when "2_ctx"  # (object, context, :ctx)
-              true
-            else
-              false
-            end
-          end
-
-          def signature_error
-            <<~ERROR.strip
-              Invalid attribute option :unless parameters, valid parameters signatures:
-              - ()                      # no parameters
-              - (object)                # one positional parameter
-              - (object, context)       # two positional parameters
-              - (object, :ctx)          # one positional parameter and :ctx keyword
-              - (object, context, :ctx) # two positional parameters and :ctx keyword
-            ERROR
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module If
-      #
-      # Validator for attribute :unless_value option
-      #
-      # @private
-      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_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_type(value)
-            return if value.is_a?(Symbol)
-            raise SeregaError, must_be_callable unless value.respond_to?(:call)
-
-            signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [:ctx])
-            raise SeregaError, signature_error unless valid_signature?(signature)
-          end
-
-          def must_be_callable
-            "Invalid attribute option :unless_value. It must be a Symbol, a Proc or respond to :call"
-          end
-
-          def valid_signature?(signature)
-            case signature
-            when "0"      # no parameters
-              true
-            when "1"      # (value)
-              true
-            when "2"      # (value, context)
-              true
-            when "1_ctx"  # (value, :ctx)
-              true
-            when "2_ctx"  # (value, context, :ctx)
-              true
-            else
-              false
-            end
-          end
-
-          def signature_error
-            <<~ERROR.strip
-              Invalid attribute option :unless_value parameters, valid parameters signatures:
-              - ()                     # no parameters
-              - (value)                # one positional parameter
-              - (value, context)       # two positional parameters
-              - (value, :ctx)          # one positional parameter and :ctx keyword
-              - (value, context, :ctx) # two positional parameters and :ctx keyword
-            ERROR
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute block parameter
-        #
-        # @private
-        class CheckBlock
-          class << self
-            #
-            # Checks block provided with attribute
-            # Block must have up to two arguments - object(s) and context.
-            #
-            # @example without arguments
-            #   metadata(:version) { CONSTANT_VERSION }
-            #
-            # @example with one argument
-            #   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[:pagy] }
-            #
-            # @param block [Proc] Block that returns serialized meta attribute value
-            #
-            # @raise [SeregaError] SeregaError that block has invalid arguments
-            #
-            # @return [void]
-            #
-            def call(block)
-              signature = SeregaUtils::MethodSignature.call(block, pos_limit: 2, keyword_args: [])
-              raise SeregaError, block_error unless %w[0 1 2].include?(signature)
-            end
-
-            private
-
-            def block_error
-              "Block can have maximum two parameters (object(s), context)"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # MetaAttribute `:const` option validator
-        #
-        # @private
-        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_hide_empty.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute :hide_empty option
-        #
-        # @private
-        class CheckOptHideEmpty
-          class << self
-            #
-            # Checks attribute :hide_empty option
-            #
-            # @param opts [Hash] Attribute options
-            #
-            # @raise [SeregaError] SeregaError that option has invalid value
-            #
-            # @return [void]
-            #
-            def call(opts)
-              return unless opts.key?(:hide_empty)
-
-              value = opts[:hide_empty]
-              return if value == true
-
-              raise SeregaError, "Invalid option :hide_empty => #{value.inspect}. Must be true"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute :hide_nil option
-        #
-        # @private
-        class CheckOptHideNil
-          class << self
-            #
-            # Checks attribute :hide_nil option
-            #
-            # @param opts [Hash] Attribute options
-            #
-            # @raise [SeregaError] SeregaError that option has invalid value
-            #
-            # @return [void]
-            #
-            def call(opts)
-              return unless opts.key?(:hide_nil)
-
-              value = opts[:hide_nil]
-              return if value == true
-
-              raise SeregaError, "Invalid option :hide_nil => #{value.inspect}. Must be true"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute :value option
-        #
-        # @private
-        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)
-
-              signature = SeregaUtils::MethodSignature.call(value, pos_limit: 2, keyword_args: [])
-
-              raise SeregaError, params_count_error unless %w[0 1 2].include?(signature)
-            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

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute options
-        #
-        # @private
-        class CheckOpts
-          class << self
-            #
-            # Validates meta_attribute options
-            # Checks used options are allowed and then checks options values.
-            #
-            # @param opts [Hash] Attribute options
-            # @param block [Proc] Attribute block
-            # @param allowed_keys [Array<Symbol>] Allowed options keys
-            #
-            # @raise [SeregaError] when attribute has invalid options
-            #
-            # @return [void]
-            #
-            def call(opts, block, allowed_keys)
-              check_allowed_options_keys(opts, allowed_keys)
-              check_each_opt(opts, block)
-              check_any_value_provided(opts, block)
-            end
-
-            private
-
-            def check_allowed_options_keys(opts, allowed_keys)
-              opts.each_key do |key|
-                next if allowed_keys.include?(key.to_sym)
-
-                allowed = allowed_keys.map(&:inspect).join(", ")
-                raise SeregaError, "Invalid option #{key.inspect}. Allowed options are: #{allowed}"
-              end
-            end
-
-            def check_each_opt(opts, block)
-              CheckOptHideEmpty.call(opts)
-              CheckOptHideNil.call(opts)
-              CheckOptValue.call(opts, block)
-              CheckOptConst.call(opts, block)
-            end
-
-            def check_any_value_provided(opts, block)
-              return if opts.key?(:const) || opts.key?(:value) || block
-
-              raise SeregaError, "Please provide block argument or add :value or :const option"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module Metadata
-      class MetaAttribute
-        #
-        # Validator for meta_attribute :path parameter
-        #
-        # @private
-        class CheckPath
-          # Regexp for valid path
-          FORMAT = /\A[\w~-]+\z/
-
-          private_constant :FORMAT
-
-          class << self
-            #
-            # Checks allowed characters.
-            # Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~".
-            #
-            # @param path [Array<String, Symbol>] Metadata attribute path names
-            #
-            # @raise [SeregaError] when metadata attribute name has invalid format
-            # @return [void]
-            #
-            def call(path)
-              path.each { |attr_name| check_name(attr_name) }
-            end
-
-            private
-
-            def check_name(name)
-              name = name.to_s
-
-              raise SeregaError, message(name) unless FORMAT.match?(name)
-            end
-
-            def message(name)
-              <<~MESSAGE.tr("\n", "")
-                Invalid metadata path #{name.inspect}.
-                 Allowed characters: "a-z", "A-Z", "0-9", "_", "-", "~"
-              MESSAGE
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin :string_modifiers
-    #
-    # Allows to specify modifiers as strings.
-    #
-    # Serialized attributes must be split with `,` and nested attributes can be defined inside brackets `(`, `)`.
-    #
-    # @example
-    #   PostSerializer.plugin :string_modifiers
-    #   PostSerializer.new(only: "id,user(id,username)").to_h(post)
-    #   PostSerializer.new(except: "user(username,email)").to_h(post)
-    #   PostSerializer.new(with: "user(email)").to_h(post)
-    #
-    #   # Modifiers can still be provided old way with nested hashes or arrays.
-    #   PostSerializer.new(with: {user: %i[email, username]}).to_h(post)
-    #
-    module StringModifiers
-      #
-      # Modifiers parser
-      #
-      # @private
-      class ParseStringModifiers
-        COMMA = ","
-        COMMA_CODEPOINT = COMMA.ord
-        LPAREN = "("
-        LPAREN_CODEPOINT = LPAREN.ord
-        RPAREN = ")"
-        RPAREN_CODEPOINT = RPAREN.ord
-        private_constant :COMMA, :LPAREN, :RPAREN, :COMMA_CODEPOINT, :LPAREN_CODEPOINT, :RPAREN_CODEPOINT
-
-        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)
-            result = {}
-            attribute_storage = result
-            path_stack = (fields.include?(LPAREN) || fields.include?(RPAREN)) ? [] : nil
-
-            start_index = 0
-            end_index = 0
-            fields.each_codepoint do |codepoint|
-              case codepoint
-              when COMMA_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-                start_index = end_index + 1
-              when LPAREN_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                if attribute
-                  attribute_storage = add_attribute(attribute_storage, attribute, {})
-                  path_stack.push(attribute)
-                end
-                start_index = end_index + 1
-              when RPAREN_CODEPOINT
-                attribute = extract_attribute(fields, start_index, end_index)
-                add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-                path_stack.pop
-                attribute_storage = dig?(result, path_stack)
-                start_index = end_index + 1
-              end
-
-              end_index += 1
-            end
-
-            attribute = extract_attribute(fields, start_index, end_index)
-            add_attribute(attribute_storage, attribute, FROZEN_EMPTY_HASH) if attribute
-
-            result
-          end
-
-          private
-
-          def extract_attribute(fields, start_index, end_index)
-            attribute = fields[start_index, end_index - start_index]
-            attribute.strip!
-            attribute.empty? ? nil : attribute.to_sym
-          end
-
-          def add_attribute(storage, attribute, nested_attributes = FROZEN_EMPTY_HASH)
-            storage[attribute] = nested_attributes
-          end
-
-          def dig?(hash, path)
-            return hash if !path || path.empty?
-
-            path.each do |point|
-              hash = hash[point]
-            end
-
-            hash
-          end
-        end
-      end
-    end
-  end
-end