grape 0.18.0 → 0.19.0

data/lib/grape/error_formatter/base.rb

@@ -15,6 +15,7 @@ module Grape
           # env['api.endpoint'].route does not work when the error occurs within a middleware
           # the Endpoint does not have a valid env at this moment
           http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || []
+
           found_code = http_codes.find do |http_code|
             (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
           end if env[Grape::Env::API_ENDPOINT].request

data/lib/grape/formatter/serializable_hash.rb

@@ -12,13 +12,13 @@ module Grape
         private
 
         def serializable?(object)
-          object.respond_to?(:serializable_hash) || object.is_a?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false) || object.is_a?(Hash)
+          object.respond_to?(:serializable_hash) || object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash } || object.is_a?(Hash)
         end
 
         def serialize(object)
           if object.respond_to? :serializable_hash
             object.serializable_hash
-          elsif object.is_a?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false)
+          elsif object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash }
             object.map(&:serializable_hash)
           elsif object.is_a?(Hash)
             h = {}

data/lib/grape/http/headers.rb

@@ -16,6 +16,8 @@ module Grape
       HEAD    = 'HEAD'.freeze
       OPTIONS = 'OPTIONS'.freeze
 
+      SUPPORTED_METHODS = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS].freeze
+
       HTTP_ACCEPT_VERSION    = 'HTTP_ACCEPT_VERSION'.freeze
       X_CASCADE              = 'X-Cascade'.freeze
       HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'.freeze

data/lib/grape/middleware/base.rb

@@ -13,6 +13,7 @@ module Grape
       def initialize(app, **options)
         @app = app
         @options = default_options.merge(**options)
+        @app_response = nil
       end
 
       def default_options
@@ -44,14 +45,12 @@ module Grape
 
       # @abstract
       # Called before the application is called in the middleware lifecycle.
-      def before
-      end
+      def before; end
 
       # @abstract
       # Called after the application is called in the middleware lifecycle.
       # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards.
-      def after
-      end
+      def after; end
 
       def response
         return @app_response if @app_response.is_a?(Rack::Response)

data/lib/grape/middleware/error.rb

@@ -70,7 +70,7 @@ module Grape
       end
 
       def exec_handler(e, &handler)
-        if handler.lambda? && handler.arity == 0
+        if handler.lambda? && handler.arity.zero?
           instance_exec(&handler)
         else
           instance_exec(e, &handler)

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

@@ -26,7 +26,7 @@ module Grape
         def before
           path = env[Grape::Http::Headers::PATH_INFO].dup
 
-          if prefix && path.index(prefix) == 0
+          if prefix && path.index(prefix).zero?
             path.sub!(prefix, '')
             path = Grape::Router.normalize_path(path)
           end

data/lib/grape/router.rb

@@ -19,6 +19,10 @@ module Grape
       path
     end
 
+    def self.supported_methods
+      @supported_methods ||= Grape::Http::Headers::SUPPORTED_METHODS + ['*']
+    end
+
     def initialize
       @neutral_map = []
       @map = Hash.new { |hash, key| hash[key] = [] }
@@ -28,7 +32,8 @@ module Grape
     def compile!
       return if compiled
       @union = Regexp.union(@neutral_map.map(&:regexp))
