grape 1.3.0 → 1.5.2

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

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 require 'set'
-require_relative 'dry_type_coercer'
+require_relative 'array_coercer'
 
 module Grape
   module Validations
     module Types
       # Takes the given array and converts it to a set. Every element of the set
       # is also coerced.
-      class SetCoercer < DryTypeCoercer
+      class SetCoercer < ArrayCoercer
+        register_collection Set
+
         def initialize(type, strict = false)
           super
 
-          @elem_coercer = PrimitiveCoercer.new(type.first, strict)
+          @coercer = nil
         end
 
         def call(value)
@@ -25,7 +27,7 @@ module Grape
 
         def coerce_elements(collection)
           collection.each_with_object(Set.new) do |elem, memo|
-            coerced_elem = @elem_coercer.call(elem)
+            coerced_elem = elem_coercer.call(elem)
 
             return coerced_elem if coerced_elem.is_a?(InvalidValue)
 

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

@@ -33,7 +33,7 @@ module Grape
         #   the coerced result, or an instance
         #   of {InvalidValue} if the value could not be coerced.
         def call(value)
-          return InvalidValue.new unless value.is_a? Array
+          return unless value.is_a? Array
 
           value =
             if @method

data/lib/grape/validations/types.rb

@@ -7,6 +7,7 @@ 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
@@ -21,10 +22,6 @@ module Grape
     # and {Grape::Dsl::Parameters#optional}. The main
     # entry point for this process is {Types.build_coercer}.
     module Types
-      # Instances of this class may be used as tokens to denote that
-      # a parameter value could not be coerced.
-      class InvalidValue; end
-
       # Types representing a single value, which are coerced.
       PRIMITIVES = [
         # Numerical
@@ -42,7 +39,6 @@ module Grape
         Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile,
         TrueClass,
         FalseClass
       ].freeze
@@ -54,8 +50,7 @@ module Grape
         Set
       ].freeze
 
-      # Types for which Grape provides special coercion
-      # and type-checking logic.
+      # Special custom types provided by Grape.
       SPECIAL = {
         JSON => Json,
         Array[JSON] => JsonArray,
@@ -130,7 +125,6 @@ module Grape
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1
       end
@@ -143,7 +137,11 @@ module Grape
       def self.collection_of_custom?(type)
         (type.is_a?(Array) || type.is_a?(Set)) &&
           type.length == 1 &&
-          custom?(type.first)
+          (custom?(type.first) || special?(type.first))
+      end
+
+      def self.map_special(type)
+        SPECIAL.fetch(type, type)
       end
     end
   end

data/lib/grape/validations/validator_factory.rb

@@ -8,7 +8,7 @@ module Grape
                                       options[:options],
                                       options[:required],
                                       options[:params_scope],
-                                      options[:opts])
+                                      **options[:opts])
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class AsValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @renamed_options = options
         super
       end

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

@@ -12,14 +12,15 @@ 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 [Hash] additional validation options
-      def initialize(attrs, options, required, scope, opts = {})
+      # @param opts [Array] additional validation options
+      def initialize(attrs, options, required, scope, *opts)
         @attrs = Array(attrs)
         @option = options
         @required = required
         @scope = scope
-        @fail_fast = opts[:fail_fast] || false
-        @allow_blank = opts[:allow_blank] || false
+        opts = opts.any? ? opts.shift : {}
+        @fail_fast = opts.fetch(:fail_fast, false)
+        @allow_blank = opts.fetch(:allow_blank, false)
       end
 
       # Validates a given request.
@@ -43,13 +44,12 @@ module Grape
         # there may be more than one error per field
         array_errors = []
 
-        attributes.each do |val, attr_name, empty_val|
+        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
-            if @required || val.respond_to?(:key?) && val.key?(attr_name)
-              validate_param!(attr_name, val)
-            end
+            validate_param!(attr_name, val) if @required || val.respond_to?(:key?) && val.key?(attr_name)
           rescue Grape::Exceptions::Validation => e
             array_errors << e
           end

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

@@ -17,7 +17,7 @@ module Grape
 
   module Validations
     class CoerceValidator < Base
-      def initialize(*_args)
+      def initialize(attrs, options, required, scope, **opts)
         super
 
         @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
@@ -36,7 +36,7 @@ module Grape
 
         new_value = coerce_value(params[attr_name])
 
-        raise validation_exception(attr_name) unless valid_type?(new_value)
+        raise validation_exception(attr_name, new_value.message) unless valid_type?(new_value)
 
         # Don't assign a value if it is identical. It fixes a problem with Hashie::Mash
         # which looses wrappers for hashes and arrays after reassigning values
@@ -47,7 +47,9 @@ module Grape
         #     h[:list] = list
         #     h
         #     => #<Hashie::Mash list=[1, 2, 3, 4]>
-        params[attr_name] = new_value unless params[attr_name] == new_value
+        return if params[attr_name].class == new_value.class && params[attr_name] == new_value
+
+        params[attr_name] = new_value
       end
 
       private
@@ -65,18 +67,9 @@ module Grape
       end
 
       def coerce_value(val)
