grape 1.3.2 → 1.5.2

data/lib/grape/exceptions/validation.rb

@@ -17,7 +17,7 @@ module Grape
         super(**args)
       end
 
-      # remove all the unnecessary stuff from Grape::Exceptions::Base like status
+      # Remove all the unnecessary stuff from Grape::Exceptions::Base like status
       # and headers when converting a validation error to json or string
       def as_json(*_args)
         to_s

data/lib/grape/exceptions/validation_errors.rb

@@ -39,7 +39,7 @@ module Grape
         end
       end
 
-      def to_json(**_opts)
+      def to_json(*_opts)
         as_json.to_json
       end
 

data/lib/grape/middleware/auth/base.rb

@@ -10,9 +10,9 @@ module Grape
 
         attr_accessor :options, :app, :env
 
-        def initialize(app, **options)
+        def initialize(app, *options)
           @app = app
-          @options = options
+          @options = options.shift
         end
 
         def call(env)
@@ -23,7 +23,7 @@ module Grape
           self.env = env
 
           if options.key?(:type)
-            auth_proc         = options[:proc]
+            auth_proc = options[:proc]
             auth_proc_context = context
 
             strategy_info = Grape::Middleware::Auth::Strategies[options[:type]]

data/lib/grape/middleware/base.rb

@@ -8,15 +8,16 @@ module Grape
       include Helpers
 
       attr_reader :app, :env, :options
+
       TEXT_HTML = 'text/html'
 
       include Grape::DSL::Headers
 
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
-      def initialize(app, **options)
+      def initialize(app, *options)
         @app = app
-        @options = default_options.merge(**options)
+        @options = options.any? ? default_options.merge(options.shift) : default_options
         @app_response = nil
       end
 

data/lib/grape/middleware/error.rb

@@ -19,15 +19,15 @@ module Grape
           rescue_subclasses: true, # rescue subclasses of exceptions listed
           rescue_options: {
             backtrace: false, # true to display backtrace, true to let Grape handle Grape::Exceptions
-            original_exception: false, # true to display exception
+            original_exception: false # true to display exception
           },
           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
+          all_rescue_handler: nil # rescue handler block to rescue from all exceptions
         }
       end
 
-      def initialize(app, **options)
+      def initialize(app, *options)
         super
         self.class.send(:include, @options[:helpers]) if @options[:helpers]
       end
@@ -38,15 +38,15 @@ module Grape
           error_response(catch(:error) do
             return @app.call(@env)
           end)
-        rescue Exception => error # rubocop:disable Lint/RescueException
+        rescue Exception => e # rubocop:disable Lint/RescueException
           handler =
-            rescue_handler_for_base_only_class(error.class) ||
-            rescue_handler_for_class_or_its_ancestor(error.class) ||
-            rescue_handler_for_grape_exception(error.class) ||
-            rescue_handler_for_any_class(error.class) ||
+            rescue_handler_for_base_only_class(e.class) ||
+            rescue_handler_for_class_or_its_ancestor(e.class) ||
+            rescue_handler_for_grape_exception(e.class) ||
+            rescue_handler_for_any_class(e.class) ||
             raise
 
-          run_rescue_handler(handler, error)
+          run_rescue_handler(handler, e)
         end
       end
 
@@ -65,15 +65,13 @@ module Grape
         message = error[:message] || options[:default_message]
         headers = { Grape::Http::Headers::CONTENT_TYPE => content_type }
         headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
-        backtrace = error[:backtrace] || error[:original_exception] && error[:original_exception].backtrace || []
+        backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
         original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
         rack_response(format_message(message, backtrace, original_exception), status, headers)
       end
 
       def rack_response(message, status = options[:default_status], headers = { Grape::Http::Headers::CONTENT_TYPE => content_type })
-        if headers[Grape::Http::Headers::CONTENT_TYPE] == TEXT_HTML
-          message = ERB::Util.html_escape(message)
-        end
+        message = ERB::Util.html_escape(message) if headers[Grape::Http::Headers::CONTENT_TYPE] == TEXT_HTML
         Rack::Response.new([message], status, headers)
       end
 