-      map.each do |method, routes|
+      self.class.supported_methods.each do |method|
+        routes = map[method]
         @optimized_map[method] = routes.map.with_index do |route, index|
           route.index = index
           route.regexp = /(?<_#{index}>#{route.pattern.to_regexp})/
@@ -64,38 +69,54 @@ module Grape
 
     def identity(env)
       route = nil
-      response = transaction(env) do |input, method, routing_args|
+      response = transaction(env) do |input, method|
         route = match?(input, method)
-        if route
-          env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
-          route.exec(env)
-        end
+        process_route(route, env) if route
       end
       [response, route]
     end
 
     def rotation(env, exact_route = nil)
       response = nil
-      input, method, routing_args = *extract_required_args(env)
-      routes_for(method).each do |route|
+      input, method = *extract_input_and_method(env)
+      map[method].each do |route|
         next if exact_route == route
         next unless route.match?(input)
-        env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
-        response = route.exec(env)
+        response = process_route(route, env)
         break unless cascade?(response)
       end
       response
     end
 
     def transaction(env)
-      input, method, routing_args = *extract_required_args(env)
-      response = yield(input, method, routing_args)
+      input, method = *extract_input_and_method(env)
+      response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
       neighbor = greedy_match?(input)
-      return unless neighbor
 
-      (!cascade && neighbor) ? call_with_allow_headers(env, neighbor.allow_header, neighbor.endpoint) : nil
+      # If neighbor exists and request method is OPTIONS,
+      # return response by using #call_with_allow_headers.
+      return call_with_allow_headers(
+        env,
+        neighbor.allow_header,
+        neighbor.endpoint
+      ) if neighbor && method == 'OPTIONS' && !cascade
+
+      route = match?(input, '*')
+      if route
+        response = process_route(route, env)
+        return response if response && !(cascade = cascade?(response))
+      end
+
+      !cascade && neighbor ? call_with_allow_headers(env, neighbor.allow_header, neighbor.endpoint) : nil
+    end
+
+    def process_route(route, env)
+      input, = *extract_input_and_method(env)
+      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
+      route.exec(env)
     end
 
     def make_routing_args(default_args, route, input)
@@ -103,11 +124,10 @@ module Grape
       args.merge(route.params(input))
     end
 
-    def extract_required_args(env)
+    def extract_input_and_method(env)
       input = string_for(env[Grape::Http::Headers::PATH_INFO])
       method = env[Grape::Http::Headers::REQUEST_METHOD]
-      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
-      [input, method, routing_args]
+      [input, method]
     end
 
     def with_optimization
@@ -141,10 +161,6 @@ module Grape
       response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass'
     end
 
-    def routes_for(method)
-      map[method] + map['ANY']
-    end
-
     def string_for(input)
       self.class.normalize_path(input)
     end

data/lib/grape/router/attribute_translator.rb

@@ -13,7 +13,7 @@ module Grape
       def method_missing(m, *args)
         if m[-1] == '='
           @attributes[m[0..-1]] = *args
-        else
+        elsif m[-1] != '='
           @attributes[m]
         end
       end

data/lib/grape/router/pattern.rb

@@ -35,7 +35,15 @@ module Grape
       end
 
       def build_path(pattern, anchor: false, suffix: nil, **_options)
-        pattern << '*path' unless anchor || pattern.end_with?('*path')
+        unless anchor || pattern.end_with?('*path')
+          pattern << '/' unless pattern.end_with?('/')
+          pattern << '*path'
+        end
+
+        pattern = pattern.split('/').tap do |parts|
+          parts[parts.length - 1] = '?' + parts.last
+        end.join('/') if pattern.end_with?('*path')
+
         pattern + suffix.to_s
       end
 

data/lib/grape/router/route.rb

@@ -28,6 +28,10 @@ module Grape
         end
       end
 
+      def respond_to_missing?(method_id, _)
+        ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
+      end
+
       [
         :prefix,
         :version,

data/lib/grape/validations/params_scope.rb

@@ -16,6 +16,7 @@ module Grape
       # @option opts :optional [Boolean] whether or not this scope needs to have
       #   any parameters set or not
       # @option opts :type [Class] a type meant to govern this scope (deprecated)
+      # @option opts :type [Hash] group options for this scope
       # @option opts :dependent_on [Symbol] if present, this scope should only
       #   validate if this param is present in the parent scope
       # @yield the instance context, open for parameter definitions
@@ -25,8 +26,10 @@ module Grape
         @api          = opts[:api]
         @optional     = opts[:optional] || false
         @type         = opts[:type]
+        @group        = opts[:group] || {}
         @dependent_on = opts[:dependent_on]
         @declared_params = []
+        @index = nil
 
         instance_eval(&block) if block_given?
 
@@ -55,11 +58,10 @@ module Grape
 
       # @return [String] the proper attribute name, with nesting considered.
       def full_name(name)
-        case
-        when nested?
+        if nested?
           # Find our containing element's name, and append ours.
           "#{@parent.full_name(@element)}#{array_index}[#{name}]"
-        when lateral?
+        elsif lateral?
           # Find the name of the element as if it was at the
           # same nesting level as our parent.
           @parent.full_name(name)
@@ -168,7 +170,8 @@ module Grape
           parent:   self,
           optional: optional,
           type:     opts[:type],
-          &block)
+          &block
+        )
       end
 
       # Returns a new parameter scope, not nested under any current-level param