-        # define default values for structures, the dry-types lib which is used
-        # for coercion doesn't accept nil as a value, so it would fail
-        if val.nil?
-          return []      if type == Array || type.is_a?(Array)
-          return Set.new if type == Set
-          return {}      if type == Hash
-        end
-
         converter.call(val)
-
       # Some custom types might fail, so it should be treated as an invalid value
-      rescue
+      rescue StandardError
         Types::InvalidValue.new
       end
 
@@ -87,8 +80,11 @@ module Grape
         @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
       end
 
-      def validation_exception(attr_name)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:coerce))
+      def validation_exception(attr_name, custom_msg = nil)
+        Grape::Exceptions::Validation.new(
+          params: [@scope.full_name(attr_name)],
+          message: custom_msg || message(:coerce)
+        )
       end
     end
   end

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

@@ -3,13 +3,12 @@
 module Grape
   module Validations
     class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         @default = options
         super
       end
 
       def validate_param!(attr_name, params)
-        return if params.key? attr_name
         params[attr_name] = if @default.is_a? Proc
                               @default.call
                             elsif @default.frozen? || !duplicatable?(@default)
@@ -22,9 +21,8 @@ module Grape
       def validate!(params)
         attrs = SingleAttributeIterator.new(self, @scope, params)
         attrs.each do |resource_params, attr_name|
-          if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
-            validate_param!(attr_name, resource_params)
-          end
+          next unless @scope.meets_dependency?(resource_params, params)
+          validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
         end
       end
 

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

@@ -6,8 +6,10 @@ module Grape
   module Validations
     class ExactlyOneOfValidator < MultipleParamsBase
       def validate_params!(params)
-        return if keys_in_common(params).length == 1
-        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one))
+        keys = keys_in_common(params)
+        return if keys.length == 1
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     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/multiple_params_base.rb

@@ -7,7 +7,8 @@ module Grape
         attributes = MultipleAttributesIterator.new(self, @scope, params)
         array_errors = []
 
-        attributes.each do |resource_params|
+        attributes.each do |resource_params, skip_value|
+          next if skip_value
           begin
             validate_params!(resource_params)
           rescue Grape::Exceptions::Validation => e

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

@@ -5,7 +5,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 =~ (options_key?(:value) ? @option[:value] : @option)) }
+        return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
         raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
       end
     end

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

@@ -3,7 +3,7 @@
 module Grape
   module Validations
     class ValuesValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
+      def initialize(attrs, options, required, scope, **opts)
         if options.is_a?(Hash)
           @excepts = options[:except]
           @values = options[:value]

data/lib/grape/version.rb

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

data/lib/grape.rb

@@ -12,6 +12,7 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/except'
@@ -20,7 +21,6 @@ require 'active_support/core_ext/hash/conversions'
 require 'active_support/dependencies/autoload'
 require 'active_support/notifications'
 require 'i18n'
-require 'thread'
 
 I18n.load_path << File.expand_path('../grape/locale/en.yml', __FILE__)
 
@@ -84,7 +84,6 @@ module Grape
     eager_autoload do
       autoload :DeepMergeableHash
       autoload :DeepSymbolizeHash
-      autoload :DeepHashWithIndifferentAccess
       autoload :Hash
     end
     module ActiveSupport
@@ -208,18 +207,19 @@ module Grape
     end
   end
 
-  module ServeFile
+  module ServeStream
     extend ::ActiveSupport::Autoload
     eager_autoload do
-      autoload :FileResponse
       autoload :FileBody
       autoload :SendfileResponse
+      autoload :StreamResponse
     end
   end
 end
 
 require 'grape/config'
-require 'grape/util/content_types'
+require 'grape/content_types'
+
 require 'grape/util/lazy_value'
 require 'grape/util/lazy_block'
 require 'grape/util/endpoint_configuration'

data/spec/grape/api/instance_spec.rb

@@ -51,4 +51,54 @@ describe Grape::API::Instance do
       expect(an_instance.top_level_setting.parent).to be_nil
     end
   end
