grape 2.2.0 → 2.3.0

data/lib/grape/util/registry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Registry
+      def register(klass)
+        short_name = build_short_name(klass)
+        return if short_name.nil?
+
+        warn "#{short_name} is already registered with class #{klass}" if registry.key?(short_name)
+        registry[short_name] = klass
+      end
+
+      private
+
+      def build_short_name(klass)
+        return if klass.name.blank?
+
+        klass.name.demodulize.underscore
+      end
+
+      def registry
+        @registry ||= {}.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/grape/validations/contract_scope.rb

@@ -23,49 +23,12 @@ module Grape
         api.namespace_stackable(:contract_key_map, key_map)
 
         validator_options = {
-          validator_class: Validator,
-          opts: { schema: contract }
+          validator_class: Grape::Validations.require_validator(:contract_scope),
+          opts: { schema: contract, fail_fast: false }
         }
 
         api.namespace_stackable(:validations, validator_options)
       end
-
-      class Validator
-        attr_reader :schema
-
-        def initialize(*_args, schema:)
-          @schema = schema
-        end
-
-        # Validates a given request.
-        # @param request [Grape::Request] the request currently being handled
-        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
-        # @return [void]
-        def validate(request)
-          res = schema.call(request.params)
-
-          if res.success?
-            request.params.deep_merge!(res.to_h)
-            return
-          end
-
-          errors = []
-
-          res.errors.messages.each do |message|
-            full_name = message.path.first.to_s
-
-            full_name += "[#{message.path[1..].join('][')}]" if message.path.size > 1
-
-            errors << Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
-          end
-
-          raise Grape::Exceptions::ValidationArrayErrors.new(errors)
-        end
-
-        def fail_fast?
-          false
-        end
-      end
     end
   end
 end

data/lib/grape/validations/params_scope.rb

@@ -174,16 +174,12 @@ module Grape
 
       # Adds a parameter declaration to our list of validations.
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
-      def push_declared_params(attrs, **opts)
-        opts = opts.merge(declared_params_scope: self) unless opts.key?(:declared_params_scope)
-        if lateral?
-          @parent.push_declared_params(attrs, **opts)
-        else
-          push_renamed_param(full_path + [attrs.first], opts[:as]) \
-            if opts && opts[:as]
+      def push_declared_params(attrs, opts = {})
+        opts[:declared_params_scope] = self unless opts.key?(:declared_params_scope)
+        return @parent.push_declared_params(attrs, opts) if lateral?
 
-          @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
-        end
+        push_renamed_param(full_path + [attrs.first], opts[:as]) if opts[:as]
+        @declared_params.concat(attrs.map { |attr| ::Grape::Validations::ParamsScope::Attr.new(attr, opts[:declared_params_scope]) })
       end
 
       # Get the full path of the parameter scope in the hierarchy.
@@ -490,7 +486,7 @@ module Grape
       def validate_value_coercion(coerce_type, *values_list)
         return unless coerce_type
 
-        coerce_type = coerce_type.first if coerce_type.is_a?(Array)
+        coerce_type = coerce_type.first if coerce_type.is_a?(Enumerable)
         values_list.each do |values|
           next if !values || values.is_a?(Proc)
 
@@ -529,7 +525,7 @@ module Grape
       def validates_presence(validations, attrs, doc, opts)
         return unless validations.key?(:presence) && validations[:presence]
 
-        validate(:presence, validations.delete(:presence), attrs, doc, opts)
+        validate('presence', validations.delete(:presence), attrs, doc, opts)
         validations.delete(:message) if validations.key?(:message)
       end
     end

data/lib/grape/validations/types/dry_type_coercer.rb

@@ -22,16 +22,20 @@ module Grape
           #    collection_coercer_for(Array)
           #    #=> Grape::Validations::Types::ArrayCoercer
           def collection_coercer_for(type)
-            Grape::Validations::Types.const_get(:"#{type.name.camelize}Coercer")
+            case type
+            when Array
+              ArrayCoercer
+            when Set
+              SetCoercer
+            else
+              raise ArgumentError, "Unknown type: #{type}"
+            end
           end
 
           # Returns an instance of a coercer for a given type
           def coercer_instance_for(type, strict = false)
-            return PrimitiveCoercer.new(type, strict) if type.instance_of?(Class)
-
-            # in case of a collection (Array[Integer]) the type is an instance of a collection,
-            # so we need to figure out the actual type
-            collection_coercer_for(type.class).new(type, strict)
+            klass = type.instance_of?(Class) ? PrimitiveCoercer : collection_coercer_for(type)
+            klass.new(type, strict)
           end
         end
 

