grape 1.8.0 → 3.3.5

data/lib/grape/router/mustermann_pattern.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    # Grape-style path patterns for Mustermann: `:param`, `*splat`, `{name}` /
+    # `{+splat}`, `( )` optionals, `|`, and an Integer digit-only constraint
+    # (driven by Grape's `params` option).
+    #
+    # Inlined from the mustermann-grape gem (MIT) by namusyaka, Konstantin Haase
+    # and Daniel Doubrovkine. Grape instantiates this class directly (see
+    # {Grape::Router::Pattern}), so unlike the gem it is not registered as a
+    # Mustermann `type: :grape`.
+    class MustermannPattern < ::Mustermann::AST::Pattern
+      supported_options :params
+
+      on(nil, '?', ')') { |c| unexpected(c) }
+
+      on('*') { |_c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+      on(':') do |_c|
+        param_name = scan(/\w+/)
+        # Integer params (declared via Grape's `params` option) match digits only;
+        # any other capture matches a single path segment (anything but / ? # .).
+        param_type = pattern&.options&.dig(:params, param_name, :type)
+        constraint = param_type == 'Integer' ? /\d/ : '[^/?#.]'
+        node(:capture, param_name, constraint:) { scan(/\w+/) }
+      end
+      on('\\') { |_c| node(:char, expect(/./)) }
+      on('(') { |_c| node(:optional, node(:group) { read unless scan(')') }) }
+      on('|') { |_c| node(:or) }
+
+      on('{') do |_c|
+        type = scan('+') ? :named_splat : :capture
+        name = expect(/[\w.]+/)
+        type = :splat if (type == :named_splat) && (name == 'splat')
+        expect('}')
+        node(type, name)
+      end
+
+      suffix('?') do |_c, element|
+        node(:optional, element)
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -1,62 +1,58 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'mustermann/grape'
-require 'grape/util/cache'
-
 module Grape
   class Router
     class Pattern
-      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
-      DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
+      extend Forwardable
+
+      DEFAULT_CAPTURES = %w[format version].freeze
 
       attr_reader :origin, :path, :pattern, :to_regexp
 
-      extend Forwardable
-      def_delegators :pattern, :named_captures, :params
+      def_delegators :pattern, :params
       def_delegators :to_regexp, :===
       alias match? ===
 
-      def initialize(pattern, **options)
-        @origin  = pattern
-        @path    = build_path(pattern, **options)
-        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+      def initialize(origin:, suffix:, anchor:, params:, format:, version:, requirements:)
+        @origin = origin
+        @path = PatternCache[[build_path_from_pattern(@origin, anchor), suffix]]
+        @pattern = MustermannPattern.new(@path, uri_decode: true, params:, capture: extract_capture(format, version, requirements))
         @to_regexp = @pattern.to_regexp
       end
 
+      def captures_default
+        to_regexp.names
+                 .delete_if { |n| DEFAULT_CAPTURES.include?(n) }
+                 .to_h { |k| [k, ''] }
+      end
+
       private
 
-      def pattern_options(options)
-        capture = extract_capture(**options)
-        options = DEFAULT_PATTERN_OPTIONS.dup
-        options[:capture] = capture if capture.present?
-        options
-      end
+      def extract_capture(format, version, requirements)
+        capture = {}
+        capture[:format] = map_str(format) if format.present?
+        capture[:version] = map_str(version) if version.present?
 
-      def build_path(pattern, anchor: false, suffix: nil, **_options)
-        unless anchor || pattern.end_with?('*path')
-          pattern = +pattern
-          pattern << '/' unless pattern.end_with?('/')
-          pattern << '*path'
-        end
+        return capture if requirements.blank?
 
-        pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = "?#{parts.last}"
-        end.join('/') if pattern.end_with?('*path')
+        requirements.merge(capture)
+      end
 
-        PatternCache[[pattern, suffix]]
+      def build_path_from_pattern(pattern, anchor)
+        return pattern.dup.insert(pattern.rindex('/') + 1, '?') if pattern.end_with?('*path')
+        return pattern if anchor
+        return "#{pattern}?*path" if pattern.end_with?('/')
+
+        "#{pattern}/?*path"
       end
 
-      def extract_capture(requirements: {}, **options)
-        requirements = {}.merge(requirements)
-        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
-          option = Array(options[field])
-          capture[field] = option.map(&:to_s) if option.present?
-        end
+      def map_str(value)
+        Array.wrap(value).map(&:to_s)
       end
 
       class PatternCache < Grape::Util::Cache
         def initialize
+          super
           @cache = Hash.new do |h, (pattern, suffix)|
             h[[pattern, suffix]] = -"#{pattern}#{suffix}"
           end

data/lib/grape/router/route.rb

@@ -1,61 +1,26 @@
 # frozen_string_literal: true
 
-require 'grape/router/pattern'
-require 'grape/router/attribute_translator'
-require 'forwardable'
-require 'pathname'
-
 module Grape
   class Router
-    class Route
-      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, :options
-
-      alias attributes translator
-
+    class Route < BaseRoute
       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)
