grape 0.16.2 → 0.17.0

data/lib/grape/exceptions/validation.rb

@@ -7,9 +7,12 @@ module Grape
       attr_accessor :message_key
 
       def initialize(args = {})
-        fail 'Params are missing:' unless args.key? :params
+        raise 'Params are missing:' unless args.key? :params
         @params = args[:params]
-        args[:message] = translate_message(args[:message]) if args.key? :message
+        if args.key?(:message)
+          @message_key = args[:message] if args[:message].is_a?(Symbol)
+          args[:message] = translate_message(args[:message])
+        end
         super
       end
 

data/lib/grape/exceptions/validation_array_errors.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Exceptions
+    class ValidationArrayErrors < Base
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+      end
+    end
+  end
+end

data/lib/grape/formatter/xml.rb

@@ -4,7 +4,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_xml if object.respond_to?(:to_xml)
-          fail Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
+          raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
         end
       end
     end

data/lib/grape/middleware/error.rb

@@ -8,29 +8,34 @@ module Grape
           default_status: 500, # default status returned on error
           default_message: '',
           format: :txt,
+          helpers: nil,
           formatters: {},
           error_formatters: {},
           rescue_all: false, # true to rescue all exceptions
+          rescue_grape_exceptions: false,
           rescue_subclasses: true, # rescue subclasses of exceptions listed
-          rescue_options: { backtrace: false }, # true to display backtrace
+          rescue_options: { backtrace: false }, # true to display backtrace, true to let Grape handle Grape::Exceptions
           rescue_handlers: {}, # rescue handler blocks
           base_only_rescue_handlers: {}, # rescue handler blocks rescuing only the base class
           all_rescue_handler: nil # rescue handler block to rescue from all exceptions
         }
       end
 
+      def initialize(app, options = {})
+        super
+        self.class.send(:include, @options[:helpers]) if @options[:helpers]
+      end
+
       def call!(env)
         @env = env
 
-        inject_helpers!
-
         begin
           error_response(catch(:error) do
             return @app.call(@env)
           end)
         rescue StandardError => e
           is_rescuable = rescuable?(e.class)
-          if e.is_a?(Grape::Exceptions::Base) && !is_rescuable
+          if e.is_a?(Grape::Exceptions::Base) && (!is_rescuable || rescuable_by_grape?(e.class))
             handler = ->(arg) { error_response(arg) }
           else
             raise unless is_rescuable
@@ -45,20 +50,23 @@ module Grape
         handler = options[:rescue_handlers].find(-> { [] }) { |error, _| klass <= error }[1]
         handler ||= options[:base_only_rescue_handlers][klass]
         handler ||= options[:all_rescue_handler]
-        with_option = options[:rescue_options][:with]
-        if with_option.instance_of?(Symbol)
-          if respond_to?(with_option)
-            handler ||= self.class.instance_method(with_option).bind(self)
-          else
-            fail NoMethodError, "undefined method `#{with_option}'"
-          end
+
+        if handler.instance_of?(Symbol)
+          raise NoMethodError, "undefined method `#{handler}'" unless respond_to?(handler)
+          handler = self.class.instance_method(handler).bind(self)
         end
+
         handler
       end
 
       def rescuable?(klass)
         return false if klass == Grape::Exceptions::InvalidVersionHeader
-        options[:rescue_all] || (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error } || (options[:base_only_rescue_handlers] || []).include?(klass)
+        rescue_all? || rescue_class_or_its_ancestor?(klass) || rescue_with_base_only_handler?(klass)
+      end
+
+      def rescuable_by_grape?(klass)
+        return false if klass == Grape::Exceptions::InvalidVersionHeader
+        options[:rescue_grape_exceptions]
       end
 
       def exec_handler(e, &handler)
@@ -69,19 +77,6 @@ module Grape
         end
       end
 
-      def inject_helpers!
-        return if helpers_available?
-        endpoint = @env['api.endpoint']
-        self.class.instance_eval do
-          include endpoint.send(:helpers)
-        end if endpoint.is_a?(Grape::Endpoint)
-        @helpers = true
-      end
-
-      def helpers_available?
-        @helpers
-      end
-
       def error!(message, status = options[:default_status], headers = {}, backtrace = [])
         headers = headers.reverse_merge(Grape::Http::Headers::CONTENT_TYPE => content_type)
         rack_response(format_message(message, backtrace), status, headers)
