grape 0.17.0 → 0.18.0

data/lib/grape/router/pattern.rb

@@ -14,9 +14,9 @@ module Grape
       def_delegators :@regexp, :===
       alias match? ===
 
-      def initialize(pattern, options = {})
+      def initialize(pattern, **options)
         @origin  = pattern
-        @path    = build_path(pattern, options)
+        @path    = build_path(pattern, **options)
         @capture = extract_capture(options)
         @pattern = Mustermann.new(@path, pattern_options)
         @regexp  = to_regexp
@@ -34,13 +34,13 @@ module Grape
         options
       end
 
-      def build_path(pattern, options = {})
-        pattern << '*path' unless options[:anchor] || pattern.end_with?('*path')
-        pattern + options[:suffix].to_s
+      def build_path(pattern, anchor: false, suffix: nil, **_options)
+        pattern << '*path' unless anchor || pattern.end_with?('*path')
+        pattern + suffix.to_s
       end
 
-      def extract_capture(options = {})
-        requirements = {}.merge(options[:requirements])
+      def extract_capture(requirements: {}, **options)
+        requirements = {}.merge(requirements)
         supported_capture.each_with_object(requirements) do |field, capture|
           option = Array(options[field])
           capture[field] = option.map(&:to_s) if option.present?

data/lib/grape/router/route.rb

@@ -57,11 +57,11 @@ module Grape
         pattern.path
       end
 
-      def initialize(method, pattern, options = {})
+      def initialize(method, pattern, **options)
         @suffix     = options[:suffix]
         @options    = options.merge(method: method.to_s.upcase)
-        @pattern    = Pattern.new(pattern, options)
-        @translator = AttributeTranslator.new(options.merge(request_method: method.to_s.upcase))
+        @pattern    = Pattern.new(pattern, **options)
+        @translator = AttributeTranslator.new(**options, request_method: method.to_s.upcase)
       end
 
       def exec(env)

data/lib/grape/util/env.rb

@@ -18,6 +18,6 @@ module Grape
     GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze
     GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze
     GRAPE_ROUTING_ARGS = 'grape.routing_args'.freeze
-    GRAPE_METHOD_NOT_ALLOWED = 'grape.method_not_allowed'.freeze
+    GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'.freeze
   end
 end

data/lib/grape/validations/params_scope.rb

@@ -230,9 +230,13 @@ module Grape
         full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
         @api.document_attribute(full_attrs, doc_attrs)
 
+        # slice out fail_fast attribute
+        opts = {}
+        opts[:fail_fast] = validations.delete(:fail_fast) || false
+
         # Validate for presence before any other validators
         if validations.key?(:presence) && validations[:presence]
-          validate('presence', validations[:presence], attrs, doc_attrs)
+          validate('presence', validations[:presence], attrs, doc_attrs, opts)
           validations.delete(:presence)
           validations.delete(:message) if validations.key?(:message)
         end
@@ -240,10 +244,10 @@ module Grape
         # Before we run the rest of the validators, let's handle
         # whatever coercion so that we are working with correctly
         # type casted values
-        coerce_type validations, attrs, doc_attrs
+        coerce_type validations, attrs, doc_attrs, opts
 
         validations.each do |type, options|
-          validate(type, options, attrs, doc_attrs)
+          validate(type, options, attrs, doc_attrs, opts)
         end
       end
 
@@ -308,7 +312,7 @@ module Grape
       # composited from more than one +requires+/+optional+
       # parameter, and needs to be run before most other
       # validations.
-      def coerce_type(validations, attrs, doc_attrs)
+      def coerce_type(validations, attrs, doc_attrs, opts)
         check_coerce_with(validations)
 
         return unless validations.key?(:coerce)
@@ -318,7 +322,7 @@ module Grape
           method: validations[:coerce_with],
           message: validations[:coerce_message]
         }
-        validate('coerce', coerce_options, attrs, doc_attrs)
+        validate('coerce', coerce_options, attrs, doc_attrs, opts)
         validations.delete(:coerce_with)
         validations.delete(:coerce)
         validations.delete(:coerce_message)
