grape 0.10.1 → 0.11.0

data/lib/grape/dsl/routing.rb

@@ -35,10 +35,20 @@ module Grape
             fail Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
             @versions = versions | args
-            nest(block) do
+
+            if block_given?
+              within_namespace do
+                namespace_inheritable(:version, args)
+                namespace_inheritable(:version_options, options)
+
+                instance_eval(&block)
+              end
+            else
               namespace_inheritable(:version, args)
               namespace_inheritable(:version_options, options)
             end
+
+            # reset_validations!
           end
 
           @versions.last unless @versions.nil?

data/lib/grape/error_formatter/base.rb

@@ -41,7 +41,7 @@ module Grape
           http_codes = env['rack.routing_args'][:route_info].route_http_codes || []
           found_code = http_codes.find do |http_code|
             (http_code[0].to_i == env['api.endpoint'].status) && http_code[2].respond_to?(:represent)
-          end
+          end if env['api.endpoint'].request
 
           presenter = found_code[2] if found_code
         end

data/lib/grape/exceptions/invalid_accept_header.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class InvalidAcceptHeader < Base
+      def initialize(message, headers)
+        super(message: compose_message('invalid_accept_header', message: message), status: 406, headers: headers)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/invalid_message_body.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class InvalidMessageBody < Base
+      def initialize(body_format)
+        super(message: compose_message('invalid_message_body', body_format: body_format), status: 400)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/missing_group_type.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class MissingGroupTypeError < Base
+      def initialize
+        super(message: compose_message('missing_group_type'))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unsupported_group_type.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class UnsupportedGroupTypeError < Base
+      def initialize
+        super(message: compose_message('unsupported_group_type'))
+      end
+    end
+  end
+end

data/lib/grape/http/request.rb

@@ -7,6 +7,7 @@ module Grape
           args = env['rack.routing_args'].dup
           # preserve version from query string parameters
           args.delete(:version)
+          args.delete(:route_info)
           params.deep_merge!(args)
         end
         params

data/lib/grape/locale/en.yml

@@ -33,4 +33,15 @@ en:
         at_least_one: 'are missing, at least one parameter must be provided'
         exactly_one: 'are missing, exactly one parameter must be provided'
         all_or_none: 'provide all or none of parameters'
+        missing_group_type: 'group type is required'
+        unsupported_group_type: 'group type must be Array or Hash'
+        invalid_message_body:
+          problem: "message body does not match declared format"
+          resolution:
+            "when specifying %{body_format} as content-type, you must pass valid
+            %{body_format} in the request's 'body'
+            "
+        invalid_accept_header:
+          problem: 'Invalid accept header'
+          resolution: '%{message}'
 

data/lib/grape/middleware/base.rb

@@ -37,7 +37,7 @@ module Grape
       end
 
       def response
-        Rack::Response.new(@app_response)
+        Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
       def content_type_for(format)

data/lib/grape/middleware/formatter.rb

@@ -81,6 +81,8 @@ module Grape
                 end
                 env['rack.request.form_input'] = env['rack.input']
               end
+            rescue Grape::Exceptions::Base => e
+              raise e
             rescue StandardError => e
               throw :error, status: 400, message: e.message
             end

data/lib/grape/middleware/versioner/header.rb

@@ -16,23 +16,19 @@ module Grape
       #    env['api.subtype'] => 'vnd.mycompany-v1+json'
       #    env['api.vendor]   => 'mycompany'
       #    env['api.version]  => 'v1'
-      #    env['api.format]   => 'format'
+      #    env['api.format]   => 'json'
       #
       # If version does not match this route, then a 406 is raised with
       # X-Cascade header to alert Rack::Mount to attempt the next matched
       # route.
       class Header < Base
         def before
-          begin
-            header = Rack::Accept::MediaType.new env['HTTP_ACCEPT']
-          rescue RuntimeError => e
-            throw :error, status: 406, headers: error_headers, message: e.message
-          end
+          header = rack_accept_header
 
           if strict?
             # If no Accept header:
             if header.qvalues.empty?
-              throw :error, status: 406, headers: error_headers, message: 'Accept header must be set.'
+              fail Grape::Exceptions::InvalidAcceptHeader.new('Accept header must be set.', error_headers)
             end
             # Remove any acceptable content types with ranges.
             header.qvalues.reject! do |media_type, _|