@@ -111,6 +106,20 @@ module Grape
         throw :error, status: 406, message: "The requested format '#{format}' is not supported." unless formatter
         formatter.call(message, backtrace, options, env)
       end
+
+      private
+
+      def rescue_all?
+        options[:rescue_all]
+      end
+
+      def rescue_class_or_its_ancestor?(klass)
+        (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error }
+      end
+
+      def rescue_with_base_only_handler?(klass)
+        (options[:base_only_rescue_handlers] || []).include?(klass)
+      end
     end
   end
 end

data/lib/grape/middleware/formatter.rb

@@ -74,7 +74,7 @@ module Grape
         return unless
           (request.post? || request.put? || request.patch? || request.delete?) &&
           (!request.form_data? || !request.media_type) &&
-          (!request.parseable_data?) &&
+          !request.parseable_data? &&
           (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
 
         return unless (input = env[Grape::Env::RACK_INPUT])
@@ -82,7 +82,7 @@ module Grape
         input.rewind
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
-          read_rack_input(body) if body && body.length > 0
+          read_rack_input(body) if body && !body.empty?
         ensure
           input.rewind
         end
@@ -98,11 +98,11 @@ module Grape
             begin
               body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
               if body.is_a?(Hash)
-                if env[Grape::Env::RACK_REQUEST_FORM_HASH]
-                  env[Grape::Env::RACK_REQUEST_FORM_HASH] = env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
-                else
-                  env[Grape::Env::RACK_REQUEST_FORM_HASH] = body
-                end
+                env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env[Grape::Env::RACK_REQUEST_FORM_HASH]
+                                                            env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
+                                                          else
+                                                            body
+                                                          end
                 env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]
               end
             rescue Grape::Exceptions::Base => e
@@ -168,8 +168,8 @@ module Grape
         vendor_prefix_pattern = /vnd\.[^+]+\+/
 
         accept.scan(accept_into_mime_and_quality)
-          .sort_by { |_, quality_preference| -quality_preference.to_f }
-          .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
+              .sort_by { |_, quality_preference| -quality_preference.to_f }
+              .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
       end
     end
   end

data/lib/grape/middleware/stack.rb

@@ -0,0 +1,110 @@
+module Grape
+  module Middleware
+    # Class to handle the stack of middlewares based on ActionDispatch::MiddlewareStack
+    # It allows to insert and insert after
+    class Stack
+      class Middleware
+        attr_reader :args, :block, :klass
+
+        def initialize(klass, *args, &block)
+          @klass = klass
+          @args = args
+          @block = block
+        end
+
+        def name
+          klass.name
+        end
+
+        def ==(other)
+          case other
+          when Middleware
+            klass == other.klass
+          when Class
+            klass == other
+          end
+        end
+
+        def inspect
+          klass.to_s
+        end
+      end
+
+      include Enumerable
+
+      attr_accessor :middlewares, :others
+
+      def initialize
+        @middlewares = []
+        @others = []
+      end
+
+      def each
+        @middlewares.each { |x| yield x }
+      end
+
+      def size
+        middlewares.size
+      end
+
+      def last
+        middlewares.last
+      end
+
+      def [](i)
+        middlewares[i]
+      end
+
+      def insert(index, *args, &block)
+        index = assert_index(index, :before)
+        middleware = self.class::Middleware.new(*args, &block)
+        middlewares.insert(index, middleware)
+      end
+
+      alias insert_before insert
+
+      def insert_after(index, *args, &block)
+        index = assert_index(index, :after)
+        insert(index + 1, *args, &block)
+      end
+
+      def use(*args, &block)
+        middleware = self.class::Middleware.new(*args, &block)
+        middlewares.push(middleware)
+      end
+
+      def merge_with(middleware_specs)
+        middleware_specs.each do |operation, *args|
+          if args.last.is_a?(Proc)
+            public_send(operation, *args, &args.pop)
+          else
+            public_send(operation, *args)
+          end
+        end
+      end
+
+      # @return [Rack::Builder] the builder object with our middlewares applied
+      def build(builder = Rack::Builder.new)
+        others.shift(others.size).each(&method(:merge_with))
+        middlewares.each do |m|
+          m.block ? builder.use(m.klass, *m.args, &m.block) : builder.use(m.klass, *m.args)
+        end
+        builder
+      end
+
+      # @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later
+      # @param [Array] other_specs An array of middleware specifications (e.g. [[:use, klass], [:insert_before, *args]])
+      def concat(other_specs)
+        @others << Array(other_specs).reject { |o| o.first == :use }
+        merge_with Array(other_specs).select { |o| o.first == :use }
+      end
+
+      protected
+
+      def assert_index(index, where)
+        i = index.is_a?(Integer) ? index : middlewares.index(index)
+        i || raise("No such middleware to insert #{where}: #{index.inspect}")
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner.rb