@@ -337,18 +341,22 @@ module Grape
         raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
       end
 
-      def validate(type, options, attrs, doc_attrs)
+      def validate(type, options, attrs, doc_attrs, opts)
         validator_class = Validations.validators[type.to_s]
 
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
-        value = validator_class.new(attrs, options, doc_attrs[:required], self)
+        value = validator_class.new(attrs, options, doc_attrs[:required], self, opts)
         @api.namespace_stackable(:validations, value)
       end
 
       def validate_value_coercion(coerce_type, values)
         return unless coerce_type && values
         return if values.is_a?(Proc)
+        if values.is_a?(Hash)
+          return if values[:value] && values[:value].is_a?(Proc)
+          return if values[:except] && values[:except].is_a?(Proc)
+        end
         coerce_type = coerce_type.first if coerce_type.is_a?(Array)
         value_types = values.is_a?(Range) ? [values.begin, values.end] : values
         if coerce_type == Virtus::Attribute::Boolean

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

@@ -7,19 +7,6 @@ module Grape
         value = params[attr_name]
         value = value.strip if value.respond_to?(:strip)
 
-        key_exists = params.key?(attr_name)
-
-        should_validate = if @scope.root?
-                            # root scope. validate if it's a required param. if it's optional, validate only if key exists in hash
-                            @required || key_exists
-                          else # nested scope
-                            (@required && params.present?) ||
-                              # optional param but key inside scoping element exists
-                              (!@required && params.key?(attr_name))
-                          end
-
-        return unless should_validate
-
         return if false == value || value.present?
 
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank)

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

@@ -10,11 +10,13 @@ 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
-      def initialize(attrs, options, required, scope)
+      # @param opts [Hash] 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
       end
 
       # Validates a given request.
@@ -24,6 +26,7 @@ module Grape
       # @raise [Grape::Exceptions::Validation] if validation failed
       # @return [void]
       def validate(request)
+        return unless @scope.should_validate?(request.params)
         validate!(request.params)
       end
 
@@ -75,6 +78,10 @@ module Grape
         options = instance_variable_get(:@option) if options.nil?
         options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
       end
+
+      def fail_fast?
+        @fail_fast
+      end
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Grape
   module Validations
     class DefaultValidator < Base
-      def initialize(attrs, options, required, scope)
+      def initialize(attrs, options, required, scope, opts = {})
         @default = options
         super
       end
@@ -18,8 +18,6 @@ module Grape
       end
 
       def validate!(params)
-        return unless @scope.should_validate?(params)
-
         attrs = AttributesIterator.new(self, @scope, params)
         attrs.each do |resource_params, attr_name|
           if resource_params.is_a?(Hash) && resource_params[attr_name].nil?

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

@@ -1,11 +1,6 @@
 module Grape
   module Validations
     class PresenceValidator < Base
-      def validate!(params)
-        return unless @scope.should_validate?(params)
-        super
-      end
-
       def validate_param!(attr_name, params)
         return if params.respond_to?(:key?) && params.key?(attr_name)
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)

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

@@ -1,8 +1,11 @@
 module Grape
   module Validations
     class ValuesValidator < Base
-      def initialize(attrs, options, required, scope)
-        @values = (options_key?(:value, options) ? options[:value] : options)
+      def initialize(attrs, options, required, scope, opts = {})
+        @excepts = (options_key?(:except, options) ? options[:except] : [])
+        @values = (options_key?(:value, options) ? options[:value] : [])
+
+        @values = options if @excepts == [] && @values == []
         super
       end
 
@@ -11,13 +14,24 @@ module Grape
         return unless params[attr_name] || required_for_root_scope?
 
         values = @values.is_a?(Proc) ? @values.call : @values
+        excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        return if param_array.all? { |param| values.include?(param) }
+
+        if param_array.all? { |param| excepts.include?(param) }
+          raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: except_message
+        end
+
+        return if (values.is_a?(Array) && values.empty?) || param_array.all? { |param| values.include?(param) }
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values)
       end
 
       private
 
