grape 3.2.1 → 3.3.0

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

@@ -17,12 +17,17 @@ module Grape
       #   env['api.version'] => 'v1'
       #
       class Path < Base
+        def initialize(app, **options)
+          super
+          @prefixes = [mount_path, Grape::Util::PathNormalizer.call(prefix)].select { |p| p.present? && p != '/' }.freeze
+        end
+
         def before
-          path_info = Grape::Router.normalize_path(env[Rack::PATH_INFO])
+          path_info = Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
           return if path_info == '/'
 
-          [mount_path, Grape::Router.normalize_path(prefix)].each do |path|
-            path_info = path_info.delete_prefix(path) if path.present? && path != '/' && path_info.start_with?(path)
+          path_info = @prefixes.reduce(path_info) do |pi, path|
+            pi.start_with?(path) ? pi.delete_prefix(path) : pi
           end
 
           slash_position = path_info.index('/', 1) # omit the first one

data/lib/grape/namespace.rb

@@ -23,13 +23,13 @@ module Grape
       settings&.map(&:space)
     end
 
-    def eql?(other)
+    def ==(other)
       other.class == self.class &&
         other.space == space &&
         other.requirements == requirements &&
         other.options == options
     end
-    alias == eql?
+    alias eql? ==
 
     def hash
       [self.class, space, requirements, options].hash
@@ -45,7 +45,7 @@ module Grape
       def initialize
         super
         @cache = Hash.new do |h, joined_space|
-          h[joined_space] = Grape::Router.normalize_path(joined_space.join('/'))
+          h[joined_space] = Grape::Util::PathNormalizer.call(joined_space.join('/'))
         end
       end
     end

data/lib/grape/params_builder/hash_with_indifferent_access.rb

@@ -4,7 +4,7 @@ module Grape
   module ParamsBuilder
     class HashWithIndifferentAccess < Base
       def self.call(params)
-        params.with_indifferent_access
+        ActiveSupport::HashWithIndifferentAccess.new(params)
       end
     end
   end

data/lib/grape/parser/json.rb

@@ -4,7 +4,7 @@ module Grape
   module Parser
     class Json < Base
       def self.call(object, _env)
-        ::Grape::Json.load(object)
+        ::Grape::Json.parse(object)
       rescue ::Grape::Json::ParseError
         # handle JSON parsing errors via the rescue handlers or provide error message
         raise Grape::Exceptions::InvalidMessageBody.new('application/json')

data/lib/grape/path.rb

@@ -21,23 +21,20 @@ module Grape
     private
 
     def build_suffix(raw_path, raw_namespace, settings)
-      if uses_specific_format?(settings)
-        "(.#{settings[:format]})"
-      elsif !uses_path_versioning?(settings) || (valid_part?(raw_namespace) || valid_part?(raw_path))
-        NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT
-      else
-        DEFAULT_FORMAT_SEGMENT
-      end
+      return "(.#{settings[:format]})" if uses_specific_format?(settings)
+      return NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT if !uses_path_versioning?(settings) || valid_part?(raw_namespace) || valid_part?(raw_path)
+
+      DEFAULT_FORMAT_SEGMENT
     end
 
     def build_parts(raw_path, raw_namespace, settings)
-      [].tap do |parts|
-        add_part(parts, settings[:mount_path])
-        add_part(parts, settings[:root_prefix])
-        parts << VERSION_SEGMENT if uses_path_versioning?(settings)
-        add_part(parts, raw_namespace)
-        add_part(parts, raw_path)
-      end
+      parts = []
+      add_part(parts, settings[:mount_path])
+      add_part(parts, settings[:root_prefix])
+      parts << VERSION_SEGMENT if uses_path_versioning?(settings)
+      add_part(parts, raw_namespace)
+      add_part(parts, raw_path)
+      parts
     end
 
     def add_part(parts, value)
@@ -55,9 +52,9 @@ module Grape
     end
 
     def uses_path_versioning?(settings)
-      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
+      return false unless settings.key?(:version) && settings[:version_options]
 
-      settings[:version] && settings[:version_options][:using] == :path
+      settings[:version] && settings[:version_options].using == :path
     end
 
     def valid_part?(part)
@@ -68,7 +65,7 @@ module Grape
       def initialize
         super
         @cache = Hash.new do |h, parts|