data/lib/grape/middleware/formatter.rb

@@ -36,9 +36,9 @@ module Grape
       def build_formatted_response(status, headers, bodies)
         headers = ensure_content_type(headers)
 
-        if bodies.is_a?(Grape::ServeFile::FileResponse)
-          Grape::ServeFile::SendfileResponse.new([], status, headers) do |resp|
-            resp.body = bodies.file
+        if bodies.is_a?(Grape::ServeStream::StreamResponse)
+          Grape::ServeStream::SendfileResponse.new([], status, headers) do |resp|
+            resp.body = bodies.stream
           end
         else
           # Allow content-type to be explicitly overwritten

data/lib/grape/middleware/stack.rb

@@ -30,6 +30,10 @@ module Grape
         def inspect
           klass.to_s
         end
+
+        def use_in(builder)
+          builder.use(@klass, *@args, &@block)
+        end
       end
 
       include Enumerable
@@ -62,6 +66,7 @@ module Grape
         middleware = self.class::Middleware.new(*args, &block)
         middlewares.insert(index, middleware)
       end
+      ruby2_keywords :insert if respond_to?(:ruby2_keywords, true)
 
       alias insert_before insert
 
@@ -69,11 +74,13 @@ module Grape
         index = assert_index(index, :after)
         insert(index + 1, *args, &block)
       end
+      ruby2_keywords :insert_after if respond_to?(:ruby2_keywords, true)
 
       def use(*args, &block)
         middleware = self.class::Middleware.new(*args, &block)
         middlewares.push(middleware)
       end
+      ruby2_keywords :use if respond_to?(:ruby2_keywords, true)
 
       def merge_with(middleware_specs)
         middleware_specs.each do |operation, *args|
@@ -90,7 +97,7 @@ module Grape
       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)
+          m.use_in(builder)
         end
         builder
       end

data/lib/grape/request.rb

@@ -8,7 +8,7 @@ module Grape
 
     alias rack_params params
 
-    def initialize(env, options = {})
+    def initialize(env, **options)
       extend options[:build_params_with] || Grape.config.param_builder
       super(env)
     end

data/lib/grape/router.rb

@@ -7,29 +7,12 @@ module Grape
   class Router
     attr_reader :map, :compiled
 
-    class Any < AttributeTranslator
-      attr_reader :pattern, :index
-      def initialize(pattern, index, **attributes)
-        @pattern = pattern
-        @index = index
-        super(attributes)
-      end
-    end
-
-    class NormalizePathCache < Grape::Util::Cache
-      def initialize
-        @cache = Hash.new do |h, path|
-          normalized_path = +"/#{path}"
-          normalized_path.squeeze!('/')
-          normalized_path.sub!(%r{/+\Z}, '')
-          normalized_path = '/' if normalized_path.empty?
-          h[path] = -normalized_path
-        end
-      end
-    end
-
     def self.normalize_path(path)
-      NormalizePathCache[path]
+      path = +"/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
     end
 
     def self.supported_methods
@@ -64,7 +47,7 @@ module Grape
 
     def associate_routes(pattern, **options)
       @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Any.new(pattern, @neutral_map.length, **options)
+      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
     end
 
     def call(env)
@@ -108,37 +91,34 @@ module Grape
       response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
-      neighbor = greedy_match?(input)
+      last_neighbor_route = greedy_match?(input)
 
-      # If neighbor exists and request method is OPTIONS,
+      # If last_neighbor_route 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 == Grape::Http::Headers::OPTIONS && !cascade
+      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Grape::Http::Headers::OPTIONS && !cascade
 
       route = match?(input, '*')
-      return neighbor.endpoint.call(env) if neighbor && cascade && route
+
+      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
 
       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
+      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+
+      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)
+      prepare_env_from_route(env, route)
       route.exec(env)
     end
 
     def make_routing_args(default_args, route, input)
       args = default_args || { route_info: route }
-      args.merge(route.params(input))
+      args.merge(route.params(input) || {})
     end
 
     def extract_input_and_method(env)