+      def except_message
+        options = instance_variable_get(:@option)
+        options_key?(:except_message) ? options[:except_message] : message(:except)
+      end
+
       def required_for_root_scope?
         @required && @scope.root?
       end

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.17.0'.freeze
+  VERSION = '0.18.0'.freeze
 end

data/spec/grape/api_spec.rb

@@ -665,6 +665,47 @@ XML
       end
     end
 
+    describe 'adds an OPTIONS route for namespaced endpoints that' do
+      before do
+        subject.before { header 'X-Custom-Header', 'foo' }
+        subject.namespace :example do
+          before { header 'X-Custom-Header-2', 'foo' }
+          get :inner do
+            'example/inner'
+          end
+        end
+        options '/example/inner'
+      end
+
+      it 'returns a 204' do
+        expect(last_response.status).to eql 204
+      end
+
+      it 'has an empty body' do
+        expect(last_response.body).to be_blank
+      end
+
+      it 'has an Allow header' do
+        expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
+      end
+
+      it 'calls the outer before filter' do
+        expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+      end
+
+      it 'calls the inner before filter' do
+        expect(last_response.headers['X-Custom-Header-2']).to eql 'foo'
+      end
+
+      it 'has no Content-Type' do
+        expect(last_response.content_type).to be_nil
+      end
+
+      it 'has no Content-Length' do
+        expect(last_response.content_length).to be_nil
+      end
+    end
+
     describe 'adds a 405 Not Allowed route that' do
       before do
         subject.before { header 'X-Custom-Header', 'foo' }

data/spec/grape/exceptions/validation_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Grape::Exceptions::Validation do
   it 'fails when params are missing' do
-    expect { Grape::Exceptions::Validation.new(message: 'presence') }.to raise_error(RuntimeError, 'Params are missing:')
+    expect { Grape::Exceptions::Validation.new(message: 'presence') }.to raise_error(ArgumentError, 'missing keyword: params')
   end
   context 'when message is a symbol' do
     it 'stores message_key' do

data/spec/grape/middleware/stack_spec.rb

@@ -61,6 +61,16 @@ describe Grape::Middleware::Stack do
       expect(subject[1]).to eq(StackSpec::FooMiddleware)
     end
 