@@ -186,7 +189,22 @@ module Grape
           options:      @optional,
           type:         Hash,
           dependent_on: options[:dependent_on],
-          &block)
+          &block
+        )
+      end
+
+      # Returns a new parameter scope, subordinate to the current one and nested
+      # under the parameter corresponding to `attrs.first`.
+      # @param attrs [Array] the attributes passed to the `requires` or
+      #   `optional` invocation that opened this scope.
+      # @yield parameter scope
+      def new_group_scope(attrs, &block)
+        self.class.new(
+          api:          @api,
+          parent:       self,
+          group:        attrs.first,
+          &block
+        )
       end
 
       # Pushes declared params to parent or settings
@@ -369,7 +387,7 @@ module Grape
       def extract_message_option(attrs)
         return nil unless attrs.is_a?(Array)
         opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
-        (opts.key?(:message) && !opts[:message].nil?) ? opts.delete(:message) : nil
+        opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
       end
 
       def options_key?(type, key, validations)

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

@@ -39,13 +39,12 @@ module Grape
       def validate!(params)
         attributes = AttributesIterator.new(self, @scope, params)
         array_errors = []
-        attributes.each do |resource_params, attr_name, inside_array|
+        attributes.each do |resource_params, attr_name|
           next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
 
           begin
             validate_param!(attr_name, resource_params)
           rescue Grape::Exceptions::Validation => e
-            raise e unless inside_array
             # we collect errors inside array because
             # there may be more than one error per field
             array_errors << e

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

@@ -2,7 +2,8 @@ module Grape
   module Validations
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
-        return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ (options_key?(:value) ? @option[:value] : @option))
+        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)) }
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
       end
     end

data/lib/grape/version.rb

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

data/spec/grape/api/patch_method_helpers_spec.rb

@@ -12,8 +12,7 @@ describe Grape::API::Helpers do
     end
 
     module AuthMethods
-      def authenticate!
-      end
+      def authenticate!; end
     end
 
     class PatchPrivate < Grape::API

data/spec/grape/api_spec.rb

@@ -508,6 +508,37 @@ describe Grape::API do
       end
     end
 
+    it 'allows for catch-all in a namespace' do
+      subject.namespace :nested do
+        get do
+          'root'
+        end
+
+        get 'something' do
+          'something'
+        end
+
+        route :any, '*path' do
+          'catch-all'
+        end
+      end
+
+      get 'nested'
+      expect(last_response.body).to eql 'root'
+
+      get 'nested/something'
+      expect(last_response.body).to eql 'something'
+
+      get 'nested/missing'
+      expect(last_response.body).to eql 'catch-all'
+
+      post 'nested'
+      expect(last_response.body).to eql 'catch-all'
+
+      post 'nested/something'
+      expect(last_response.body).to eql 'catch-all'
+    end
+
     verbs = %w(post get head delete put options patch)
     verbs.each do |verb|
       it "allows and properly constrain a #{verb.upcase} method" do
@@ -516,9 +547,15 @@ describe Grape::API do
         end
         send(verb, '/example')
         expect(last_response.body).to eql verb == 'head' ? '' : verb
-        # Call it with a method other than the properly constrained one.
-        send(used_verb = verbs[(verbs.index(verb) + 2) % verbs.size], '/example')
-        expect(last_response.status).to eql used_verb == 'options' ? 204 : 405
+        # Call it with all methods other than the properly constrained one.
+        (verbs - [verb]).each do |other_verb|
+          send(other_verb, '/example')
+          expected_rc = if other_verb == 'options' then 204
+                        elsif other_verb == 'head' && verb == 'get' then 200
+                        else 405
+                        end
+          expect(last_response.status).to eql expected_rc
+        end
       end
     end
 
@@ -549,6 +586,7 @@ describe Grape::API do
         before_validation { raise 'before_validation filter should not run' }
         after_validation  { raise 'after_validation filter should not run' }
         after             { raise 'after filter should not run' }
+        params { requires :only_for_get }
         get
       end
 
@@ -573,6 +611,26 @@ describe Grape::API do
       expect(last_response.headers['X-Custom-Header']).to eql 'foo'
     end
 
