grape 2.2.0 → 2.3.0

data/lib/grape/formatter.rb

@@ -2,24 +2,16 @@
 
 module Grape
   module Formatter
-    module_function
+    extend Grape::Util::Registry
 
-    DEFAULTS = {
-      json: Grape::Formatter::Json,
-      jsonapi: Grape::Formatter::Json,
-      serializable_hash: Grape::Formatter::SerializableHash,
-      txt: Grape::Formatter::Txt,
-      xml: Grape::Formatter::Xml
-    }.freeze
+    module_function
 
     DEFAULT_LAMBDA_FORMATTER = ->(obj, _env) { obj }
 
     def formatter_for(api_format, formatters)
-      select_formatter(formatters, api_format) || DEFAULT_LAMBDA_FORMATTER
-    end
+      return formatters[api_format] if formatters&.key?(api_format)
 
-    def select_formatter(formatters, api_format)
-      formatters&.key?(api_format) ? formatters[api_format] : DEFAULTS[api_format]
+      registry[api_format] || DEFAULT_LAMBDA_FORMATTER
     end
   end
 end

data/lib/grape/http/headers.rb

@@ -6,6 +6,7 @@ module Grape
       HTTP_ACCEPT_VERSION = 'HTTP_ACCEPT_VERSION'
       HTTP_ACCEPT = 'HTTP_ACCEPT'
       HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
+      HTTP_VERSION = 'HTTP_VERSION'
 
       ALLOW = 'Allow'
       LOCATION = 'Location'

data/lib/grape/middleware/error.rb

@@ -65,6 +65,7 @@ module Grape
 
       def error_response(error = {})
         status = error[:status] || options[:default_status]
+        env[Grape::Env::API_ENDPOINT].status(status) # error! may not have been called
         message = error[:message] || options[:default_message]
         headers = { Rack::CONTENT_TYPE => content_type }.tap do |h|
           h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
@@ -130,6 +131,7 @@ module Grape
       end
 
       def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