-          h[parts] = Grape::Router.normalize_path(parts.join('/'))
+          h[parts] = Grape::Util::PathNormalizer.call(parts.join('/'))
         end
       end
     end

data/lib/grape/request.rb

@@ -132,8 +132,8 @@ module Grape
       X-UA-Compatible
       X-WebKit-CS
       X-XSS-Protection
-    ].each_with_object({}) do |header, response|
-      response["HTTP_#{header.upcase.tr('-', '_')}"] = header
+    ].to_h do |header|
+      ["HTTP_#{header.upcase.tr('-', '_')}", header]
     end.freeze
 
     alias rack_params params
@@ -153,19 +153,26 @@ module Grape
     end
 
     def cookies
-      @cookies ||= Grape::Cookies.new(-> { rack_cookies })
+      @cookies ||= Grape::Cookies.new(rack_cookies)
     end
 
-    # needs to be public until extensions param_builder are removed
-    def grape_routing_args
-      # preserve version from query string parameters
-      env[Grape::Env::GRAPE_ROUTING_ARGS]&.except(:version, :route_info) || {}
+    # True once the cookie jar has been materialized (a cookie was read or
+    # written this request). Lets the endpoint skip response-cookie flushing,
+    # and the Grape::Cookies allocation it triggers, when no cookie was
+    # touched on the request.
+    def cookies?
+      !@cookies.nil?
     end
 
     private
 
     def make_params
-      @params_builder.call(rack_params).deep_merge!(grape_routing_args)
+      params = @params_builder.call(rack_params)
+      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
+      filtered = routing_args&.except(:version, :route_info)
+      return params if filtered.blank?
+
+      params.deep_merge!(filtered)
     rescue *Grape::RACK_ERRORS
       raise Grape::Exceptions::RequestError
     end

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

@@ -16,7 +16,7 @@ module Grape
       def initialize(origin:, suffix:, anchor:, params:, format:, version:, requirements:)
         @origin = origin
         @path = PatternCache[[build_path_from_pattern(@origin, anchor), suffix]]
-        @pattern = Mustermann::Grape.new(@path, uri_decode: true, params:, capture: extract_capture(format, version, requirements))
+        @pattern = MustermannPattern.new(@path, uri_decode: true, params:, capture: extract_capture(format, version, requirements))
         @to_regexp = @pattern.to_regexp
       end
 
@@ -39,15 +39,11 @@ module Grape
       end
 
       def build_path_from_pattern(pattern, anchor)
-        if pattern.end_with?('*path')
-          pattern.dup.insert(pattern.rindex('/') + 1, '?')
-        elsif anchor
-          pattern
-        elsif pattern.end_with?('/')
-          "#{pattern}?*path"
-        else
-          "#{pattern}/?*path"
-        end
+        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 map_str(value)

data/lib/grape/router.rb

@@ -2,31 +2,12 @@
 
 module Grape
   class Router
-    # Taken from Rails
-    #     normalize_path("/foo")  # => "/foo"
-    #     normalize_path("/foo/") # => "/foo"
-    #     normalize_path("foo")   # => "/foo"
-    #     normalize_path("")      # => "/"
-    #     normalize_path("/%ab")  # => "/%AB"
-    # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
+    # @deprecated Use {Grape::Util::PathNormalizer.call} instead.
     def self.normalize_path(path)
-      return '/' unless path
-      return path if path == '/'
-
-      # Fast path for the overwhelming majority of paths that don't need to be normalized
-      return path if path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//}))
-
-      # Slow path
-      encoding = path.encoding
-      path = "/#{path}"
-      path.squeeze!('/')
-
-      unless path == '/'
-        path.delete_suffix!('/')
-        path.gsub!(/(%[a-f0-9]{2})/) { ::Regexp.last_match(1).upcase }
-      end
-
-      path.force_encoding(encoding)
+      Grape.deprecator.warn(
+        '`Grape::Router.normalize_path` is deprecated. Use `Grape::Util::PathNormalizer.call` instead.'
+      )
+      Grape::Util::PathNormalizer.call(path)
     end
 
     def initialize
@@ -62,7 +43,7 @@ module Grape
 
     def call(env)
       with_optimization do
-        input = Router.normalize_path(env[Rack::PATH_INFO])
+        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)
@@ -103,20 +84,10 @@ module Grape
     end
 
     def transaction(input, method, env)