@@ -40,7 +36,8 @@ module Grape
             end
             # If all Accept headers included a range:
             if header.qvalues.empty?
-              throw :error, status: 406, headers: error_headers, message: 'Accept header must not contain ranges ("*").'
+              fail Grape::Exceptions::InvalidAcceptHeader.new('Accept header must not contain ranges ("*").',
+                                                              error_headers)
             end
           end
 
@@ -58,10 +55,10 @@ module Grape
             end
           # If none of the available content types are acceptable:
           elsif strict?
-            throw :error, status: 406, headers: error_headers, message: '406 Not Acceptable'
+            fail Grape::Exceptions::InvalidAcceptHeader.new('406 Not Acceptable', error_headers)
           # If all acceptable content types specify a vendor or version that doesn't exist:
           elsif header.values.all? { |header_value| has_vendor?(header_value) || version?(header_value) }
-            throw :error, status: 406, headers: error_headers, message: 'API vendor or version not found.'
+            fail Grape::Exceptions::InvalidAcceptHeader.new('API vendor or version not found.', error_headers)
           end
         end
 
@@ -83,7 +80,13 @@ module Grape
             available_media_types << media_type
           end
 
-          available_media_types = available_media_types.flatten
+          available_media_types.flatten
+        end
+
+        def rack_accept_header
+          Rack::Accept::MediaType.new env['HTTP_ACCEPT']
+        rescue RuntimeError => e
+          raise Grape::Exceptions::InvalidAcceptHeader.new(e.message, error_headers)
         end
 
         def versions

data/lib/grape/parser/json.rb

@@ -4,6 +4,9 @@ module Grape
       class << self
         def call(object, env)
           MultiJson.load(object)
+        rescue MultiJson::ParseError
+          # handle JSON parsing errors via the rescue handlers or provide error message
+          raise Grape::Exceptions::InvalidMessageBody, 'application/json'
         end
       end
     end

data/lib/grape/parser/xml.rb

@@ -4,6 +4,9 @@ module Grape
       class << self
         def call(object, env)
           MultiXml.parse(object)
+        rescue MultiXml::ParseError
+          # handle XML parsing errors via the rescue handlers or provide error message
+          raise Grape::Exceptions::InvalidMessageBody, 'application/xml'
         end
       end
     end

data/lib/grape/validations/params_scope.rb

@@ -64,14 +64,29 @@ module Grape
         end
       end
 
+      def require_optional_fields(context, opts)
+        optional_fields = opts[:using].keys
+        optional_fields -= Array(opts[:except]) unless context == :all
+        optional_fields.each do |field|
+          field_opts = opts[:using][field]
+          optional(field, field_opts) if field_opts
+        end
+      end
+
       def validate_attributes(attrs, opts, &block)
-        validations = { presence: true }
-        validations.merge!(opts) if opts
+        validations = opts.clone
         validations[:type] ||= Array if block
         validates(attrs, validations)
       end
 
       def new_scope(attrs, optional = false, &block)
+        # if required params are grouped and no type or unsupported type is provided, raise an error
+        type = attrs[1] ? attrs[1][:type] : nil
+        if attrs.first && !optional
+          fail Grape::Exceptions::MissingGroupTypeError.new if type.nil?
+          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless [Array, Hash].include?(type)
+        end
+
         opts = attrs[1] || { type: Array }
         ParamsScope.new(api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block)
       end
@@ -141,7 +156,7 @@ module Grape
 
       def guess_coerce_type(coerce_type, values)
         return coerce_type if !values || values.is_a?(Proc)
-        return values.first.class if coerce_type == Array && !values.empty?
+        return values.first.class if coerce_type == Array && (values.is_a?(Range) || !values.empty?)
         coerce_type
       end
 
@@ -167,7 +182,8 @@ module Grape
         return unless coerce_type && values
         return if values.is_a?(Proc)
         coerce_type = coerce_type.first if coerce_type.kind_of?(Array)
-        if values.any? { |v| !v.kind_of?(coerce_type) }
+        value_types = values.is_a?(Range) ? [values.begin, values.end] : values
+        if value_types.any? { |v| !v.kind_of?(coerce_type) }
           fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
         end
       end

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

