grape 2.0.0 → 2.1.1

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-require 'grape/middleware/versioner/parse_media_type_patch'
-
 module Grape
   module Middleware
     module Versioner
@@ -25,169 +22,26 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        VENDOR_VERSION_HEADER_REGEX =
-          /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
-
-        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#{Regexp.last_match(0)}\^]+/.freeze
-        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))+/.freeze
-
         def before
-          strict_header_checks if strict?
-
-          if media_type || env[Grape::Env::GRAPE_ALLOWED_METHODS]
-            media_type_header_handler
-          elsif headers_contain_wrong_vendor?
-            fail_with_invalid_accept_header!('API vendor not found.')
-          elsif headers_contain_wrong_version?
-            fail_with_invalid_version_header!('API version not found.')
-          end
-        end
-
-        private
-
-        def strict_header_checks
-          strict_accept_header_presence_check
-          strict_version_vendor_accept_header_presence_check
-        end
-
-        def strict_accept_header_presence_check
-          return unless header.qvalues.empty?
-
-          fail_with_invalid_accept_header!('Accept header must be set.')
-        end
-
-        def strict_version_vendor_accept_header_presence_check
-          return if versions.blank? || an_accept_header_with_version_and_vendor_is_present?
-
-          fail_with_invalid_accept_header!('API vendor or version not found.')
-        end
-
-        def an_accept_header_with_version_and_vendor_is_present?
-          header.qvalues.keys.any? do |h|
-            VENDOR_VERSION_HEADER_REGEX.match?(h.sub('application/', ''))
+          handler = Grape::Util::AcceptHeaderHandler.new(
+            accept_header: env[Grape::Http::Headers::HTTP_ACCEPT],
+            versions: options[:versions],
+            **options.fetch(:version_options) { {} }
+          )
+
+          handler.match_best_quality_media_type!(
+            content_types: content_types,
+            allowed_methods: env[Grape::Env::GRAPE_ALLOWED_METHODS]
+          ) do |media_type|
+            env.update(
+              Grape::Env::API_TYPE => media_type.type,
+              Grape::Env::API_SUBTYPE => media_type.subtype,
+              Grape::Env::API_VENDOR => media_type.vendor,
+              Grape::Env::API_VERSION => media_type.version,
+              Grape::Env::API_FORMAT => media_type.format
+            )
           end
         end
