grape 1.3.1 → 1.5.1

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

@@ -11,10 +11,10 @@ module Grape
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
+          BigDecimal          => DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String              => DryTypes::Coercible::String,
-          BigDecimal          => DryTypes::Coercible::Decimal
+          String              => DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
@@ -36,8 +36,7 @@ module Grape
 
         def call(val)
           return InvalidValue.new if reject?(val)
-          return nil if val.nil?
-          return '' if val == ''
+          return nil if val.nil? || treat_as_nil?(val)
 
           super
         end
@@ -46,7 +45,7 @@ module Grape
 
         attr_reader :type
 
-        # This method maintaine logic which was defined by Virtus. For example,
+        # This method maintains logic which was defined by Virtus. For example,
         # dry-types is ok to convert an array or a hash to a string, it is supported,
         # but Virtus wouldn't accept it. So, this method only exists to not introduce
         # breaking changes.
@@ -55,6 +54,13 @@ module Grape
             (val.is_a?(String) && type == Hash) ||
             (val.is_a?(Hash) && type == String)
         end
+
+        # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as
+        # absence of a value and coerces it into nil. See a discussion there
+        # https://github.com/ruby-grape/grape/pull/2045
+        def treat_as_nil?(val)
+          val == '' && type != String
+        end
       end
     end
   end

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/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

@@ -13,7 +13,7 @@ module Grape
       # @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 = {})
+      def initialize(attrs, options, required, scope, **opts)
         @attrs = Array(attrs)
         @option = options
         @required = required
@@ -43,13 +43,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

@@ -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,16 +67,7 @@ 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 StandardError
         Types::InvalidValue.new

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/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.1'
+  VERSION = '1.5.1'
 end

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_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
@@ -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

data/spec/grape/dsl/inside_route_spec.rb

@@ -203,80 +203,229 @@ describe Grape::Endpoint do
   end
 
   describe '#file' do
+    before do
+      allow(subject).to receive(:warn)
+    end
+
     describe 'set' do
       context 'as file path' do
         let(:file_path) { '/some/file/path' }
 
-        let(:file_response) do
-          file_body = Grape::ServeFile::FileBody.new(file_path)
-          Grape::ServeFile::FileResponse.new(file_body)
-        end
+        it 'emits a warning that this method is deprecated' do
+          expect(subject).to receive(:warn).with(/Use sendfile or stream/)
 
-        before do
           subject.file file_path
         end
 
-        it 'returns value wrapped in FileResponse' do
-          expect(subject.file).to eq file_response
+        it 'forwards the call to sendfile' do
+          expect(subject).to receive(:sendfile).with(file_path)
+
+          subject.file file_path
         end
       end
 
       context 'as object (backward compatibility)' do
-        let(:file_object) { Class.new }
+        let(:file_object) { double('StreamerObject', each: nil) }
+
+        it 'emits a warning that this method is deprecated' do
+          expect(subject).to receive(:warn).with(/Use stream to use a Stream object/)
+
+          subject.file file_object
+        end
+
+        it 'forwards the call to stream' do
+          expect(subject).to receive(:stream).with(file_object)
+
+          subject.file file_object
+        end
+      end
+    end
+
+    describe 'get' do
+      it 'emits a warning that this method is deprecated' do
+        expect(subject).to receive(:warn).with(/Use sendfile or stream/)
+
+        subject.file
+      end
+
+      it 'fowards call to sendfile' do
+        expect(subject).to receive(:sendfile)
+
+        subject.file
+      end
+    end
+  end
+
+  describe '#sendfile' do
+    describe 'set' do
+      context 'as file path' do
+        let(:file_path) { '/some/file/path' }
 
         let(:file_response) do
-          Grape::ServeFile::FileResponse.new(file_object)
+          file_body = Grape::ServeStream::FileBody.new(file_path)
+          Grape::ServeStream::StreamResponse.new(file_body)
         end
 
         before do
-          subject.file file_object
+          subject.header 'Cache-Control', 'cache'
+          subject.header 'Content-Length', 123
+          subject.header 'Transfer-Encoding', 'base64'
+        end
+
+        it 'sends no deprecation warnings' do
+          expect(subject).to_not receive(:warn)
+
+          subject.sendfile file_path
+        end
+
+        it 'returns value wrapped in StreamResponse' do
+          subject.sendfile file_path
+
+          expect(subject.sendfile).to eq file_response
+        end
+
+        it 'does not change the Cache-Control header' do
+          subject.sendfile file_path
+
+          expect(subject.header['Cache-Control']).to eq 'cache'
+        end
+
+        it 'does not change the Content-Length header' do
+          subject.sendfile file_path
+
+          expect(subject.header['Content-Length']).to eq 123
+        end
+
+        it 'does not change the Transfer-Encoding header' do
+          subject.sendfile file_path
+
+          expect(subject.header['Transfer-Encoding']).to eq 'base64'
         end