-        if match
-          method_name = match.captures.last.to_sym
-          warn_route_methods(method_name, caller(1).shift)
-          @options[method_name]
-        else
-          super
-        end
-      end
+      FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
+      NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
 
-      def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
-      end
+      attr_reader :app, :request_method, :index
 
-      def route_method
-        warn_route_methods(:method, caller(1).shift, :request_method)
-        request_method
-      end
+      def_delegators :@app, :call
 
-      def route_path
-        warn_route_methods(:path, caller(1).shift)
-        pattern.path
+      def initialize(endpoint, method, pattern, options)
+        super(pattern, options)
+        @app = endpoint
+        @request_method = upcase_method(method)
+        @match_function = options[:forward_match] ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
       end
 
-      def initialize(method, pattern, **options)
-        method_s = method.to_s
-        method_upcase = Grape::Http::Headers.find_supported_method(method_s) || method_s.upcase
-
-        @options    = options.merge(method: method_upcase)
-        @pattern    = Pattern.new(pattern, **options)
-        @translator = AttributeTranslator.new(**options, request_method: method_upcase)
-      end
-
-      def exec(env)
-        @app.call(env)
+      def convert_to_head_request!
+        @request_method = Rack::HEAD
       end
 
       def apply(app)
@@ -64,27 +29,29 @@ module Grape
       end
 
       def match?(input)
-        translator.respond_to?(:forward_match) && translator.forward_match ? input.start_with?(pattern.origin) : pattern.match?(input)
+        return false if input.blank?
+
+        @match_function.call(input, pattern)
       end
 
       def params(input = nil)
-        if input.nil?
-          pattern.named_captures.keys.each_with_object(translator.params) do |(key), defaults|
-            defaults[key] ||= '' unless FIXED_NAMED_CAPTURES.include?(key) || defaults.key?(key)
-          end
-        else
-          parsed = pattern.params(input)
-          parsed ? parsed.delete_if { |_, value| value.nil? }.symbolize_keys : {}
-        end
+        return params_without_input if input.blank?
+
+        parsed = pattern.params(input)
+        return unless parsed
+
+        parsed.compact.symbolize_keys
       end
 
       private
 
-      def warn_route_methods(name, location, expected = nil)
-        path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
-        path = File.realpath(path) if Pathname.new(path).relative?
-        expected ||= name
-        ActiveSupport::Deprecation.warn("#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.")
+      def params_without_input
+        @params_without_input ||= pattern.captures_default.merge(options[:params])
+      end
+
+      def upcase_method(method)
+        method_s = method.to_s
+        Grape::HTTP_SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
       end
     end
   end

data/lib/grape/router.rb

@@ -1,60 +1,57 @@
 # frozen_string_literal: true
 
-require 'grape/router/route'
-require 'grape/util/cache'
-
 module Grape
   class Router
-    attr_reader :map, :compiled
-
+    # @deprecated Use {Grape::Util::PathNormalizer.call} instead.
     def self.normalize_path(path)
-      path = +"/#{path}"
-      path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
-    end
-
-    def self.supported_methods
-      @supported_methods ||= Grape::Http::Headers::SUPPORTED_METHODS + ['*']
+      Grape.deprecator.warn(
+        '`Grape::Router.normalize_path` is deprecated. Use `Grape::Util::PathNormalizer.call` instead.'
+      )
+      Grape::Util::PathNormalizer.call(path)
     end
 
     def initialize
       @neutral_map = []
       @neutral_regexes = []