-      # using a Proc is important since `return` will exit the enclosing function
-      cascade_or_return_response = proc do |response|
-        if response
-          cascade?(response).tap do |cascade|
-            return response unless cascade
-
-            # we need to close the body if possible before dismissing
-            response[2].close if response[2].respond_to?(:close)
-          end
-        end
-      end
-
       response = yield
-      last_response_cascade = cascade_or_return_response.call(response)
+      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,
@@ -127,18 +98,33 @@ module Grape
 
       return last_neighbor_route.call(env) if last_neighbor_route && last_response_cascade && route
 
-      last_response_cascade = cascade_or_return_response.call(process_route(route, input, env)) if route
+      if route
+        route_response = process_route(route, input, env)
+        return route_response if halt?(route_response)
+
+        last_response_cascade = !route_response.nil?
+      end
 
       return process_route(last_neighbor_route, input, env, include_allow_header: true) if !last_response_cascade && last_neighbor_route
 
       nil
     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
+
+      cascade = cascade?(response)
+      response[2].close if cascade && response[2].respond_to?(:close)
+      !cascade
+    end
+
     def process_route(route, input, env, include_allow_header: false)
-      args = env[Grape::Env::GRAPE_ROUTING_ARGS] || { route_info: route }
       route_params = route.params(input)
-      routing_args = args.merge(route_params || {})
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = routing_args
+      env[Grape::Env::GRAPE_ROUTING_ARGS] ||= { route_info: route }
+      env[Grape::Env::GRAPE_ROUTING_ARGS].merge!(route_params) if route_params.present?
       env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header if include_allow_header
       route.call(env)
     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/base_inheritable.rb

@@ -4,6 +4,9 @@ module Grape
   module Util
     # Base for classes which need to operate with own values kept
     # in the hash and inherited values kept in a Hash-like object.
+    #
+    # +@new_values+ is lazily allocated on first write so settings layers
+    # that only inherit (never override) don't carry an empty Hash each.
     class BaseInheritable
       attr_accessor :inherited_values, :new_values
 
@@ -11,35 +14,29 @@ module Grape
       #   of the Hash class.
       def initialize(inherited_values = nil)
         @inherited_values = inherited_values || {}
-        @new_values = {}
+        # @new_values stays nil until the first write.
       end
 
       def delete(*keys)
-        keys.map do |key|
-          # since delete returns the deleted value, seems natural to `map` the result
-          new_values.delete key
-        end
+        return [] unless @new_values
+
+        keys.map { |key| @new_values.delete(key) }
       end
 
       def initialize_copy(other)
         super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        @inherited_values = other.inherited_values
+        @new_values = other.new_values&.dup
       end
 
       def keys
-        if new_values.any?
-          inherited_values.keys.tap do |combined|
-            combined.concat(new_values.keys)
-            combined.uniq!
-          end
-        else
-          inherited_values.keys
-        end
+        return @inherited_values.keys if @new_values.nil? || @new_values.empty?
+
+        (@inherited_values.keys + @new_values.keys).uniq
       end
 
       def key?(name)
-        inherited_values.key?(name) || new_values.key?(name)
+        @inherited_values.key?(name) || @new_values&.key?(name) || false
       end
     end
   end

data/lib/grape/util/inheritable_setting.rb

@@ -5,7 +5,17 @@ module Grape
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
+      attr_reader :route, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent
+
+      # Lazy-allocated; +api_class+ and +point_in_time_copies+ are rarely
+      # written on most settings layers, so don't pay for a Hash/Array each.
+      def api_class
+        @api_class ||= {}
+      end
+
+      def point_in_time_copies
+        @point_in_time_copies ||= []
+      end
 
       # Retrieve global settings.
       def self.global
@@ -23,17 +33,14 @@ module Grape
       # instance can then be set to inherit from an existing instance (see
       # #inherit_from).
       def initialize
-        self.route = {}
-        self.api_class = {}
-        self.namespace = InheritableValues.new # only inheritable from a parent when
+        @route = {}
+        @namespace = InheritableValues.new # only inheritable from a parent when
         # used with a mount, or should every API::Class be a separate namespace by default?
-        self.namespace_inheritable = InheritableValues.new
-        self.namespace_stackable = StackableValues.new
-        self.namespace_reverse_stackable = ReverseStackableValues.new
-
-        self.point_in_time_copies = []
-
-        self.parent = nil
+        @namespace_inheritable = InheritableValues.new
+        @namespace_stackable = StackableValues.new
+        @namespace_reverse_stackable = ReverseStackableValues.new
+        @parent = nil
+        # @api_class and @point_in_time_copies stay nil until first access.
       end
 
       # Return the class-level global properties.