data/lib/grape/validations/validator_factory.rb

@@ -3,12 +3,12 @@
 module Grape
   module Validations
     class ValidatorFactory
-      def self.create_validator(**options)
+      def self.create_validator(options)
         options[:validator_class].new(options[:attributes],
                                       options[:options],
                                       options[:required],
                                       options[:params_scope],
-                                      **options[:opts])
+                                      options[:opts])
       end
     end
   end

data/lib/grape/validations/validators/allow_blank_validator.rb

@@ -8,7 +8,7 @@ module Grape
           return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
 
           value = params[attr_name]
-          value = value.strip if value.respond_to?(:strip)
+          value = value.scrub if value.respond_to?(:scrub)
 
           return if value == false || value.present?
 

data/lib/grape/validations/validators/base.rb

@@ -13,15 +13,14 @@ module Grape
         # @param options [Object] implementation-dependent Validator options
         # @param required [Boolean] attribute(s) are required or optional
         # @param scope [ParamsScope] parent scope for this Validator
-        # @param opts [Array] additional validation options
-        def initialize(attrs, options, required, scope, *opts)
+        # @param opts [Hash] additional validation options
+        def initialize(attrs, options, required, scope, opts)
           @attrs = Array(attrs)
           @option = options
           @required = required
           @scope = scope
-          opts = opts.any? ? opts.shift : {}
-          @fail_fast = opts.fetch(:fail_fast, false)
-          @allow_blank = opts.fetch(:allow_blank, false)
+          @fail_fast = opts[:fail_fast]
+          @allow_blank = opts[:allow_blank]
         end
 
         # Validates a given request.
@@ -60,10 +59,7 @@ module Grape
 
         def self.inherited(klass)
           super
-          return if klass.name.blank?
-
-          short_validator_name = klass.name.demodulize.underscore.delete_suffix('_validator')
-          Validations.register_validator(short_validator_name, klass)
+          Validations.register(klass)
         end
 
         def message(default_key = nil)

data/lib/grape/validations/validators/coerce_validator.rb

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Validators
       class CoerceValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        def initialize(attrs, options, required, scope, opts)
           super
 
           @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)

data/lib/grape/validations/validators/contract_scope_validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ContractScopeValidator < Base
+        attr_reader :schema
+
+        def initialize(_attrs, _options, _required, _scope, opts)
+          super
+          @schema = opts.fetch(:schema)
+        end
+
+        # Validates a given request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
+        # @return [void]
+        def validate(request)
+          res = schema.call(request.params)
+
+          if res.success?
+            request.params.deep_merge!(res.to_h)
+            return
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(build_errors_from_messages(res.errors.messages))
+        end
+
+        private
+
+        def build_errors_from_messages(messages)
+          messages.map do |message|
+            full_name = message.path.first.to_s
+            full_name << "[#{message.path[1..].join('][')}]" if message.path.size > 1
+            Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/default_validator.rb

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Validators
       class DefaultValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        def initialize(attrs, options, required, scope, opts = {})
           @default = options
           super
         end

data/lib/grape/validations/validators/except_values_validator.rb

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Validators
       class ExceptValuesValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        def initialize(attrs, options, required, scope, opts)
           @except = options.is_a?(Hash) ? options[:value] : options
           super
         end

data/lib/grape/validations/validators/length_validator.rb

@@ -4,7 +4,7 @@ module Grape
   module Validations
     module Validators
       class LengthValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
+        def initialize(attrs, options, required, scope, opts)
           @min = options[:min]
           @max = options[:max]
           @is = options[:is]

data/lib/grape/validations/validators/regexp_validator.rb

@@ -6,7 +6,7 @@ module Grape
       class RegexpValidator < Base
         def validate_param!(attr_name, params)
           return unless params.respond_to?(:key?) && params.key?(attr_name)
-          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.scrub.match?((options_key?(:value) ? @option[:value] : @option)) }
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
         end

data/lib/grape/validations/validators/values_validator.rb

@@ -4,23 +4,8 @@ module Grape
   module Validations
     module Validators
       class ValuesValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
-          if options.is_a?(Hash)
-            @excepts = options[:except]
-            @values = options[:value]
-            @proc = options[:proc]
-
-            Grape.deprecator.warn('The values validator except option is deprecated. Use the except validator instead.') if @excepts
-
-            raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
-
-            Grape.deprecator.warn('The values validator proc option is deprecated. The lambda expression can now be assigned directly to values.') if @proc
-          else
-            @excepts = nil
-            @values = nil
-            @proc = nil
-            @values = options
-          end
+        def initialize(attrs, options, required, scope, opts)
+          @values = options.is_a?(Hash) ? options[:value] : options
           super
         end
 
