grape 1.3.0 → 1.5.0

data/lib/grape/namespace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/cache'
+
 module Grape
   # A container for endpoints or other namespaces, which allows for both
   # logical grouping of endpoints as well as sharing common configuration.
@@ -25,13 +27,21 @@ module Grape
 
     # (see ::joined_space_path)
     def self.joined_space(settings)
-      (settings || []).map(&:space).join('/')
+      settings&.map(&:space)
     end
 
     # Join the namespaces from a list of settings to create a path prefix.
     # @param settings [Array] list of Grape::Util::InheritableSettings.
     def self.joined_space_path(settings)
-      Grape::Router.normalize_path(joined_space(settings))
+      Grape::Router.normalize_path(JoinedSpaceCache[joined_space(settings)])
+    end
+
+    class JoinedSpaceCache < Grape::Util::Cache
+      def initialize
+        @cache = Hash.new do |h, joined_space|
+          h[joined_space] = -joined_space.join('/')
+        end
+      end
     end
   end
 end

data/lib/grape/path.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/cache'
+
 module Grape
   # Represents a path to an endpoint.
   class Path
@@ -40,11 +42,11 @@ module Grape
     end
 
     def namespace?
-      namespace && namespace.to_s =~ /^\S/ && namespace != '/'
+      namespace&.match?(/^\S/) && namespace != '/'
     end
 
     def path?
-      raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
+      raw_path&.match?(/^\S/) && raw_path != '/'
     end
 
     def suffix
@@ -58,7 +60,7 @@ module Grape
     end
 
     def path
-      Grape::Router.normalize_path(parts.join('/'))
+      Grape::Router.normalize_path(PartsCache[parts])
     end
 
     def path_with_suffix
@@ -71,6 +73,14 @@ module Grape
 
     private
 
+    class PartsCache < Grape::Util::Cache
+      def initialize
+        @cache = Hash.new do |h, parts|
+          h[parts] = -parts.join('/')
+        end
+      end
+    end
+
     def parts
       parts = [mount_path, root_prefix].compact
       parts << ':version' if uses_path_versioning?

data/lib/grape/request.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require 'grape/util/lazy_object'
+
 module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'
 
     alias rack_params params
 
-    def initialize(env, options = {})
+    def initialize(env, **options)
       extend options[:build_params_with] || Grape.config.param_builder
       super(env)
     end
@@ -30,14 +32,17 @@ module Grape
     end
 
     def build_headers
-      headers = {}
-      env.each_pair do |k, v|
-        next unless k.to_s.start_with? HTTP_PREFIX
-
-        k = k[5..-1].split('_').each(&:capitalize!).join('-')
-        headers[k] = v
+      Grape::Util::LazyObject.new do
+        env.each_pair.with_object({}) do |(k, v), headers|
+          next unless k.to_s.start_with? HTTP_PREFIX
+          transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
+          headers[transformed_header] = v
+        end
       end
-      headers
+    end
+
+    def transform_header(header)
+      -header[5..-1].split('_').each(&:capitalize!).join('-')
     end
   end
 end

data/lib/grape/router.rb

@@ -1,21 +1,12 @@
 # frozen_string_literal: true
 
 require 'grape/router/route'
+require 'grape/util/cache'
 
 module Grape
   class Router
     attr_reader :map, :compiled
 
-    class Any < AttributeTranslator
-      attr_reader :pattern, :regexp, :index
-      def initialize(pattern, regexp, index, **attributes)
-        @pattern = pattern
-        @regexp = regexp
-        @index = index
-        super(attributes)
-      end
-    end
-
     def self.normalize_path(path)
       path = +"/#{path}"
       path.squeeze!('/')
@@ -30,18 +21,20 @@ module Grape
 
     def initialize
       @neutral_map = []