+
+  context 'with multiple moutes' do
+    let(:first) do
+      Class.new(Grape::API::Instance) do
+        namespace(:some_namespace) do
+          route :any, '*path' do
+            error!('Not found! (1)', 404)
+          end
+        end
+      end
+    end
+    let(:second) do
+      Class.new(Grape::API::Instance) do
+        namespace(:another_namespace) do
+          route :any, '*path' do
+            error!('Not found! (2)', 404)
+          end
+        end
+      end
+    end
+    let(:root_api) do
+      first_instance = first
+      second_instance = second
+      Class.new(Grape::API) do
+        mount first_instance
+        mount first_instance
+        mount second_instance
+      end
+    end
+
+    it 'does not raise a FrozenError on first instance' do
+      expect { patch '/some_namespace/anything' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the first instance' do
+      patch '/some_namespace/anything'
+      expect(last_response.body).to eq 'Not found! (1)'
+    end
+
+    it 'does not raise a FrozenError on second instance' do
+      expect { get '/another_namespace/other' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the second instance' do
+      get '/another_namespace/foobar'
+      expect(last_response.body).to eq 'Not found! (2)'
+    end
+  end
 end

data/spec/grape/api_remount_spec.rb

@@ -340,19 +340,24 @@ describe Grape::API do
       context 'when the configuration is read within a namespace' do
         before do
           a_remounted_api.namespace 'api' do
+            params do
+              requires configuration[:required_param]
+            end
             get "/#{configuration[:path]}" do
               '10 votes'
             end
           end
-          root_api.mount a_remounted_api, with: { path: 'votes' }
-          root_api.mount a_remounted_api, with: { path: 'scores' }
+          root_api.mount a_remounted_api, with: { path: 'votes', required_param: 'param_key' }
+          root_api.mount a_remounted_api, with: { path: 'scores', required_param: 'param_key' }
         end
 
         it 'will use the dynamic configuration on all routes' do
-          get 'api/votes'
+          get 'api/votes', param_key: 'a'
           expect(last_response.body).to eql '10 votes'
-          get 'api/scores'
+          get 'api/scores', param_key: 'a'
           expect(last_response.body).to eql '10 votes'
+          get 'api/votes'
+          expect(last_response.status).to eq 400
         end
       end
 

data/spec/grape/api_spec.rb

@@ -816,6 +816,71 @@ XML
       end
     end
 
+    describe 'when hook behaviour is controlled by attributes on the route ' do
+      before do
+        subject.before do
+          error!('Access Denied', 401) unless route.options[:secret] == params[:secret]
+        end
+
+        subject.namespace 'example' do
+          before do
+            error!('Access Denied', 401) unless route.options[:namespace_secret] == params[:namespace_secret]
+          end
+
+          desc 'it gets with secret', secret: 'password'
+          get { status(params[:id] == '504' ? 200 : 404) }
+
+          desc 'it post with secret', secret: 'password', namespace_secret: 'namespace_password'
+          post {}
+        end
+      end
+
+      context 'when HTTP method is not defined' do
+        let(:response) { delete('/example') }
+
+        it 'responds with a 405 status' do
+          expect(response.status).to eql 405
+        end
+      end
+
+      context 'when HTTP method is defined with attribute' do
+        let(:response) { post('/example?secret=incorrect_password') }
+        it 'responds with the defined error in the before hook' do
+          expect(response.status).to eql 401
+        end
+      end
+
+      context 'when HTTP method is defined and the underlying before hook expectation is not met' do
+        let(:response) { post('/example?secret=password&namespace_secret=wrong_namespace_password') }
+        it 'ends up in the endpoint' do
+          expect(response.status).to eql 401
+        end
+      end
+
+      context 'when HTTP method is defined and everything is like the before hooks expect' do
+        let(:response) { post('/example?secret=password&namespace_secret=namespace_password') }
+        it 'ends up in the endpoint' do
+          expect(response.status).to eql 201
+        end
+      end
+
+      context 'when HEAD is called for the defined GET' do
+        let(:response) { head('/example?id=504') }
+
+        it 'responds with 401 because before expectations in before hooks are not met' do
+          expect(response.status).to eql 401
+        end
+      end
+
+      context 'when HEAD is called for the defined GET' do
+        let(:response) { head('/example?id=504&secret=password') }
+
+        it 'responds with 200 because before hooks are not called' do
+          expect(response.status).to eql 200
+        end
+      end
+    end
+
     context 'allows HEAD on a GET request that' do
       before do
         subject.get 'example' do
@@ -935,7 +1000,7 @@ XML
 
     it 'adds a before filter to current and child namespaces only' do
       subject.get '/' do
-        "root - #{@foo}"
+        "root - #{instance_variable_defined?(:@foo) ? @foo : nil}"
       end
       subject.namespace :blah do
         before { @foo = 'foo' }
@@ -1084,6 +1149,11 @@ XML
       expect(last_response.headers['Content-Type']).to eq('text/plain')
     end
 
+    it 'does not set Cache-Control' do
+      get '/foo'
+      expect(last_response.headers['Cache-Control']).to eq(nil)
+    end
+
     it 'sets content type for xml' do
       get '/foo.xml'
       expect(last_response.headers['Content-Type']).to eq('application/xml')
@@ -1530,6 +1600,11 @@ XML
       expect(subject.io).to receive(:write).with(message)
       subject.logger.info 'this will be logged'
     end
+
+    it 'does not unnecessarily retain duplicate setup blocks' do
+      subject.logger
+      expect { subject.logger }.to_not change(subject.instance_variable_get(:@setup), :size)
+    end
   end
 
   describe '.helpers' do
@@ -3677,12 +3752,13 @@ XML
       end
     end
     context ':serializable_hash' do
-      before(:each) do
-        class SerializableHashExample
-          def serializable_hash
-            { abc: 'def' }
-          end
+      class SerializableHashExample
+        def serializable_hash
+          { abc: 'def' }
         end
+      end
+
+      before(:each) do
         subject.format :serializable_hash
       end
       it 'instance' do