@@ -48,14 +55,14 @@ module Grape
       def inherit_from(parent)
         return if parent.nil?
 
-        self.parent = parent
+        @parent = parent
 
         namespace_inheritable.inherited_values = parent.namespace_inheritable
         namespace_stackable.inherited_values = parent.namespace_stackable
         namespace_reverse_stackable.inherited_values = parent.namespace_reverse_stackable
-        self.route = parent.route.merge(route)
+        @route = parent.route.merge(route)
 
-        point_in_time_copies.each { |cloned_one| cloned_one.inherit_from parent }
+        @point_in_time_copies&.each { |cloned_one| cloned_one.inherit_from parent }
       end
 
       # Create a point-in-time copy of this settings instance, with clones of
@@ -63,19 +70,11 @@ module Grape
       # changed via #inherit_from, it will copy that inheritence to any copies
       # which were made.
       def point_in_time_copy
-        self.class.new.tap do |new_setting|
-          point_in_time_copies << new_setting
-          new_setting.point_in_time_copies = []
-
-          new_setting.namespace = namespace.clone
-          new_setting.namespace_inheritable = namespace_inheritable.clone
-          new_setting.namespace_stackable = namespace_stackable.clone
-          new_setting.namespace_reverse_stackable = namespace_reverse_stackable.clone
-          new_setting.route = route.clone
-          new_setting.api_class = api_class
-
-          new_setting.inherit_from(parent)
-        end
+        new_setting = self.class.new
+        point_in_time_copies << new_setting
+        new_setting.copy_state_from(self)
+        new_setting.inherit_from(parent)
+        new_setting
       end
 
       # Resets the instance store of per-route settings.
@@ -96,12 +95,30 @@ module Grape
         }
       end
 
+      def ==(other)
+        other.is_a?(self.class) && to_hash == other.to_hash
+      end
+      alias eql? ==
+
       def namespace_stackable_with_hash(key)
         data = namespace_stackable[key]
         return if data.blank?
 
         data.each_with_object({}) { |value, result| result.deep_merge!(value) }
       end
+
+      protected
+
+      # Used by +point_in_time_copy+ to populate a freshly-built instance
+      # with cloned state from another instance of the same class.
+      def copy_state_from(source)
+        @namespace = source.namespace.clone
+        @namespace_inheritable = source.namespace_inheritable.clone
+        @namespace_stackable = source.namespace_stackable.clone
+        @namespace_reverse_stackable = source.namespace_reverse_stackable.clone
+        @route = source.route.clone
+        @api_class = source.api_class
+      end
     end
   end
 end

data/lib/grape/util/inheritable_values.rb

@@ -4,11 +4,13 @@ module Grape
   module Util
     class InheritableValues < BaseInheritable
       def [](name)
-        values[name]
+        return @inherited_values[name] unless @new_values
+
+        @new_values.fetch(name) { @inherited_values[name] }
       end
 
       def []=(name, value)
-        new_values[name] = value
+        (@new_values ||= {})[name] = value
       end
 
       def merge(new_hash)
@@ -22,7 +24,9 @@ module Grape
       protected
 
       def values
-        @inherited_values.merge(@new_values)
+        return @inherited_values.merge(@new_values) if @new_values && !@new_values.empty?
+
+        @inherited_values.is_a?(Hash) ? @inherited_values.dup : @inherited_values.to_hash
       end
     end
   end

data/lib/grape/util/lazy/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      # Abstract parent for lazy wrappers used by the remount/configuration
+      # machinery. Call sites can type-check with +is_a?(Grape::Util::Lazy::Base)+
+      # instead of enumerating the concrete subclasses.
+      class Base
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/lazy/block.rb

@@ -3,8 +3,9 @@
 module Grape
   module Util
     module Lazy
-      class Block
+      class Block < Base
         def initialize(&new_block)
+          super()
           @block = new_block
         end
 
@@ -15,14 +16,6 @@ module Grape
         def evaluate
           @block.call({})
         end
-
-        def lazy?
-          true
-        end
-
-        def to_s
-          evaluate.to_s
-        end
       end
     end
   end