+      @neutral_regexes = []
       @map = Hash.new { |hash, key| hash[key] = [] }
       @optimized_map = Hash.new { |hash, key| hash[key] = // }
     end
 
     def compile!
       return if compiled
-      @union = Regexp.union(@neutral_map.map(&:regexp))
+      @union = Regexp.union(@neutral_regexes)
+      @neutral_regexes = nil
       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 = Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
+          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
         end
         @optimized_map[method] = Regexp.union(@optimized_map[method])
       end
@@ -53,8 +46,8 @@ module Grape
     end
 
     def associate_routes(pattern, **options)
-      regexp = Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Any.new(pattern, regexp, @neutral_map.length, **options)
+      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
+      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
     end
 
     def call(env)
@@ -98,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 == '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)
@@ -159,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
-      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

@@ -6,17 +6,38 @@ module Grape
     class AttributeTranslator
       attr_reader :attributes, :request_method, :requirements
 
-      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/pattern.rb

@@ -2,35 +2,32 @@
 
 require 'forwardable'
 require 'mustermann/grape'
+require 'grape/util/cache'
 
 module Grape
   class Router
     class Pattern
-      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true, type: :grape }.freeze
+      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
       DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
 
-      attr_reader :origin, :path, :capture, :pattern
+      attr_reader :origin, :path, :pattern, :to_regexp
 
       extend Forwardable
       def_delegators :pattern, :named_captures, :params
-      def_delegators :@regexp, :===
+      def_delegators :to_regexp, :===
       alias match? ===
 
       def initialize(pattern, **options)
         @origin  = pattern
         @path    = build_path(pattern, **options)
-        @capture = extract_capture(**options)
-        @pattern = Mustermann.new(@path, **pattern_options)
-        @regexp  = to_regexp
-      end
-
-      def to_regexp
-        @to_regexp ||= @pattern.to_regexp
+        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+        @to_regexp = @pattern.to_regexp
       end
 
       private
 
-      def pattern_options
+      def pattern_options(options)
+        capture = extract_capture(**options)
         options = DEFAULT_PATTERN_OPTIONS.dup
         options[:capture] = capture if capture.present?
         options
@@ -43,23 +40,27 @@ module Grape
           pattern << '*path'
         end
 
-        pattern = pattern.split('/').tap do |parts|
+        pattern = -pattern.split('/').tap do |parts|
           parts[parts.length - 1] = '?' + parts.last
         end.join('/') if pattern.end_with?('*path')
 
-        "#{pattern}#{suffix}"
+        PatternCache[[pattern, suffix]]
       end
 
       def extract_capture(requirements: {}, **options)
         requirements = {}.merge(requirements)
-        supported_capture.each_with_object(requirements) do |field, capture|
+        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
           option = Array(options[field])
           capture[field] = option.map(&:to_s) if option.present?
         end
       end
 
-      def supported_capture
-        DEFAULT_SUPPORTED_CAPTURE
+      class PatternCache < Grape::Util::Cache
+        def initialize
+          @cache = Hash.new do |h, (pattern, suffix)|
+            h[[pattern, suffix]] = -"#{pattern}#{suffix}"
+          end
+        end
       end
     end
   end

data/lib/grape/router/route.rb

@@ -8,16 +8,17 @@ require 'pathname'
 module Grape
   class Router
     class Route
-      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/
+      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
       FIXED_NAMED_CAPTURES = %w[format version].freeze
 
-      attr_accessor :pattern, :translator, :app, :index, :regexp, :options
+      attr_accessor :pattern, :translator, :app, :index, :options
 
       alias attributes translator
 
       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)
@@ -31,26 +32,7 @@ module Grape
       end
 
       def respond_to_missing?(method_id, _)
-        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
+        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
       def route_method
@@ -67,7 +49,6 @@ module Grape
         method_s = method.to_s
         method_upcase = Grape::Http::Headers.find_supported_method(method_s) || method_s.upcase
 
-        @suffix     = options[:suffix]
         @options    = options.merge(method: method_upcase)
         @pattern    = Pattern.new(pattern, **options)
         @translator = AttributeTranslator.new(**options, request_method: method_upcase)

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