@@ -29,9 +29,12 @@ module Grape
         # allow nil, to ignore when a parameter is absent
         return true if val.nil?
         if klass == Virtus::Attribute::Boolean
-          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+          val.is_a?(TrueClass) || val.is_a?(FalseClass) || (val.is_a?(String) && val.empty?)
         elsif klass == Rack::Multipart::UploadedFile
           val.is_a?(Hashie::Mash) && val.key?(:tempfile)
+        elsif [DateTime, Date, Numeric].any?{ |vclass| vclass >= klass }
+          return true if val.is_a?(String) && val.empty?
+          val.is_a?(klass)
         else
           val.is_a?(klass)
         end

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

@@ -11,7 +11,7 @@ module Grape
 
         values = @values.is_a?(Proc) ? @values.call : @values
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        unless (param_array - values).empty?
+        unless param_array.all? { |param| values.include?(param) }
           fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :values
         end
       end

data/lib/grape/version.rb

@@ -1,3 +1,3 @@
 module Grape
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 end

data/spec/grape/api_spec.rb

@@ -2166,11 +2166,11 @@ describe Grape::API do
     it 'groups nested params and prevents overwriting of params with same name in different groups' do
       subject.desc 'method'
       subject.params do
-        group :group1 do
+        group :group1, type: Array do
           optional :param1, desc: 'group1 param1 desc'
           requires :param2, desc: 'group1 param2 desc'
         end
-        group :group2 do
+        group :group2, type: Array do
           optional :param1, desc: 'group2 param1 desc'
           requires :param2, desc: 'group2 param2 desc'
         end
@@ -2190,7 +2190,7 @@ describe Grape::API do
       subject.desc 'nesting'
       subject.params do
         requires :root_param, desc: 'root param'
-        group :nested do
+        group :nested, type: Array do
           requires :nested_param, desc: 'nested param'
         end
       end

data/spec/grape/dsl/parameters_spec.rb

@@ -11,7 +11,7 @@ module Grape
         end
 
         # rubocop:disable TrivialAccessors
-        def validate_attrs
+        def validate_attributes_reader
           @validate_attributes
         end
         # rubocop:enable TrivialAccessors
@@ -21,7 +21,7 @@ module Grape
         end
 
         # rubocop:disable TrivialAccessors
-        def push_declared_paras
+        def push_declared_params_reader
           @push_declared_params
         end
         # rubocop:enable TrivialAccessors
@@ -31,7 +31,7 @@ module Grape
         end
 
         # rubocop:disable TrivialAccessors
-        def valids
+        def validates_reader
           @validates
         end
         # rubocop:enable TrivialAccessors
@@ -57,8 +57,8 @@ module Grape
         it 'adds a required parameter' do
           subject.requires :id, type: Integer, desc: 'Identity.'
 
-          expect(subject.validate_attrs).to eq([[:id], { type: Integer, desc: 'Identity.' }])
-          expect(subject.push_declared_paras).to eq([[:id]])
+          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.', presence: true }])
+          expect(subject.push_declared_params_reader).to eq([[:id]])
         end
       end
 
@@ -66,8 +66,8 @@ module Grape
         it 'adds an optional parameter' do
           subject.optional :id, type: Integer, desc: 'Identity.'
 
-          expect(subject.valids).to eq([[:id], { type: Integer, desc: 'Identity.' }])
-          expect(subject.push_declared_paras).to eq([[:id]])
+          expect(subject.validate_attributes_reader).to eq([[:id], { type: Integer, desc: 'Identity.' }])
+          expect(subject.push_declared_params_reader).to eq([[:id]])
         end
       end
 
@@ -75,7 +75,7 @@ module Grape
         it 'adds an mutally exclusive parameter validation' do
           subject.mutually_exclusive :media, :audio
 
-          expect(subject.valids).to eq([[:media, :audio], { mutual_exclusion: true }])
+          expect(subject.validates_reader).to eq([[:media, :audio], { mutual_exclusion: true }])
         end
       end
 
@@ -83,7 +83,7 @@ module Grape
         it 'adds an exactly of one parameter validation' do
           subject.exactly_one_of :media, :audio
 
-          expect(subject.valids).to eq([[:media, :audio], { exactly_one_of: true }])
+          expect(subject.validates_reader).to eq([[:media, :audio], { exactly_one_of: true }])
         end
       end
 