-      @map = Hash.new { |hash, key| hash[key] = [] }
-      @optimized_map = Hash.new { |hash, key| hash[key] = // }
+      # Plain hashes with no auto-vivifying default: a lookup for an HTTP method
+      # that has no routes must not insert a key. `compile!` freezes both maps,
+      # so request-time reads never mutate shared state (see #match? / #rotation).
+      @map = {}
+      @optimized_map = {}
     end
 
     def compile!
-      return if compiled
+      return if @compiled
 
       @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
-          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
-        end
-        @optimized_map[method] = Regexp.union(@optimized_map[method])
+      (Grape::HTTP_SUPPORTED_METHODS + ['*']).each do |method|
+        next unless @map.key?(method)
+
+        routes = @map[method]
+        optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
+        @optimized_map[method] = Regexp.union(optimized_map)
       end
+      @map.freeze
+      @optimized_map.freeze
       @compiled = true
     end
 
     def append(route)
-      map[route.request_method] << route
+      (@map[route.request_method] ||= []) << route
     end
 
-    def associate_routes(pattern, **options)
-      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
+    def associate_routes(greedy_route)
+      @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+      @neutral_map << greedy_route
     end
 
     def call(env)
       with_optimization do
-        response, route = identity(env)
-        response || rotation(env, route)
+        input = Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
+        method = env[Rack::REQUEST_METHOD]
+        response, route = identity(input, method, env)
+        response || rotation(input, method, env, route)
       end
     end
 
@@ -65,113 +62,101 @@ module Grape
       any.endpoint
     end
 
+    DEFAULT_RESPONSE_HEADERS = Grape::Util::Header.new.merge('X-Cascade' => 'pass').freeze
+    DEFAULT_RESPONSE_BODY = ['404 Not Found'].freeze
+
     private
 
-    def identity(env)
+    def identity(input, method, env)
       route = nil
-      response = transaction(env) do |input, method|
+      response = transaction(input, method, env) do
         route = match?(input, method)
-        process_route(route, env) if route
+        process_route(route, input, env) if route
       end
       [response, route]
     end
 
-    def rotation(env, exact_route = nil)
+    def rotation(input, method, env, exact_route)
       response = nil
-      input, method = *extract_input_and_method(env)
-      map[method].each do |route|
+      @map[method]&.each do |route|
         next if exact_route == route
         next unless route.match?(input)
 
-        response = process_route(route, env)
+        response = process_route(route, input, env)
         break unless cascade?(response)
       end
       response
     end
 
-    def transaction(env)
-      input, method = *extract_input_and_method(env)
-      response = yield(input, method)
-
-      return response if response && !(cascade = cascade?(response))
+    def transaction(input, method, env)
+      response = yield
+      return response if halt?(response)
 
+      last_response_cascade = !response.nil?
       last_neighbor_route = greedy_match?(input)
 
       # If last_neighbor_route exists and request method is OPTIONS,
-      # return response by using #call_with_allow_headers.
-      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Grape::Http::Headers::OPTIONS && !cascade
+      # return response by using #include_allow_header.
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !last_response_cascade && method == Rack::OPTIONS && last_neighbor_route
 
       route = match?(input, '*')
 
-      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
+      return last_neighbor_route.call(env) if last_neighbor_route && last_response_cascade && route
 
       if route
-        response = process_route(route, env)
-        return response if response && !(cascade = cascade?(response))
+        route_response = process_route(route, input, env)
+        return route_response if halt?(route_response)
+
+        last_response_cascade = !route_response.nil?
       end
 
-      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !last_response_cascade && last_neighbor_route
 
       nil
     end
 
-    def process_route(route, env)
-      prepare_env_from_route(env, route)
-      route.exec(env)
-    end
+    # Returns true if `response` should be returned as-is from the enclosing
+    # transaction. Closes the body as a side effect when the response is
+    # cascading so callers can safely try the next match.
+    def halt?(response)
+      return false unless response
 
-    def make_routing_args(default_args, route, input)
-      args = default_args || { route_info: route }
-      args.merge(route.params(input) || {})
+      cascade = cascade?(response)
+      response[2].close if cascade && response[2].respond_to?(:close)
+      !cascade
     end
 
-    def extract_input_and_method(env)
-      input = string_for(env[Grape::Http::Headers::PATH_INFO])
-      method = env[Grape::Http::Headers::REQUEST_METHOD]
-      [input, method]
+    # Routing args are rebuilt for every attempt: when a route cascades
+    # (X-Cascade pass), the next candidate must not observe the previous
+    # attempt's +route_info+ or path captures.
+    def process_route(route, input, env, include_allow_header: false)
+      route_params = route.params(input)
+      routing_args = { route_info: route }
+      routing_args.merge!(route_params) if route_params.present?
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = routing_args
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header if include_allow_header
+      route.call(env)
     end
 
     def with_optimization
-      compile! unless compiled
+      compile!
       yield || default_response
     end
 
     def default_response
-      [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']]
+      [404, DEFAULT_RESPONSE_HEADERS.dup, DEFAULT_RESPONSE_BODY.dup]
     end
 
     def match?(input, method)
-      current_regexp = @optimized_map[method]
-      return unless current_regexp.match(input)
-
-      last_match = Regexp.last_match
-      @map[method].detect { |route| last_match["_#{route.index}"] }
+      @optimized_map[method]&.match(input) { |m| @map[method].detect { |route| m[route.regexp_capture_index] } }
     end
 
     def greedy_match?(input)
-      return unless @union.match(input)
-
-      last_match = Regexp.last_match
-      @neutral_map.detect { |route| last_match["_#{route.index}"] }
-    end
-
-    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)
+      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_index] } }
     end
 
     def cascade?(response)