@@ -169,9 +149,15 @@ module Grape
       @neutral_map.detect { |route| last_match["_#{route.index}"] }
     end
 
-    def call_with_allow_headers(env, methods, endpoint)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods.join(', ').freeze
-      endpoint.call(env)
+    def call_with_allow_headers(env, route)
+      prepare_env_from_route(env, route)
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header.join(', ').freeze
+      route.endpoint.call(env)
+    end
+
+    def prepare_env_from_route(env, route)
+      input, = *extract_input_and_method(env)
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
     end
 
     def cascade?(response)

data/lib/grape/router/attribute_translator.rb

@@ -4,19 +4,40 @@ module Grape
   class Router
     # this could be an OpenStruct, but doesn't work in Ruby 2.3.0, see https://bugs.ruby-lang.org/issues/12251
     class AttributeTranslator
-      attr_reader :attributes, :request_method, :requirements
+      attr_reader :attributes
 
-      def initialize(attributes = {})
+      ROUTE_ATTRIBUTES = %i[
+        prefix
+        version
+        settings
+        format
+        description
+        http_codes
+        headers
+        entity
+        details
+        requirements
+        request_method
+        namespace
+      ].freeze
+
+      ROUTER_ATTRIBUTES = %i[pattern index].freeze
+
+      def initialize(**attributes)
         @attributes = attributes
-        @request_method = attributes[:request_method]
-        @requirements = attributes[:requirements]
+      end
+
+      (ROUTER_ATTRIBUTES + ROUTE_ATTRIBUTES).each do |attr|
+        define_method attr do
+          attributes[attr]
+        end
       end
 
       def to_h
         attributes
       end
 
-      def method_missing(method_name, *args) # rubocop:disable Style/MethodMissing
+      def method_missing(method_name, *args)
         if setter?(method_name[-1])
           attributes[method_name[0..-1]] = *args
         else

data/lib/grape/router/route.rb

@@ -18,6 +18,7 @@ module Grape
 
       extend Forwardable
       def_delegators :pattern, :path, :origin
+      delegate Grape::Router::AttributeTranslator::ROUTE_ATTRIBUTES => :attributes
 
       def method_missing(method_id, *arguments)
         match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
@@ -34,25 +35,6 @@ module Grape
         ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
-      %i[
-        prefix
-        version
-        settings
-        format
-        description
-        http_codes
-        headers
-        entity
-        details
-        requirements
-        request_method
-        namespace
-      ].each do |method_name|
-        define_method method_name do
-          attributes.public_send method_name
-        end
-      end
-
       def route_method
         warn_route_methods(:method, caller(1).shift, :request_method)
         request_method

data/lib/grape/{serve_file → serve_stream}/file_body.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
+  module ServeStream
     CHUNK_SIZE = 16_384
 
     # Class helps send file through API

data/lib/grape/{serve_file → serve_stream}/sendfile_response.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
+  module ServeStream
     # Response should respond to to_path method
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response

data/lib/grape/{serve_file/file_response.rb → serve_stream/stream_response.rb}

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 module Grape
-  module ServeFile
-    # A simple class used to identify responses which represent files and do not
+  module ServeStream
+    # A simple class used to identify responses which represent streams (or files) and do not
     # need to be formatted or pre-read by Rack::Response
-    class FileResponse
-      attr_reader :file
+    class StreamResponse
+      attr_reader :stream
 
-      # @param file [Object]
-      def initialize(file)
-        @file = file
+      # @param stream [Object]
+      def initialize(stream)
+        @stream = stream
       end
 
       # Equality provided mostly for tests.
       #
       # @return [Boolean]
       def ==(other)
-        file == other.file
+        stream == other.stream
       end
     end
   end

data/lib/grape/util/base_inheritable.rb

@@ -9,8 +9,8 @@ module Grape
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
         @new_values = {}
       end
 

data/lib/grape/util/lazy_value.rb

@@ -4,6 +4,7 @@ module Grape
   module Util
     class LazyValue
       attr_reader :access_keys
+
       def initialize(value, access_keys = [])
         @value = value
         @access_keys = access_keys