+    it 'runs all filters and body with a custom OPTIONS method' do
+      subject.namespace :example do
+        before            { header 'X-Custom-Header-1', 'foo' }
+        before_validation { header 'X-Custom-Header-2', 'foo' }
+        after_validation  { header 'X-Custom-Header-3', 'foo' }
+        after             { header 'X-Custom-Header-4', 'foo' }
+        options { 'yup' }
+        get
+      end
+
+      options '/example'
+      expect(last_response.status).to eql 200
+      expect(last_response.body).to eql 'yup'
+      expect(last_response.headers['Allow']).to be_nil
+      expect(last_response.headers['X-Custom-Header-1']).to eql 'foo'
+      expect(last_response.headers['X-Custom-Header-2']).to eql 'foo'
+      expect(last_response.headers['X-Custom-Header-3']).to eql 'foo'
+      expect(last_response.headers['X-Custom-Header-4']).to eql 'foo'
+    end
+
     context 'when format is xml' do
       it 'returns a 405 for an unsupported method' do
         subject.format :xml
@@ -594,8 +652,8 @@ XML
     context 'when accessing env' do
       it 'returns a 405 for an unsupported method' do
         subject.before do
-          _custom_header_1 = headers['X-Custom-Header']
-          _custom_header_2 = env['HTTP_X_CUSTOM_HEADER']
+          _customheader1 = headers['X-Custom-Header']
+          _customheader2 = env['HTTP_X_CUSTOM_HEADER']
         end
         subject.get 'example' do
           'example'
@@ -630,7 +688,11 @@ XML
 
     describe 'adds an OPTIONS route that' do
       before do
-        subject.before { header 'X-Custom-Header', 'foo' }
+        subject.before            { header 'X-Custom-Header', 'foo' }
+        subject.before_validation { header 'X-Custom-Header-2', 'bar' }
+        subject.after_validation  { header 'X-Custom-Header-3', 'baz' }
+        subject.after             { header 'X-Custom-Header-4', 'bing' }
+        subject.params { requires :only_for_get }
         subject.get 'example' do
           'example'
         end
@@ -652,10 +714,22 @@ XML
         expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
       end
 
-      it 'has a X-Custom-Header' do
+      it 'calls before hook' do
         expect(last_response.headers['X-Custom-Header']).to eql 'foo'
       end
 
+      it 'does not call before_validation hook' do
+        expect(last_response.headers.key?('X-Custom-Header-2')).to be false
+      end
+
+      it 'does not call after_validation hook' do
+        expect(last_response.headers.key?('X-Custom-Header-3')).to be false
+      end
+
+      it 'calls after hook' do
+        expect(last_response.headers['X-Custom-Header-4']).to eq 'bing'
+      end
+
       it 'has no Content-Type' do
         expect(last_response.content_type).to be_nil
       end
@@ -712,9 +786,6 @@ XML
         subject.post :example do
           'example'
         end
-        subject.route :any, '*path' do
-          error! :not_found, 404
-        end
         get '/example'
       end
 
@@ -1131,7 +1202,7 @@ XML
         def initialize(app, *args)
           @args = args
           @app = app
-          @block = true if block_given?
+          @block = block_given? ? true : nil
         end
 
         def call(env)
@@ -2555,13 +2626,11 @@ XML
           params: {
             'param1' => { required: true },
             'param2' => { required: false }
-          }
-        },
+          } },
         { description: 'global description',
           params: {
             'param2' => { required: false }
-          }
-        }
+          } }
       ]
     end
     it 'merges the parameters of the namespace with the parameters of the method' do
@@ -2585,8 +2654,7 @@ XML
           params: {
             'ns_param' => { required: true, desc: 'namespace parameter' },
             'method_param' => { required: false, desc: 'method parameter' }
-          }
-        }
+          } }
       ]
     end
     it 'merges the parameters of nested namespaces' do
@@ -2618,8 +2686,7 @@ XML
             'ns1_param' => { required: true, desc: 'ns1 param' },
             'ns2_param' => { required: true, desc: 'ns2 param' },
             'method_param' => { required: false, desc: 'method param' }
-          }
-        }
+          } }
       ]
     end
     it 'groups nested params and prevents overwriting of params with same name in different groups' do
@@ -2662,8 +2729,7 @@ XML
             'root_param' => { required: true, desc: 'root param' },
             'nested' => { required: true, type: 'Array' },
             'nested[nested_param]' => { required: true, desc: 'nested param' }
-          }
-        }
+          } }
       ]
     end
     it 'allows to set the type attribute on :group element' do