-      response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass'
-    end
-
-    def string_for(input)
-      self.class.normalize_path(input)
+      response && response[1]['X-Cascade'] == 'pass'
     end
   end
 end

data/lib/grape/serve_stream/file_body.rb

@@ -31,6 +31,7 @@ module Grape
       def ==(other)
         path == other.path
       end
+      alias eql? ==
     end
   end
 end

data/lib/grape/serve_stream/sendfile_response.rb

@@ -6,11 +6,9 @@ module Grape
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response
       def respond_to?(method_name, include_all = false)
-        if method_name == :to_path
-          @body.respond_to?(:to_path, include_all)
-        else
-          super
-        end
+        return @body.respond_to?(:to_path, include_all) if method_name == :to_path
+
+        super
       end
 
       def to_path

data/lib/grape/serve_stream/stream_response.rb

@@ -18,6 +18,7 @@ module Grape
       def ==(other)
         stream == other.stream
       end
+      alias eql? ==
     end
   end
 end

data/lib/grape/testing.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Grape
+  module Testing
+    module RunBeforeEach
+      def run
+        self.class.run_before_each(self)
+        super
+      end
+    end
+
+    module ClassMethods
+      def before_each(&block)
+        raise ArgumentError, 'a block is required' unless block
+
+        @before_each ||= []
+        @before_each << block
+      end
+
+      def reset_before_each
+        @before_each&.clear
+      end
+
+      def run_before_each(endpoint)
+        superclass.run_before_each(endpoint) unless self == Grape::Endpoint
+        @before_each&.each { |blk| blk.call(endpoint) }
+      end
+    end
+
+    Grape::Endpoint.prepend(RunBeforeEach)
+    Grape::Endpoint.extend(ClassMethods)
+  end
+end

data/lib/grape/util/api_description.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class ApiDescription
+      DSL_METHODS = %i[
+        body_name
+        consumes
+        default
+        deprecated
+        detail
+        entity
+        headers
+        hidden
+        http_codes
+        is_array
+        named
+        nickname
+        params
+        produces
+        security
+        summary
+        tags
+      ].freeze
+
+      def initialize(description, endpoint_configuration, &)
+        @endpoint_configuration = endpoint_configuration
+        @attributes = { description: }
+        instance_eval(&)
+      end
+
+      DSL_METHODS.each do |attribute|
+        define_method attribute do |value|
+          @attributes[attribute] = value
+        end
+      end
+
+      alias success entity
+      alias failure http_codes
+
+      def configuration
+        @configuration ||= eval_endpoint_config(@endpoint_configuration)
+      end
+
+      def settings
+        @attributes
+      end
+
+      private
+
+      def eval_endpoint_config(configuration)
+        return configuration if configuration.is_a?(Hash)
+
+        configuration.evaluate
+      end
+    end
+  end
+end