@@ -91,7 +91,7 @@ module Grape
         it 'adds an at least one of parameter validation' do
           subject.at_least_one_of :media, :audio
 
-          expect(subject.valids).to eq([[:media, :audio], { at_least_one_of: true }])
+          expect(subject.validates_reader).to eq([[:media, :audio], { at_least_one_of: true }])
         end
       end
 
@@ -99,7 +99,7 @@ module Grape
         it 'adds an all or none of parameter validation' do
           subject.all_or_none_of :media, :audio
 
-          expect(subject.valids).to eq([[:media, :audio], { all_or_none_of: true }])
+          expect(subject.validates_reader).to eq([[:media, :audio], { all_or_none_of: true }])
         end
       end
 

data/spec/grape/dsl/routing_spec.rb

@@ -14,8 +14,13 @@ module Grape
       let(:options) { { a: :b } }
       let(:path) { '/dummy' }
 
-      xdescribe '.version' do
-        it 'does some thing'
+      describe '.version' do
+        it 'sets a version for route' do
+          version = 'v1'
+          expect(subject).to receive(:namespace_inheritable).with(:version, [version])
+          expect(subject).to receive(:namespace_inheritable).with(:version_options, using: :path)
+          expect(subject.version(version)).to eq(version)
+        end
       end
 
       describe '.prefix' do
@@ -140,8 +145,12 @@ module Grape
         it 'does some thing'
       end
 
-      xdescribe '.versions' do
-        it 'does some thing'
+      describe '.versions' do
+        it 'returns last defined version' do
+          subject.version 'v1'
+          subject.version 'v2'
+          expect(subject.version).to eq('v2')
+        end
       end
     end
   end

data/spec/grape/endpoint_spec.rb

@@ -386,9 +386,9 @@ describe Grape::Endpoint do
 
       expect(last_response.status).to eq(200)
       expect(inner_params[:first]).to eq 'present'
-      expect(inner_params[:nested].keys).to eq [:fourth, :fifth, :nested_nested]
+      expect(inner_params[:nested].keys).to eq %w(fourth fifth nested_nested)
       expect(inner_params[:nested][:fourth]).to eq ''
-      expect(inner_params[:nested][:nested_nested].keys).to eq [:sixth, :seven]
+      expect(inner_params[:nested][:nested_nested].keys).to eq %w(sixth seven)
       expect(inner_params[:nested][:nested_nested][:sixth]).to eq 'sixth'
     end
   end

data/spec/grape/exceptions/body_parse_errors_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Grape::Exceptions::ValidationErrors do
+  context 'api with rescue_from :all handler' do
+    subject { Class.new(Grape::API) }
+    before {
+      subject.rescue_from :all do |e|
+        rack_response 'message was processed', 400
+      end
+      subject.params do
+        requires :beer
+      end
+      subject.post '/beer' do
+        'beer received'
+      end
+    }
+
+    def app
+      subject
+    end
+
+    context 'with content_type json' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq('message was processed')
+      end
+    end
+
+    context 'with content_type xml' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq('message was processed')
+      end
+    end
+
+    context 'with content_type text' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq('message was processed')
+      end
+    end
+
+    context 'with no specific content_type' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', {}
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq('message was processed')
+      end
+    end
+  end
+
+  context 'api without a rescue handler' do
+    subject { Class.new(Grape::API) }
+    before {
+      subject.params do
+        requires :beer
+      end
+      subject.post '/beer' do
+        'beer received'
+      end
+    }
+
+    def app
+      subject
+    end
+
+    context 'and with content_type json' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include('message body does not match declared format')
+        expect(last_response.body).to include('application/json')
+      end
+    end
+
+    context 'with content_type xml' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include('message body does not match declared format')
+        expect(last_response.body).to include('application/xml')
+      end
+    end
+
+    context 'with content_type text' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'text/plain'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq('beer is missing')
+      end
+    end
+
+    context 'and with no specific content_type' do
+      it 'can recover from failed body parsing' do
+        post '/beer', 'test', {}
+        expect(last_response.status).to eq 400
+        # plain response with text/html
+        expect(last_response.body).to eq('beer is missing')
+      end
+    end
+  end
+end