grape 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7af0abe5fd1cb203ceda93732e74ded372552f7a859c6a3c6b847d1ac31c9c97
-  data.tar.gz: 103a38ad4d41eccbfef3240cd8b04fe17f2bc080a4265e4353b43076ce03fb15
+  metadata.gz: 1e8e622245d5871dfbaa651eac26abfd8bc4d36accd176f39fcc8ec09200cbe5
+  data.tar.gz: d92fe82ca78e6140bc98832671e682c2f090210e1ceaee907d9f3c4f812463b1
 SHA512:
-  metadata.gz: 8c8fb085cbaa5ea150e072a54e98546f4336966871225ae5587d70d115da62d420e1f67b2459f83c39c5d29717f311e93d09e0440dd4bf4a75d1f1cec7573022
-  data.tar.gz: c0f6eb027e3f43c309c59643ceb28c8f7d783466c0663f3b65e93be52a0c3148123110d9aa81dda842027ace7f0f319519b5cdc1fec7102d65811a84fbc2b2ed
+  metadata.gz: eed721c5ebd94fa07d2fa2a5420f0a943959890e85c71a941d4b1caede3605dbff836d4f42fabf0e15dec2a3bda944c7cd29988dcc1b1fd13eeea350c81a62de
+  data.tar.gz: ac951a0fbcd4d467ecf6f9b25f0d0d460a7cd132bb4ae708e2e0f55623ccc40d77809ca9c5663bde77c5d59708b264288a7592158340f1ca8336621007c8787b

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+### 1.6.1 (2021/12/28)
+
+#### Features
+
+* [#2196](https://github.com/ruby-grape/grape/pull/2196): Add support for `passwords_hashed` param for `digest_auth` - [@lHydra](https://github.com/lhydra).
+* [#2208](https://github.com/ruby-grape/grape/pull/2208): Added Rails 7 support - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2206](https://github.com/ruby-grape/grape/pull/2206): Require main active_support lib before any of its extension definitions - [@annih](https://github.com/Annih).
+* [#2193](https://github.com/ruby-grape/grape/pull/2193): Fixed the broken ruby-head NoMethodError spec - [@Jack12816](https://github.com/Jack12816).
+* [#2192](https://github.com/ruby-grape/grape/pull/2192): Memoize the result of Grape::Middleware::Base#response - [@Jack12816](https://github.com/Jack12816).
+* [#2200](https://github.com/ruby-grape/grape/pull/2200): Add validators module to all validators - [@ericproulx](https://github.com/ericproulx).
+* [#2202](https://github.com/ruby-grape/grape/pull/2202): Fix random mock spec error - [@ericproulx](https://github.com/ericproulx).
+* [#2203](https://github.com/ruby-grape/grape/pull/2203): Add rubocop-rspec - [@ericproulx](https://github.com/ericproulx).
+* [#2207](https://github.com/ruby-grape/grape/pull/2207): Autoload Validations/Validators - [@ericproulx](https://github.com/ericproulx).
+* [#2209](https://github.com/ruby-grape/grape/pull/2209): Autoload Validations/Types - [@ericproulx](https://github.com/ericproulx).
+
 ### 1.6.0 (2021/10/04)
 
 #### Features

data/CONTRIBUTING.md

@@ -35,6 +35,7 @@ bundle exec rake
 Run tests against all supported versions of Rails.
 
 ```
+gem install appraisal
 appraisal install
 appraisal rake spec
 ```

data/README.md

@@ -158,7 +158,7 @@ content negotiation, versioning and much more.
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, **1.6.0**.
+You're reading the documentation for the stable release of Grape, **1.6.1**.
 Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
 
 ## Project Resources
@@ -3296,12 +3296,20 @@ http_basic do |username, password|
 end
 ```
 
+Digest auth supports clear-text passwords and password hashes.
+
 ```ruby
 http_digest({ realm: 'Test Api', opaque: 'app secret' }) do |username|
   # lookup the user's password here
 end
 ```
 
+```ruby
+http_digest(realm: { realm: 'Test Api', opaque: 'app secret', passwords_hashed: true }) do |username|
+  # lookup the user's password hash here
+end
+```
+
 ### Register custom middleware for authentication
 
 Grape can use custom Middleware for authentication. How to implement these

data/lib/grape/api.rb

@@ -10,6 +10,18 @@ module Grape
     # Class methods that we want to call on the API rather than on the API object
     NON_OVERRIDABLE = (Class.new.methods + %i[call call! configuration compile! inherited]).freeze
 
+    class Boolean
+      def self.build(val)
+        return nil if val != true && val != false
+
+        new
+      end
+    end
+
+    class Instance
+      Boolean = Grape::API::Boolean
+    end
+
     class << self
       attr_accessor :base_instance, :instances
 

data/lib/grape/dry_types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module Grape
+  module DryTypes
+    # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
+    # a container in this case. Check documentation for more information
+    # https://dry-rb.org/gems/dry-types/1.2/getting-started/
+    include Dry.Types()
+  end
+end

data/lib/grape/dsl/headers.rb

@@ -3,8 +3,11 @@
 module Grape
   module DSL
     module Headers
-      # Set an individual header or retrieve
-      # all headers that have been set.
+      # This method has four responsibilities:
+      # 1. Set a specifc header value by key
+      # 2. Retrieve a specifc header value by key
+      # 3. Retrieve all headers that have been set
+      # 4. Delete a specifc header key-value pair
       def header(key = nil, val = nil)
         if key
           val ? header[key.to_s] = val : header.delete(key.to_s)

data/lib/grape/dsl/helpers.rb

@@ -68,7 +68,7 @@ module Grape
         def define_boolean_in_mod(mod)
           return if defined? mod::Boolean
 
-          mod.const_set('Boolean', Grape::API::Boolean)
+          mod.const_set(:Boolean, Grape::API::Boolean)
         end
 
         def inject_api_helpers_to_mod(mod, &block)

data/lib/grape/middleware/auth/dsl.rb

@@ -32,7 +32,13 @@ module Grape
 
           def http_digest(options = {}, &block)
             options[:realm] ||= 'API Authorization'
-            options[:opaque] ||= 'secret'
+
+            if options[:realm].respond_to?(:values_at)
+              options[:realm][:opaque] ||= 'secret'
+            else
+              options[:opaque] ||= 'secret'
+            end
+
             auth :http_digest, options, &block
           end
         end

data/lib/grape/middleware/base.rb

@@ -60,7 +60,7 @@ module Grape
       def response
         return @app_response if @app_response.is_a?(Rack::Response)
 
-        Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
+        @app_response = Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
       def content_type_for(format)

data/lib/grape/util/json.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Grape
   if Object.const_defined? :MultiJson
     Json = ::MultiJson

data/lib/grape/util/strict_hash_configuration.rb

@@ -65,7 +65,7 @@ module Grape
             end
           end
 
-          define_method 'to_hash' do
+          define_method :to_hash do
             merge_hash = {}
             setting_name.each_key { |k| merge_hash[k] = send("#{k}_context").to_hash }
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

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

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry-types'
-
-module DryTypes
-  # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
-  # a container in this case. Check documentation for more information
-  # https://dry-rb.org/gems/dry-types/1.2/getting-started/
-  include Dry.Types()
-end
-
 module Grape
   module Validations
     module Types
@@ -52,7 +43,7 @@ module Grape
         def initialize(type, strict = false)
           @type = type
           @strict = strict
-          @scope = strict ? DryTypes::Strict : DryTypes::Params
+          @scope = strict ? Grape::DryTypes::Strict : Grape::DryTypes::Params
         end
 
         # Coerces the given value to a type which was specified during

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Grape
   module Validations
     module Types

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types
@@ -10,16 +8,16 @@ module Grape
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
-          Grape::API::Boolean => DryTypes::Params::Bool,
-          BigDecimal => DryTypes::Params::Decimal,
+          Grape::API::Boolean => Grape::DryTypes::Params::Bool,
+          BigDecimal => Grape::DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String => DryTypes::Coercible::String
+          String => Grape::DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
-          Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal => DryTypes::Strict::Decimal
+          Grape::API::Boolean => Grape::DryTypes::Strict::Bool,
+          BigDecimal => Grape::DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'array_coercer'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'types/build_coercer'
-require_relative 'types/custom_type_coercer'
-require_relative 'types/custom_type_collection_coercer'
-require_relative 'types/multiple_type_coercer'
-require_relative 'types/variant_collection_coercer'
-require_relative 'types/json'
-require_relative 'types/file'
-require_relative 'types/invalid_value'
-
 module Grape
   module Validations
     # Module for code related to grape's system for
@@ -143,6 +134,89 @@ module Grape
       def self.map_special(type)
         SPECIAL.fetch(type, type)
       end
+
+      # Chooses the best coercer for the given type. For example, if the type
+      # is Integer, it will return a coercer which will be able to coerce a value
+      # to the integer.
+      #
+      # There are a few very special coercers which might be returned.
+      #
+      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
+      # the given type implies values in an array with different types.
+      # For example, +[Integer, String]+ allows integer and string values in
+      # an array.
+      #
+      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
+      # a method is specified by a user with +coerce_with+ option or the user
+      # specifies a custom type which implements requirments of
+      # +Grape::Types::CustomTypeCoercer+.
+      #
+      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
+      # previous one, but it expects an array or set of values having a custom
+      # type implemented by the user.
+      #
+      # There is also a group of custom types implemented by Grape, check
+      # +Grape::Validations::Types::SPECIAL+ to get the full list.
+      #
+      # @param type [Class] the type to which input strings
+      #   should be coerced
+      # @param method [Class,#call] the coercion method to use
+      # @return [Object] object to be used
+      #   for coercion and type validation
+      def self.build_coercer(type, method: nil, strict: false)
+        cache_instance(type, method, strict) do
+          create_coercer_instance(type, method, strict)
+        end
+      end
+
+      def self.create_coercer_instance(type, method, strict)
+        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
+        type = Types.map_special(type)
+
+        # Use a special coercer for multiply-typed parameters.
+        if Types.multiple?(type)
+          MultipleTypeCoercer.new(type, method)
+
+          # Use a special coercer for custom types and coercion methods.
+        elsif method || Types.custom?(type)
+          CustomTypeCoercer.new(type, method)
+
+          # Special coercer for collections of types that implement a parse method.
+          # CustomTypeCoercer (above) already handles such types when an explicit coercion
+          # method is supplied.
+        elsif Types.collection_of_custom?(type)
+          Types::CustomTypeCollectionCoercer.new(
+            Types.map_special(type.first), type.is_a?(Set)
+          )
+        else
+          DryTypeCoercer.coercer_instance_for(type, strict)
+        end
+      end
+
+      def self.cache_instance(type, method, strict, &_block)
+        key = cache_key(type, method, strict)
+
+        return @__cache[key] if @__cache.key?(key)
+
+        instance = yield
+
+        @__cache_write_lock.synchronize do
+          @__cache[key] = instance
+        end
+
+        instance
+      end
+
+      def self.cache_key(type, method, strict)
+        [type, method, strict].each_with_object(+'_') do |val, memo|
+          next if val.nil?
+
+          memo << '_' << val.to_s
+        end
+      end
+
+      instance_variable_set(:@__cache,            {})
+      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllOrNoneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.empty? || keys.length == all_keys.length
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllowBlankValidator < Base
+        def validate_param!(attr_name, params)
+          return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
+
+          value = params[attr_name]
+          value = value.strip if value.respond_to?(:strip)
+
+          return if value == false || value.present?
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AsValidator < Base
+        # We use a validator for renaming parameters. This is just a marker for
+        # the parameter scope to handle the renaming. No actual validation
+        # happens here.
+        def validate_param!(*); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AtLeastOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          return unless keys_in_common(params).empty?
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+        end
+      end
+    end
+  end
+end

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

@@ -2,91 +2,93 @@
 
 module Grape
   module Validations
-    class Base
-      attr_reader :attrs
+    module Validators
+      class Base
+        attr_reader :attrs
 
-      # Creates a new Validator from options specified
-      # by a +requires+ or +optional+ directive during
-      # parameter definition.
-      # @param attrs [Array] names of attributes to which the Validator applies
-      # @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)
-        @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)
-      end
+        # Creates a new Validator from options specified
+        # by a +requires+ or +optional+ directive during
+        # parameter definition.
+        # @param attrs [Array] names of attributes to which the Validator applies
+        # @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)
+          @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)
+        end
 
-      # Validates a given request.
-      # @note Override #validate! unless you need to access the entire request.
-      # @param request [Grape::Request] the request currently being handled
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate(request)
-        return unless @scope.should_validate?(request.params)
+        # Validates a given request.
+        # @note Override #validate! unless you need to access the entire request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate(request)
+          return unless @scope.should_validate?(request.params)
 
-        validate!(request.params)
-      end
+          validate!(request.params)
+        end
 
-      # Validates a given parameter hash.
-      # @note Override #validate if you need to access the entire request.
-      # @param params [Hash] parameters to validate
-      # @raise [Grape::Exceptions::Validation] if validation failed
-      # @return [void]
-      def validate!(params)
-        attributes = SingleAttributeIterator.new(self, @scope, params)
-        # we collect errors inside array because
-        # there may be more than one error per field
-        array_errors = []
+        # Validates a given parameter hash.
+        # @note Override #validate if you need to access the entire request.
+        # @param params [Hash] parameters to validate
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate!(params)
+          attributes = SingleAttributeIterator.new(self, @scope, params)
+          # we collect errors inside array because
+          # there may be more than one error per field
+          array_errors = []
 
-        attributes.each do |val, attr_name, empty_val, skip_value|
-          next if skip_value
-          next if !@scope.required? && empty_val
-          next unless @scope.meets_dependency?(val, params)
+          attributes.each do |val, attr_name, empty_val, skip_value|
+            next if skip_value
+            next if !@scope.required? && empty_val
+            next unless @scope.meets_dependency?(val, params)
 
-          begin
-            validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
+            begin
+              validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
-        end
 
-        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
-      end
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
+        end
 
-      def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/')
-        ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        ret.tr!('-', '_')
-        ret.downcase!
-        File.basename(ret, '_validator')
-      end
+        def self.convert_to_short_name(klass)
+          ret = klass.name.gsub(/::/, '/')
+          ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          ret.tr!('-', '_')
+          ret.downcase!
+          File.basename(ret, '_validator')
+        end
 
-      def self.inherited(klass)
-        return unless klass.name.present?
+        def self.inherited(klass)
+          return unless klass.name.present?
 
-        Validations.register_validator(convert_to_short_name(klass), klass)
-      end
+          Validations.register_validator(convert_to_short_name(klass), klass)
+        end
 
-      def message(default_key = nil)
-        options = instance_variable_get(:@option)
-        options_key?(:message) ? options[:message] : default_key
-      end
+        def message(default_key = nil)
+          options = instance_variable_get(:@option)
+          options_key?(:message) ? options[:message] : default_key
+        end
 
-      def options_key?(key, options = nil)
-        options = instance_variable_get(:@option) if options.nil?
-        options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
-      end
+        def options_key?(key, options = nil)
+          options = instance_variable_get(:@option) if options.nil?
+          options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+        end
 
-      def fail_fast?
-        @fail_fast
+        def fail_fast?
+          @fail_fast
+        end
       end
     end
   end