+    it 'inserts a middleware before an anonymous class given by its superclass' do
+      subject.use Class.new(StackSpec::BlockMiddleware)
+
+      expect { subject.insert_before StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+
+      expect(subject[1]).to eq(StackSpec::BarMiddleware)
+      expect(subject[2]).to eq(StackSpec::BlockMiddleware)
+    end
+
     it 'raises an error on an invalid index' do
       expect { subject.insert_before StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
         .to raise_error(RuntimeError, 'No such middleware to insert before: StackSpec::BlockMiddleware')
@@ -75,6 +85,16 @@ describe Grape::Middleware::Stack do
       expect(subject[0]).to eq(StackSpec::FooMiddleware)
     end
 
+    it 'inserts a middleware after an anonymous class given by its superclass' do
+      subject.use Class.new(StackSpec::BlockMiddleware)
+
+      expect { subject.insert_after StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
+        .to change { subject.size }.by(1)
+
+      expect(subject[1]).to eq(StackSpec::BlockMiddleware)
+      expect(subject[2]).to eq(StackSpec::BarMiddleware)
+    end
+
     it 'raises an error on an invalid index' do
       expect { subject.insert_after StackSpec::BlockMiddleware, StackSpec::BarMiddleware }
         .to raise_error(RuntimeError, 'No such middleware to insert after: StackSpec::BlockMiddleware')

data/spec/grape/validations/params_scope_spec.rb

@@ -157,6 +157,35 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
+  context 'coercing values validation with proc' do
+    it 'allows the proc to pass validation without checking' do
+      subject.params { requires :numbers, type: Integer, values: -> { [0, 1, 2] } }
+
+      subject.post('/required') { 'coercion with proc works' }
+      post '/required', numbers: '1'
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to eq('coercion with proc works')
+    end
+
+    it 'allows the proc to pass validation without checking in value' do
+      subject.params { requires :numbers, type: Integer, values: { value: -> { [0, 1, 2] } } }
+
+      subject.post('/required') { 'coercion with proc works' }
+      post '/required', numbers: '1'
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to eq('coercion with proc works')
+    end
+
+    it 'allows the proc to pass validation without checking in except' do
+      subject.params { requires :numbers, type: Integer, values: { except: -> { [0, 1, 2] } } }
+
+      subject.post('/required') { 'coercion with proc works' }
+      post '/required', numbers: '10'
+      expect(last_response.status).to eq(201)
+      expect(last_response.body).to eq('coercion with proc works')
+    end
+  end
+
   context 'with range values' do
     context "when left range endpoint isn't #kind_of? the type" do
       it 'raises exception' do
@@ -342,6 +371,44 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
     end
 
+    it 'applies only the appropriate validation' do
+      subject.params do
+        optional :a
+        optional :b
+        mutually_exclusive :a, :b
+        given :a do
+          requires :c, type: String
+        end
+        given :b do
+          requires :c, type: Integer
+        end
+      end
+      subject.get('/multiple') { declared(params).to_json }
+
+      get '/multiple'
+      expect(last_response.status).to eq(200)
+
+      get '/multiple', a: true, c: 'test'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq a: 'true', b: nil, c: 'test'
+
+      get '/multiple', b: true, c: '3'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq a: nil, b: 'true', c: 3
+
+      get '/multiple', a: true
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('c is missing')
+
+      get '/multiple', b: true
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('c is missing')
+
+      get '/multiple', a: true, b: true, c: 'test'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('a, b are mutually exclusive, c is invalid')
+    end
+
     it 'raises an error if the dependent parameter was never specified' do
       expect do
         subject.params do
@@ -407,89 +474,154 @@ describe Grape::Validations::ParamsScope do
   end
 
   context 'when validations are dependent on a parameter with specific value' do
-    before do
+    # build test cases from all combinations of declarations and options
+    a_decls = %i(optional requires)
+    a_options = [{}, { values: %w(x y z) }]
+    b_options = [{}, { type: String }, { allow_blank: false }, { type: String, allow_blank: false }]
+    combinations = a_decls.product(a_options, b_options)
+    combinations.each_with_index do |combination, i|
+      a_decl, a_opts, b_opts = combination
+
+      context "(case #{i})" do
+        before do
+          # puts "a_decl: #{a_decl}, a_opts: #{a_opts}, b_opts: #{b_opts}"
+          subject.params do
+            send a_decl, :a, **a_opts
+            given(a: ->(val) { val == 'x' }) { requires :b, **b_opts }
+            given(a: ->(val) { val == 'y' }) { requires :c, **b_opts }
+          end
+          subject.get('/test') { declared(params).to_json }
+        end
+
+        if a_decl == :optional
+          it 'skips validation when base param is missing' do
+            get '/test'
+            expect(last_response.status).to eq(200)
+          end
+        end
+
+        it 'skips validation when base param does not have a specified value' do
+          get '/test', a: 'z'
+          expect(last_response.status).to eq(200)
+
+          get '/test', a: 'z', b: ''
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'applies the validation when base param has the specific value' do
+          get '/test', a: 'x'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to include('b is missing')
+
+          get '/test', a: 'x', b: true
+          expect(last_response.status).to eq(200)
+
+          get '/test', a: 'x', b: true, c: ''
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'includes the parameter within #declared(params)' do
+          get '/test', a: 'x', b: true
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => 'true', 'c' => nil)
+        end
+      end
+    end
+  end
+
+  it 'raises an error if the dependent parameter was never specified' do
+    expect do
       subject.params do
+        given :c do
+        end
+      end
+    end.to raise_error(Grape::Exceptions::UnknownParameter)
+  end
+
+  it 'returns a sensible error message within a nested context' do
+    subject.params do
+      requires :bar, type: Hash do
         optional :a
         given a: ->(val) { val == 'x' } do
           requires :b
         end
       end
-      subject.get('/test') { declared(params).to_json }
     end
+    subject.get('/nested') { 'worked' }
 
-    it 'applies the validations only if the parameter has the specific value' do
-      get '/test'
-      expect(last_response.status).to eq(200)
-
-      get '/test', a: 'x'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('b is missing')
-
-      get '/test', a: 'x', b: true
-      expect(last_response.status).to eq(200)
-    end
+    get '/nested', bar: { a: 'x' }
+    expect(last_response.status).to eq(400)
+    expect(last_response.body).to eq('bar[b] is missing')
+  end
 
-    it 'raises an error if the dependent parameter was never specified' do
-      expect do
-        subject.params do
-          given :c do
-          end
+  it 'includes the nested parameter within #declared(params)' do
+    subject.params do
+      requires :bar, type: Hash do
+        optional :a
+        given a: ->(val) { val == 'x' } do
+          requires :b
         end
-      end.to raise_error(Grape::Exceptions::UnknownParameter)
+      end
     end
+    subject.get('/nested') { declared(params).to_json }
 
-    it 'includes the parameter within #declared(params)' do
-      get '/test', a: true, b: true
-
-      expect(JSON.parse(last_response.body)).to eq('a' => 'true', 'b' => 'true')
-    end
+    get '/nested', bar: { a: 'x', b: 'yes' }
+    expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'x', 'b' => 'yes' })
+  end
 