@@ -24,7 +24,7 @@ module Grape
         when :accept_version_header
           AcceptVersionHeader
         else
-          fail Grape::Exceptions::InvalidVersionerOption.new(strategy)
+          raise Grape::Exceptions::InvalidVersionerOption.new(strategy)
         end
       end
     end

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

@@ -50,7 +50,7 @@ module Grape
         # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
         def cascade?
           if options[:version_options] && options[:version_options].key?(:cascade)
-            !!options[:version_options][:cascade]
+            options[:version_options][:cascade]
           else
             true
           end

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

@@ -87,12 +87,12 @@ module Grape
         end
 
         def fail_with_invalid_accept_header!(message)
-          fail Grape::Exceptions::InvalidAcceptHeader
+          raise Grape::Exceptions::InvalidAcceptHeader
             .new(message, error_headers)
         end
 
         def fail_with_invalid_version_header!(message)
-          fail Grape::Exceptions::InvalidVersionHeader
+          raise Grape::Exceptions::InvalidVersionHeader
             .new(message, error_headers)
         end
 
@@ -159,7 +159,7 @@ module Grape
         # header, one can set the `:cascade` option to `false`.
         def cascade?
           if version_options && version_options.key?(:cascade)
-            !!version_options[:cascade]
+            version_options[:cascade]
           else
             true
           end

data/lib/grape/path.rb

@@ -22,11 +22,19 @@ module Grape
     end
 
     def uses_specific_format?
-      !!(settings[:format] && Array(settings[:content_types]).size == 1)
+      if settings.key?(:format) && settings.key?(:content_types)
+        (settings[:format] && Array(settings[:content_types]).size == 1)
+      else
+        false
+      end
     end
 
     def uses_path_versioning?
-      !!(settings[:version] && settings[:version_options][:using] == :path)
+      if settings.key?(:version) && settings[:version_options] && settings[:version_options].key?(:using)
+        (settings[:version] && settings[:version_options][:using] == :path)
+      else
+        false
+      end
     end
 
     def namespace?

data/lib/grape/request.rb

@@ -2,7 +2,7 @@ module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'.freeze
 
-    alias_method :rack_params, :params
+    alias rack_params params
 
     def params
       @params ||= build_params

data/lib/grape/router.rb

@@ -11,6 +11,14 @@ module Grape
       end
     end
 
+    def self.normalize_path(path)
+      path = "/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
+    end
+
     def initialize
       @neutral_map = []
       @map = Hash.new { |hash, key| hash[key] = [] }
@@ -125,17 +133,8 @@ module Grape
     end
 
     def method_not_allowed(env, methods, endpoint)
-      env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED] = true
-      current = endpoint.dup
-      current.instance_eval do
-        @lazy_initialized = false
-        lazy_initialize!
-        run_filters befores, :before
-        @block = proc do
-          fail Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => methods)
-        end
-      end
-      current.call(env)
+      env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED] = methods
+      endpoint.call(env)
     end
 
     def cascade?(response)
@@ -149,13 +148,5 @@ module Grape
     def string_for(input)
       self.class.normalize_path(input)
     end
-
-    def self.normalize_path(path)
-      path = "/#{path}"
-      path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
-    end
   end
 end

data/lib/grape/router/pattern.rb

@@ -12,7 +12,7 @@ module Grape
       extend Forwardable
       def_delegators :pattern, :named_captures, :params
       def_delegators :@regexp, :===
-      alias_method :match?, :===
+      alias match? ===
 
       def initialize(pattern, options = {})
         @origin  = pattern
@@ -30,7 +30,7 @@ module Grape
 
       def pattern_options
         options = DEFAULT_PATTERN_OPTIONS.dup
-        options.merge!(capture: capture) if capture.present?
+        options[:capture] = capture if capture.present?
         options
       end