-
-        def header
-          @header ||= rack_accept_header
-        end
-
-        def media_type
-          @media_type ||= header.best_of(available_media_types)
-        end
-
-        def media_type_header_handler
-          type, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          env[Grape::Env::API_TYPE] = type
-          env[Grape::Env::API_SUBTYPE] = subtype
-
-          return unless VENDOR_VERSION_HEADER_REGEX =~ subtype
-
-          env[Grape::Env::API_VENDOR] = Regexp.last_match[1]
-          env[Grape::Env::API_VERSION] = Regexp.last_match[2]
-          # weird that Grape::Middleware::Formatter also does this
-          env[Grape::Env::API_FORMAT] = Regexp.last_match[3]
-        end
-
-        def fail_with_invalid_accept_header!(message)
-          raise Grape::Exceptions::InvalidAcceptHeader
-            .new(message, error_headers)
-        end
-
-        def fail_with_invalid_version_header!(message)
-          raise Grape::Exceptions::InvalidVersionHeader
-            .new(message, error_headers)
-        end
-
-        def available_media_types
-          [].tap do |available_media_types|
-            content_types.each_key do |extension|
-              versions.reverse_each do |version|
-                available_media_types << "application/vnd.#{vendor}-#{version}+#{extension}"
-                available_media_types << "application/vnd.#{vendor}-#{version}"
-              end
-              available_media_types << "application/vnd.#{vendor}+#{extension}"
-            end
-
-            available_media_types << "application/vnd.#{vendor}"
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
-
-        def headers_contain_wrong_vendor?
-          header.values.all? do |header_value|
-            vendor?(header_value) && request_vendor(header_value) != vendor
-          end
-        end
-
-        def headers_contain_wrong_version?
-          header.values.all? do |header_value|
-            version?(header_value) && versions.exclude?(request_version(header_value))
-          end
-        end
-
-        def rack_accept_header
-          Rack::Accept::MediaType.new env[Grape::Http::Headers::HTTP_ACCEPT]
-        rescue RuntimeError => e
-          fail_with_invalid_accept_header!(e.message)
-        end
-
-        def versions
-          options[:versions] || []
-        end
-
-        def vendor
-          version_options && version_options[:vendor]
-        end
-
-        def strict?
-          version_options && version_options[:strict]
-        end
-
-        def version_options
-          options[:version_options]
-        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?
-          if version_options&.key?(:cascade)
-            version_options[:cascade]
-          else
-            true
-          end
-        end
-
-        def error_headers
-          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
-        end
-
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets a vendor
-        def vendor?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VENDOR_REGEX]
-        end
-
-        def request_vendor(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[1]
-        end
-
-        def request_version(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[2]
-        end
-
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets an API version
-        def version?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VERSION_REGEX]
-        end
       end
     end
   end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -30,12 +28,12 @@ module Grape
         end
 
         def before
-          potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
+          potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[paramkey]
           return if potential_version.nil?
 
           throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
-          env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH
+          env[Rack::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Rack::RACK_REQUEST_QUERY_HASH
         end
 
         private

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -26,7 +24,7 @@ module Grape
         end
 
         def before
-          path = env[Grape::Http::Headers::PATH_INFO].dup
+          path = env[Rack::PATH_INFO].dup
           path.sub!(mount_path, '') if mounted_path?(path)
 
           if prefix && path.index(prefix) == 0 # rubocop:disable all

data/lib/grape/namespace.rb

@@ -1,7 +1,5 @@
 # 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.
@@ -33,13 +31,14 @@ module Grape
     # 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(JoinedSpaceCache[joined_space(settings)])
+      JoinedSpaceCache[joined_space(settings)]
     end
 
     class JoinedSpaceCache < Grape::Util::Cache
       def initialize
+        super
         @cache = Hash.new do |h, joined_space|
-          h[joined_space] = -joined_space.join('/')
+          h[joined_space] = Grape::Router.normalize_path(joined_space.join('/'))
         end
       end
     end

data/lib/grape/path.rb

@@ -1,14 +1,8 @@
 # frozen_string_literal: true
 
-require 'grape/util/cache'
-
 module Grape
   # Represents a path to an endpoint.
   class Path
-    def self.prepare(raw_path, namespace, settings)
-      Path.new(raw_path, namespace, settings)
-    end
-
     attr_reader :raw_path, :namespace, :settings
 
     def initialize(raw_path, namespace, settings)
@@ -22,31 +16,27 @@ module Grape
     end
 
     def root_prefix
-      split_setting(:root_prefix)
+      settings[:root_prefix]
     end
 
     def uses_specific_format?
-      if settings.key?(:format) && settings.key?(:content_types)
-        (settings[:format] && Array(settings[:content_types]).size == 1)
-      else
-        false
-      end
+      return false unless settings.key?(:format) && settings.key?(:content_types)
+
+      settings[:format] && Array(settings[:content_types]).size == 1
     end
 
     def uses_path_versioning?
-      if settings.key?(:version) && settings[:version_options] && settings[:version_options].key?(:using)
-        (settings[:version] && settings[:version_options][:using] == :path)
-      else
-        false
-      end
+      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
+
+      settings[:version] && settings[:version_options][:using] == :path
     end
 
     def namespace?
-      namespace&.match?(/^\S/) && namespace != '/'
+      namespace&.match?(/^\S/) && not_slash?(namespace)
     end
 
     def path?
-      raw_path&.match?(/^\S/) && raw_path != '/'
+      raw_path&.match?(/^\S/) && not_slash?(raw_path)
     end
 
     def suffix
@@ -60,7 +50,7 @@ module Grape
     end
 
     def path
-      Grape::Router.normalize_path(PartsCache[parts])
+      PartsCache[parts]
     end
 
     def path_with_suffix
@@ -75,24 +65,29 @@ module Grape
 
     class PartsCache < Grape::Util::Cache
       def initialize
+        super
         @cache = Hash.new do |h, parts|
-          h[parts] = -parts.join('/')
+          h[parts] = Grape::Router.normalize_path(parts.join('/'))
         end
       end
     end
 
     def parts
-      parts = [mount_path, root_prefix].compact
-      parts << ':version' if uses_path_versioning?
-      parts << namespace.to_s
-      parts << raw_path.to_s
-      parts.flatten.reject { |part| part == '/' }
+      [].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 split_setting(key)
-      return if settings[key].nil?
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
+    end
 
-      settings[key].to_s.split('/')
+    def not_slash?(value)
+      value != '/'
     end
   end
 end

data/lib/grape/request.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/util/lazy_object'
-
 module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'
@@ -36,8 +34,8 @@ module Grape
     end
 
     def build_headers
-      Grape::Util::LazyObject.new do
-        env.each_pair.with_object({}) do |(k, v), headers|
+      Grape::Util::Lazy::Object.new do
+        env.each_pair.with_object(Grape::Util::Header.new) do |(k, v), headers|
           next unless k.to_s.start_with? HTTP_PREFIX
 
           transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
@@ -46,14 +44,8 @@ module Grape
       end
     end
 
-    if Grape.lowercase_headers?
-      def transform_header(header)
-        -header[5..].tr('_', '-').downcase
-      end
-    else
-      def transform_header(header)
-        -header[5..].split('_').map(&:capitalize).join('-')
-      end
+    def transform_header(header)
+      -header[5..].tr('_', '-').downcase
     end
   end
 end

data/lib/grape/router/base_route.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class BaseRoute
+      delegate_missing_to :@options
+
+      attr_reader :index, :pattern, :options
+
+      def initialize(**options)
+        @options = ActiveSupport::OrderedOptions.new.update(options)
+      end
+
+      alias attributes options
+
+      def regexp_capture_index
+        CaptureIndexCache[index]
+      end
+
+      def pattern_regexp
+        pattern.to_regexp
+      end
+
+      def to_regexp(index)
+        @index = index
+        Regexp.new("(?<#{regexp_capture_index}>#{pattern_regexp})")
+      end
+
+      class CaptureIndexCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, index|
+            h[index] = "_#{index}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/router/greedy_route.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Act like a Grape::Router::Route but for greedy_match
+# see @neutral_map
+
+module Grape
+  class Router
+    class GreedyRoute < BaseRoute
+      def initialize(pattern:, **options)
+        @pattern = pattern
+        super(**options)
+      end
+
+      # Grape::Router:Route defines params as a function
+      def params(_input = nil)
+        options[:params] || {}
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -1,62 +1,71 @@
 # 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 :to_regexp, :===
       alias match? ===
 
       def initialize(pattern, **options)
-        @origin  = pattern
-        @path    = build_path(pattern, **options)
-        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+        @origin = pattern
+        @path = build_path(pattern, anchor: options[:anchor], suffix: options[:suffix])
+        @pattern = build_pattern(@path, options)
         @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
+      def build_pattern(path, options)
+        Mustermann::Grape.new(
+          path,
+          uri_decode: true,
+          params: options[:params],
+          capture: extract_capture(**options)
+        )
       end
 
-      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
+      def build_path(pattern, anchor: false, suffix: nil)
+        PatternCache[[build_path_from_pattern(pattern, anchor: anchor), suffix]]
+      end
 
-        pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = "?#{parts.last}"
-        end.join('/') if pattern.end_with?('*path')
+      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?
 
-        PatternCache[[pattern, suffix]]
+        options[:requirements].merge(sliced_options)
       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?
+      def build_path_from_pattern(pattern, anchor: false)
+        if pattern.end_with?('*path')
+          pattern.dup.insert(pattern.rindex('/') + 1, '?')
+        elsif anchor
+          pattern
+        elsif pattern.end_with?('/')
+          "#{pattern}?*path"
+        else
+          "#{pattern}/?*path"
         end
       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,57 +1,18 @@
 # 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
-
-      def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
-      end
-
-      def route_method
-        warn_route_methods(:method, caller(1).shift, :request_method)
-        request_method
-      end
+      attr_reader :app, :request_method
 
-      def route_path
-        warn_route_methods(:path, caller(1).shift)
-        pattern.path
-      end
+      def_delegators :pattern, :path, :origin
 
       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)
+        @request_method = upcase_method(method)
+        @pattern = Grape::Router::Pattern.new(pattern, **options)
+        super(**options)
       end
 
       def exec(env)
@@ -64,27 +25,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?
+
+        options[:forward_match] ? input.start_with?(pattern.origin) : pattern.match?(input)
       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
-        Grape.deprecator.warn("#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.")
+      def params_without_input
+        pattern.captures_default.merge(attributes.params)
+      end
+
+      def upcase_method(method)
+        method_s = method.to_s
+        Grape::Http::Headers::SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
       end
     end
   end