@@ -31,57 +16,34 @@ module Grape
 
           return if val.nil? && !required_for_root_scope?
 
+          val = val.scrub if val.respond_to?(:scrub)
+
           # don't forget that +false.blank?+ is true
           return if val != false && val.blank? && @allow_blank
 
-          param_array = val.nil? ? [nil] : Array.wrap(val)
-
-          raise validation_exception(attr_name, except_message) \
-          unless check_excepts(param_array)
-
-          raise validation_exception(attr_name, message(:values)) \
-          unless check_values(param_array, attr_name)
+          return if check_values?(val, attr_name)
 
-          raise validation_exception(attr_name, message(:values)) \
-            if @proc && !validate_proc(@proc, param_array)
+          raise Grape::Exceptions::Validation.new(
+            params: [@scope.full_name(attr_name)],
+            message: message(:values)
+          )
         end
 
         private
 
-        def check_values(param_array, attr_name)
+        def check_values?(val, attr_name)
           values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
           return true if values.nil?
 
+          param_array = val.nil? ? [nil] : Array.wrap(val)
+          return param_array.all? { |param| values.include?(param) } unless values.is_a?(Proc)
+
           begin
-            return param_array.all? { |param| values.call(param) } if values.is_a? Proc
+            param_array.all? { |param| values.call(param) }
           rescue StandardError => e
             warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
-            return false
+            false
           end
-          param_array.all? { |param| values.include?(param) }
-        end
-
-        def check_excepts(param_array)
-          excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
-          return true if excepts.nil?
-
-          param_array.none? { |param| excepts.include?(param) }
-        end
-
-        def validate_proc(proc, param_array)
-          case proc.arity
-          when 0
-            param_array.all? { |_param| proc.call }
-          when 1
-            param_array.all? { |param| proc.call(param) }
-          else
-            raise ArgumentError, 'proc arity must be 0 or 1'
-          end
-        end
-
-        def except_message
-          options = instance_variable_get(:@option)
-          options_key?(:except_message) ? options[:except_message] : message(:except_values)
         end
 
         def required_for_root_scope?
@@ -92,10 +54,6 @@ module Grape
 
           scope.root?
         end
-
-        def validation_exception(attr_name, message)
-          Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
-        end
       end
     end
   end

data/lib/grape/validations.rb

@@ -2,29 +2,20 @@
 
 module Grape
   module Validations
+    extend Grape::Util::Registry
+
     module_function
 
-    def validators
-      @validators ||= {}
-    end
+    def require_validator(short_name)
+      raise Grape::Exceptions::UnknownValidator, short_name unless registry.key?(short_name)
 
-    # Register a new validator, so it can be used to validate parameters.
-    # @param short_name [String] all lower-case, no spaces
-    # @param klass [Class] the validator class. Should inherit from
-    #   Grape::Validations::Validators::Base.
-    def register_validator(short_name, klass)
-      validators[short_name] = klass
+      registry[short_name]
     end
 
-    def deregister_validator(short_name)
-      validators.delete(short_name)
-    end
+    def build_short_name(klass)
+      return if klass.name.blank?
 
-    def require_validator(short_name)
-      str_name = short_name.to_s
-      validators.fetch(str_name) { Grape::Validations::Validators.const_get(:"#{str_name.camelize}Validator") }
-    rescue NameError
-      raise Grape::Exceptions::UnknownValidator, short_name
+      klass.name.demodulize.underscore.delete_suffix('_validator')
     end
   end
 end

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '2.2.0'
+  VERSION = '2.3.0'
 end

data/lib/grape.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'active_support'
 require 'active_support/concern'
 require 'active_support/configurable'
@@ -33,7 +34,6 @@ require 'date'
 require 'dry-types'
 require 'forwardable'
 require 'json'
-require 'logger'
 require 'mustermann/grape'
 require 'pathname'
 require 'rack'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Michael Bleigh
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-14 00:00:00.000000000 Z
+date: 2025-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -120,6 +119,8 @@ files:
 - lib/grape/error_formatter.rb
 - lib/grape/error_formatter/base.rb
 - lib/grape/error_formatter/json.rb