-    it 'returns a sensible error message within a nested context' do
-      subject.params do
-        requires :bar, type: Hash do
-          optional :a
-          given a: ->(val) { val == 'x' } do
+  it 'includes level 2 nested parameters outside the given within #declared(params)' do
+    subject.params do
+      requires :bar, type: Hash do
+        optional :a
+        given a: ->(val) { val == 'x' } do
+          requires :c, type: Hash do
             requires :b
           end
         end
       end
-      subject.get('/nested') { 'worked' }
-
-      get '/nested', bar: { a: 'x' }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('bar[b] is missing')
     end
+    subject.get('/nested') { declared(params).to_json }
 
-    it 'includes the nested parameter within #declared(params)' do
-      subject.params do
-        requires :bar, type: Hash do
-          optional :a
-          given a: ->(val) { val == 'x' } do
-            requires :b
-          end
+    get '/nested', bar: { a: 'x', c: { b: 'yes' } }
+    expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'x', 'c' => { 'b' => 'yes' } })
+  end
+
+  context 'failing fast' do
+    context 'when fail_fast is not defined' do
+      it 'does not stop validation' do
+        subject.params do
+          requires :one
+          requires :two
+          requires :three
         end
-      end
-      subject.get('/nested') { declared(params).to_json }
+        subject.get('/fail-fast') { declared(params).to_json }
 
-      get '/nested', bar: { a: 'x', b: 'yes' }
-      expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'x', 'b' => 'yes' })
+        get '/fail-fast'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('one is missing, two is missing, three is missing')
+      end
     end
-
-    it 'includes level 2 nested parameters outside the given within #declared(params)' do
-      subject.params do
-        requires :bar, type: Hash do
-          optional :a
-          given a: ->(val) { val == 'x' } do
-            requires :c, type: Hash do
-              requires :b
-            end
-          end
+    context 'when fail_fast is defined it stops the validation' do
+      it 'of other params' do
+        subject.params do
+          requires :one, fail_fast: true
+          requires :two
         end
+        subject.get('/fail-fast') { declared(params).to_json }
+
+        get '/fail-fast'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('one is missing')
       end
-      subject.get('/nested') { declared(params).to_json }
+      it 'for a single param' do
+        subject.params do
+          requires :one, allow_blank: false, regexp: /[0-9]+/, fail_fast: true
+        end
+        subject.get('/fail-fast') { declared(params).to_json }
 
-      get '/nested', bar: { a: 'x', c: { b: 'yes' } }
-      expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'x', 'c' => { 'b' => 'yes' } })
+        get '/fail-fast', one: ''
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('one is empty')
+      end
     end
   end
 end