+      end
+
+      context 'as object' do
+        let(:file_object) { double('StreamerObject', each: nil) }
 
-        it 'returns value wrapped in FileResponse' do
-          expect(subject.file).to eq file_response
+        it 'raises an error that only a file path is supported' do
+          expect { subject.sendfile file_object }.to raise_error(ArgumentError, /Argument must be a file path/)
         end
       end
     end
 
     it 'returns default' do
-      expect(subject.file).to be nil
+      expect(subject.sendfile).to be nil
     end
   end
 
   describe '#stream' do
     describe 'set' do
-      let(:file_object) { Class.new }
+      context 'as a file path' do
+        let(:file_path) { '/some/file/path' }
 
-      before do
-        subject.header 'Cache-Control', 'cache'
-        subject.header 'Content-Length', 123
-        subject.header 'Transfer-Encoding', 'base64'
-        subject.stream file_object
-      end
+        let(:file_response) do
+          file_body = Grape::ServeStream::FileBody.new(file_path)
+          Grape::ServeStream::StreamResponse.new(file_body)
+        end
 
-      it 'returns value wrapped in FileResponse' do
-        expect(subject.stream).to eq Grape::ServeFile::FileResponse.new(file_object)
-      end
+        before do
+          subject.header 'Cache-Control', 'cache'
+          subject.header 'Content-Length', 123
+          subject.header 'Transfer-Encoding', 'base64'
+        end
 
-      it 'also sets result of file to value wrapped in FileResponse' do
-        expect(subject.file).to eq Grape::ServeFile::FileResponse.new(file_object)
-      end
+        it 'emits no deprecation warnings' do
+          expect(subject).to_not receive(:warn)
+
+          subject.stream file_path
+        end
+
+        it 'returns file body wrapped in StreamResponse' do
+          subject.stream file_path
+
+          expect(subject.stream).to eq file_response
+        end
+
+        it 'sets Cache-Control header to no-cache' do
+          subject.stream file_path
+
+          expect(subject.header['Cache-Control']).to eq 'no-cache'
+        end
+
+        it 'does not change Cache-Control header' do
+          subject.stream
+
+          expect(subject.header['Cache-Control']).to eq 'cache'
+        end
+
+        it 'sets Content-Length header to nil' do
+          subject.stream file_path
+
+          expect(subject.header['Content-Length']).to eq nil
+        end
+
+        it 'sets Transfer-Encoding header to nil' do
+          subject.stream file_path
 
-      it 'sets Cache-Control header to no-cache' do
-        expect(subject.header['Cache-Control']).to eq 'no-cache'
+          expect(subject.header['Transfer-Encoding']).to eq nil
+        end
       end
 
-      it 'sets Content-Length header to nil' do
-        expect(subject.header['Content-Length']).to eq nil
+      context 'as a stream object' do
+        let(:stream_object) { double('StreamerObject', each: nil) }
+
+        let(:stream_response) do
+          Grape::ServeStream::StreamResponse.new(stream_object)
+        end
+
+        before do
+          subject.header 'Cache-Control', 'cache'
+          subject.header 'Content-Length', 123
+          subject.header 'Transfer-Encoding', 'base64'
+        end
+
+        it 'emits no deprecation warnings' do
+          expect(subject).to_not receive(:warn)
+
+          subject.stream stream_object
+        end
+
+        it 'returns value wrapped in StreamResponse' do
+          subject.stream stream_object
+
+          expect(subject.stream).to eq stream_response
+        end
+
+        it 'sets Cache-Control header to no-cache' do
+          subject.stream stream_object
+
+          expect(subject.header['Cache-Control']).to eq 'no-cache'
+        end
+
+        it 'sets Content-Length header to nil' do
+          subject.stream stream_object
+
+          expect(subject.header['Content-Length']).to eq nil
+        end
+
+        it 'sets Transfer-Encoding header to nil' do
+          subject.stream stream_object
+
+          expect(subject.header['Transfer-Encoding']).to eq nil
+        end
       end
 
-      it 'sets Transfer-Encoding header to nil' do
-        expect(subject.header['Transfer-Encoding']).to eq nil
+      context 'as a non-stream object' do
+        let(:non_stream_object) { double('NonStreamerObject') }
+
+        it 'raises an error that the object must implement :each' do
+          expect { subject.stream non_stream_object }.to raise_error(ArgumentError, /:each/)
+        end
       end
     end
 
     it 'returns default' do
-      expect(subject.file).to be nil
+      expect(subject.stream).to be nil
+      expect(subject.header['Cache-Control']).to eq nil
     end
   end