+- lib/grape/error_formatter/jsonapi.rb
+- lib/grape/error_formatter/serializable_hash.rb
 - lib/grape/error_formatter/txt.rb
 - lib/grape/error_formatter/xml.rb
 - lib/grape/exceptions/base.rb
@@ -149,6 +150,7 @@ files:
 - lib/grape/extensions/hash.rb
 - lib/grape/extensions/hashie/mash.rb
 - lib/grape/formatter.rb
+- lib/grape/formatter/base.rb
 - lib/grape/formatter/json.rb
 - lib/grape/formatter/serializable_hash.rb
 - lib/grape/formatter/txt.rb
@@ -169,13 +171,15 @@ files:
 - lib/grape/middleware/stack.rb
 - lib/grape/middleware/versioner.rb
 - lib/grape/middleware/versioner/accept_version_header.rb
+- lib/grape/middleware/versioner/base.rb
 - lib/grape/middleware/versioner/header.rb
 - lib/grape/middleware/versioner/param.rb
 - lib/grape/middleware/versioner/path.rb
-- lib/grape/middleware/versioner_helpers.rb
 - lib/grape/namespace.rb
 - lib/grape/parser.rb
+- lib/grape/parser/base.rb
 - lib/grape/parser/json.rb
+- lib/grape/parser/jsonapi.rb
 - lib/grape/parser/xml.rb
 - lib/grape/path.rb
 - lib/grape/presenters/presenter.rb
@@ -203,6 +207,7 @@ files:
 - lib/grape/util/lazy/value_enumerable.rb
 - lib/grape/util/lazy/value_hash.rb
 - lib/grape/util/media_type.rb
+- lib/grape/util/registry.rb
 - lib/grape/util/reverse_stackable_values.rb
 - lib/grape/util/stackable_values.rb
 - lib/grape/util/strict_hash_configuration.rb
@@ -215,7 +220,6 @@ files:
 - lib/grape/validations/single_attribute_iterator.rb
 - lib/grape/validations/types.rb
 - lib/grape/validations/types/array_coercer.rb
-- lib/grape/validations/types/build_coercer.rb
 - lib/grape/validations/types/custom_type_coercer.rb
 - lib/grape/validations/types/custom_type_collection_coercer.rb
 - lib/grape/validations/types/dry_type_coercer.rb
@@ -233,6 +237,7 @@ files:
 - lib/grape/validations/validators/at_least_one_of_validator.rb
 - lib/grape/validations/validators/base.rb
 - lib/grape/validations/validators/coerce_validator.rb
+- lib/grape/validations/validators/contract_scope_validator.rb
 - lib/grape/validations/validators/default_validator.rb
 - lib/grape/validations/validators/exactly_one_of_validator.rb
 - lib/grape/validations/validators/except_values_validator.rb
@@ -250,11 +255,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/ruby-grape/grape/issues
-  changelog_uri: https://github.com/ruby-grape/grape/blob/v2.2.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/grape/2.2.0
-  source_code_uri: https://github.com/ruby-grape/grape/tree/v2.2.0
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v2.3.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/2.3.0
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v2.3.0
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -269,8 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.13
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A simple Ruby framework for building REST-like APIs.
 test_files: []

data/lib/grape/middleware/versioner_helpers.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Middleware
-    module VersionerHelpers
-      DEFAULT_PATTERN = /.*/i.freeze
-      DEFAULT_PARAMETER = 'apiver'
-
-      def default_options
-        {
-          versions: nil,
-          prefix: nil,
-          mount_path: nil,
-          pattern: DEFAULT_PATTERN,
-          version_options: {
-            strict: false,
-            cascade: true,
-            parameter: DEFAULT_PARAMETER
-          }
-        }
-      end
-
-      def versions
-        options[:versions]
-      end
-
-      def prefix
-        options[:prefix]
-      end
-
-      def mount_path
-        options[:mount_path]
-      end
-
-      def pattern
-        options[:pattern]
-      end
-
-      def version_options
-        options[:version_options]
-      end
-
-      def strict?
-        version_options[:strict]
-      end
-
-      # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-      # of routes (see Grape::Router) for more information). To prevent
-      # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
-      def cascade?
-        version_options[:cascade]
-      end
-
-      def parameter_key
-        version_options[:parameter]
-      end
-
-      def vendor
-        version_options[:vendor]
-      end
-
-      def error_headers
-        cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
-      end
-
-      def potential_version_match?(potential_version)
-        versions.blank? || versions.any? { |v| v.to_s == potential_version }
-      end
-
-      def version_not_found!
-        throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
-      end
-    end
-  end
-end