+        env[Grape::Env::API_ENDPOINT].status(status) # not error! inside route
         rack_response(
           status, headers.reverse_merge(Rack::CONTENT_TYPE => content_type),
           format_message(message, backtrace, original_exception)

data/lib/grape/middleware/formatter.rb

@@ -53,7 +53,7 @@ module Grape
       end
 
       def fetch_formatter(headers, options)
-        api_format = mime_types[headers[Rack::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
+        api_format = env.fetch(Grape::Env::API_FORMAT) { mime_types[headers[Rack::CONTENT_TYPE]] }
         Grape::Formatter.formatter_for(api_format, options[:formatters])
       end
 

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

@@ -17,10 +17,10 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class AcceptVersionHeader < Base
-        include VersionerHelpers
-
         def before
-          potential_version = env[Grape::Http::Headers::HTTP_ACCEPT_VERSION]&.strip
+          potential_version = env[Grape::Http::Headers::HTTP_ACCEPT_VERSION]
+          potential_version = potential_version.scrub unless potential_version.nil?
+
           not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?
 
           return if potential_version.blank?

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      class Base < Grape::Middleware::Base
+        DEFAULT_PATTERN = /.*/i.freeze
+        DEFAULT_PARAMETER = 'apiver'
+
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
+        end
+
+        def default_options
+          {
+            versions: nil,
+            prefix: nil,
+            mount_path: nil,
+            pattern: DEFAULT_PATTERN,
+            version_options: {
+              strict: false,
+              cascade: true,
+              parameter: DEFAULT_PARAMETER
+            }
+          }
+        end
+
+        def versions
+          options[:versions]
+        end
+
+        def prefix
+          options[:prefix]
+        end
+
+        def mount_path
+          options[:mount_path]
+        end
+
+        def pattern
+          options[:pattern]
+        end
+
+        def version_options
+          options[:version_options]
+        end
+
+        def strict?
+          version_options[:strict]
+        end
+
+        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
+        # of routes (see Grape::Router) for more information). To prevent
+        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
+        def cascade?
+          version_options[:cascade]
+        end
+
+        def parameter_key
+          version_options[:parameter]
+        end
+
+        def vendor
+          version_options[:vendor]
+        end
+
+        def error_headers
+          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+        end
+
+        def potential_version_match?(potential_version)
+          versions.blank? || versions.any? { |v| v.to_s == potential_version }
+        end
+
+        def version_not_found!
+          throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
+        end
+      end
+    end
+  end
+end

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

@@ -22,8 +22,6 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        include VersionerHelpers
-
         def before
           match_best_quality_media_type! do |media_type|
             env.update(
@@ -46,14 +44,10 @@ module Grape
           if media_type
             yield media_type
           else
-            fail!(allowed_methods)
+            fail!
           end
         end
 
-        def allowed_methods
-          env[Grape::Env::GRAPE_ALLOWED_METHODS]
-        end
-
         def accept_header
           env[Grape::Http::Headers::HTTP_ACCEPT]
         end
@@ -93,8 +87,8 @@ module Grape
           raise Grape::Exceptions::InvalidVersionHeader.new(message, error_headers)
         end
 
-        def fail!(grape_allowed_methods)
-          return grape_allowed_methods if grape_allowed_methods.present?
+        def fail!
+          return if env[Grape::Env::GRAPE_ALLOWED_METHODS].present?
 
           media_types = q_values_mime_types.map { |mime_type| Grape::Util::MediaType.parse(mime_type) }
           vendor_not_found!(media_types) || version_not_found!(media_types)

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

@@ -19,8 +19,6 @@ module Grape
       #
       #   env['api.version'] => 'v1'
       class Param < Base
-        include VersionerHelpers
-
         def before
           potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[parameter_key]
           return if potential_version.blank?

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

@@ -17,8 +17,6 @@ module Grape
       #   env['api.version'] => 'v1'
       #
       class Path < Base
-        include VersionerHelpers
-
         def before
           path_info = Grape::Router.normalize_path(env[Rack::PATH_INFO])
           return if path_info == '/'

data/lib/grape/middleware/versioner.rb

@@ -11,14 +11,16 @@
 module Grape
   module Middleware
     module Versioner
+      extend Grape::Util::Registry
+
       module_function
 
       # @param strategy [Symbol] :path, :header, :accept_version_header or :param
       # @return a middleware class based on strategy
       def using(strategy)
-        Grape::Middleware::Versioner.const_get(:"#{strategy.to_s.camelize}")
-      rescue NameError
-        raise Grape::Exceptions::InvalidVersionerOption, strategy
+        raise Grape::Exceptions::InvalidVersionerOption, strategy unless registry.key?(strategy)
+
+        registry[strategy]
       end
     end
   end

data/lib/grape/namespace.rb

@@ -12,7 +12,7 @@ module Grape
     # @option options :requirements [Hash] param-regex pairs, all of which must
     #   be met by a request's params for all endpoints in this namespace, or
     #   validation will fail and return a 422.
-    def initialize(space, **options)
+    def initialize(space, options)
       @space = space.to_s
       @options = options
     end

data/lib/grape/parser/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Parser.register(klass)
+      end
+    end
+  end
+end

data/lib/grape/parser/json.rb

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

data/lib/grape/parser/jsonapi.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Jsonapi < Json; end
+  end
+end

data/lib/grape/parser/xml.rb

@@ -2,14 +2,12 @@
 
 module Grape
   module Parser
-    module Xml
-      class << self
-        def call(object, _env)
-          ::Grape::Xml.parse(object)
-        rescue ::Grape::Xml::ParseError
-          # handle XML parsing errors via the rescue handlers or provide error message
-          raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
-        end
+    class Xml < Base
+      def self.call(object, _env)
+        ::Grape::Xml.parse(object)
+      rescue ::Grape::Xml::ParseError
+        # handle XML parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
       end
     end
   end

data/lib/grape/parser.rb

@@ -2,16 +2,14 @@
 
 module Grape
   module Parser
-    module_function
+    extend Grape::Util::Registry
 
-    DEFAULTS = {
-      json: Grape::Parser::Json,
-      jsonapi: Grape::Parser::Json,
-      xml: Grape::Parser::Xml
-    }.freeze
+    module_function
 
     def parser_for(format, parsers = nil)
-      parsers&.key?(format) ? parsers[format] : DEFAULTS[format]
+      return parsers[format] if parsers&.key?(format)
+
+      registry[format]
     end
   end
 end

data/lib/grape/path.rb

@@ -3,65 +3,66 @@
 module Grape
   # Represents a path to an endpoint.
   class Path
-    attr_reader :raw_path, :namespace, :settings
+    DEFAULT_FORMAT_SEGMENT = '(/.:format)'
+    NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT = '(.:format)'
+    VERSION_SEGMENT = ':version'
 
-    def initialize(raw_path, namespace, settings)
-      @raw_path = raw_path
-      @namespace = namespace
-      @settings = settings
-    end
+    attr_reader :origin, :suffix
 
-    def mount_path
-      settings[:mount_path]
+    def initialize(raw_path, raw_namespace, settings)
+      @origin = PartsCache[build_parts(raw_path, raw_namespace, settings)]
+      @suffix = build_suffix(raw_path, raw_namespace, settings)
     end
 
-    def root_prefix
-      settings[:root_prefix]
+    def to_s
+      "#{origin}#{suffix}"
     end
 
-    def uses_specific_format?
-      return false unless settings.key?(:format) && settings.key?(:content_types)
+    private
 
-      settings[:format] && Array(settings[:content_types]).size == 1
+    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
     end
 
-    def uses_path_versioning?
-      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
-
-      settings[:version] && settings[:version_options][:using] == :path
+    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
     end
 
-    def namespace?
-      namespace&.match?(/^\S/) && not_slash?(namespace)
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
     end
 
-    def path?
-      raw_path&.match?(/^\S/) && not_slash?(raw_path)
+    def not_slash?(value)
+      value != '/'
     end
 
-    def suffix
-      if uses_specific_format?
-        "(.#{settings[:format]})"
-      elsif !uses_path_versioning? || (namespace? || path?)
-        '(.:format)'
-      else
-        '(/.:format)'
-      end
-    end
+    def uses_specific_format?(settings)
+      return false unless settings.key?(:format) && settings.key?(:content_types)
 
-    def path
-      PartsCache[parts]
+      settings[:format] && Array(settings[:content_types]).size == 1
     end
 
-    def path_with_suffix
-      "#{path}#{suffix}"
-    end
+    def uses_path_versioning?(settings)
+      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
 
-    def to_s
-      path_with_suffix
+      settings[:version] && settings[:version_options][:using] == :path
     end
 
-    private
+    def valid_part?(part)
+      part&.match?(/^\S/) && not_slash?(part)
+    end
 
     class PartsCache < Grape::Util::Cache
       def initialize
@@ -71,23 +72,5 @@ module Grape
         end
       end
     end
-
-    def parts
-      [].tap do |parts|
-        add_part(parts, mount_path)
-        add_part(parts, root_prefix)
-        parts << ':version' if uses_path_versioning?
-        add_part(parts, namespace)
-        add_part(parts, raw_path)
-      end
-    end
-
-    def add_part(parts, value)
-      parts << value if value && not_slash?(value)
-    end
-
-    def not_slash?(value)
-      value != '/'
-    end
   end
 end

data/lib/grape/request.rb

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

data/lib/grape/router/base_route.rb

@@ -7,8 +7,8 @@ module Grape
 
       attr_reader :index, :pattern, :options
 
-      def initialize(**options)
-        @options = ActiveSupport::OrderedOptions.new.update(options)
+      def initialize(options)
+        @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
       end
 
       alias attributes options

data/lib/grape/router/greedy_route.rb

@@ -6,9 +6,9 @@
 module Grape
   class Router
     class GreedyRoute < BaseRoute
-      def initialize(pattern:, **options)
+      def initialize(pattern, options)
         @pattern = pattern
-        super(**options)
+        super(options)
       end
 
       # Grape::Router:Route defines params as a function

data/lib/grape/router/pattern.rb

@@ -9,14 +9,14 @@ module Grape
 
       attr_reader :origin, :path, :pattern, :to_regexp
 
-      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, anchor: options[:anchor], suffix: options[:suffix])
-        @pattern = build_pattern(@path, options)
+      def initialize(origin, suffix, options)
+        @origin = origin
+        @path = build_path(origin, options[:anchor], suffix)
+        @pattern = build_pattern(@path, options[:params], options[:format], options[:version], options[:requirements])
         @to_regexp = @pattern.to_regexp
       end
 
@@ -28,30 +28,31 @@ module Grape
 
       private
 
-      def build_pattern(path, options)
+      def build_pattern(path, params, format, version, requirements)
         Mustermann::Grape.new(
           path,
           uri_decode: true,
-          params: options[:params],
-          capture: extract_capture(**options)
+          params: params,
+          capture: extract_capture(format, version, requirements)
         )
       end
 
-      def build_path(pattern, anchor: false, suffix: nil)
-        PatternCache[[build_path_from_pattern(pattern, anchor: anchor), suffix]]
+      def build_path(pattern, anchor, suffix)
+        PatternCache[[build_path_from_pattern(pattern, anchor), suffix]]
       end
 
-      def extract_capture(**options)
-        sliced_options = options
-                         .slice(:format, :version)
-                         .delete_if { |_k, v| v.blank? }
-                         .transform_values { |v| Array.wrap(v).map(&:to_s) }
-        return sliced_options if options[:requirements].blank?
+      def extract_capture(format, version, requirements)
+        capture = {}.tap do |h|
+          h[:format] = map_str(format) if format.present?
+          h[:version] = map_str(version) if version.present?
+        end
+
+        return capture if requirements.blank?
 
-        options[:requirements].merge(sliced_options)
+        requirements.merge(capture)
       end
 
-      def build_path_from_pattern(pattern, anchor: false)
+      def build_path_from_pattern(pattern, anchor)
         if pattern.end_with?('*path')
           pattern.dup.insert(pattern.rindex('/') + 1, '?')
         elsif anchor
@@ -63,6 +64,10 @@ module Grape
         end
       end
 
+      def map_str(value)
+        Array.wrap(value).map(&:to_s)
+      end
+
       class PatternCache < Grape::Util::Cache
         def initialize
           super

data/lib/grape/router/route.rb

@@ -5,14 +5,22 @@ module Grape
     class Route < BaseRoute
       extend Forwardable
 
+      FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
+      NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
+
       attr_reader :app, :request_method
 
       def_delegators :pattern, :path, :origin
 
-      def initialize(method, pattern, **options)
+      def initialize(method, origin, path, options)
         @request_method = upcase_method(method)
-        @pattern = Grape::Router::Pattern.new(pattern, **options)
-        super(**options)
+        @pattern = Grape::Router::Pattern.new(origin, path, options)
+        @match_function = options[:forward_match] ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
+        super(options)
+      end
+
+      def convert_to_head_request!
+        @request_method = Rack::HEAD
       end
 
       def exec(env)
@@ -27,7 +35,7 @@ module Grape
       def match?(input)
         return false if input.blank?
 
-        options[:forward_match] ? input.start_with?(pattern.origin) : pattern.match?(input)
+        @match_function.call(input, pattern)
       end
 
       def params(input = nil)
@@ -42,7 +50,7 @@ module Grape
       private
 
       def params_without_input
-        pattern.captures_default.merge(attributes.params)
+        @params_without_input ||= pattern.captures_default.merge(attributes.params)
       end
 
       def upcase_method(method)

data/lib/grape/router.rb

@@ -38,8 +38,8 @@ module Grape
       map[route.request_method] << route
     end
 
-    def associate_routes(pattern, **options)
-      Grape::Router::GreedyRoute.new(pattern: pattern, **options).then do |greedy_route|
+    def associate_routes(pattern, options)
+      Grape::Router::GreedyRoute.new(pattern, options).then do |greedy_route|
         @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
         @neutral_map << greedy_route
       end
@@ -107,7 +107,7 @@ module Grape
 
       route = match?(input, '*')
 
-      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && last_response_cascade && route
+      return last_neighbor_route.options[:endpoint].call(env) if last_neighbor_route && last_response_cascade && route
 
       last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
 
@@ -152,8 +152,8 @@ module Grape
 
     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)
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.options[:allow_header]
+      route.options[:endpoint].call(env)
     end
 
     def prepare_env_from_route(env, route)