grape 2.0.0 → 2.1.2

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

data/lib/grape/router.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/router/route'
-require 'grape/util/cache'
-
 module Grape
   class Router
     attr_reader :map, :compiled
@@ -15,10 +12,6 @@ module Grape
       path
     end
 
-    def self.supported_methods
-      @supported_methods ||= Grape::Http::Headers::SUPPORTED_METHODS + ['*']
-    end
-
     def initialize
       @neutral_map = []
       @neutral_regexes = []
@@ -31,13 +24,12 @@ module Grape
 
       @union = Regexp.union(@neutral_regexes)
       @neutral_regexes = nil
-      self.class.supported_methods.each do |method|
+      (Grape::Http::Headers::SUPPORTED_METHODS + ['*']).each do |method|
+        next unless map.key?(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])
+        optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
+        @optimized_map[method] = Regexp.union(optimized_map)
       end
       @compiled = true
     end
@@ -47,8 +39,10 @@ module Grape
     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)
+      Grape::Router::GreedyRoute.new(pattern: pattern, **options).then do |greedy_route|
+        @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+        @neutral_map << greedy_route
+      end
     end
 
     def call(env)
@@ -91,26 +85,33 @@ module Grape
 
     def transaction(env)
       input, method = *extract_input_and_method(env)
-      response = yield(input, method)
 
-      return response if response && !(cascade = cascade?(response))
+      # 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
+
+      last_response_cascade = cascade_or_return_response.call(yield(input, method))
       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 call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Rack::OPTIONS && !last_response_cascade
 
       route = match?(input, '*')
 
-      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
+      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && last_response_cascade && route
 
-      if route
-        response = process_route(route, env)
-        return response if response && !(cascade = cascade?(response))
-      end
+      last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
 
-      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+      return call_with_allow_headers(env, last_neighbor_route) if !last_response_cascade && last_neighbor_route
 
       nil
     end
@@ -122,12 +123,12 @@ module Grape
 
     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)
-      input = string_for(env[Grape::Http::Headers::PATH_INFO])
-      method = env[Grape::Http::Headers::REQUEST_METHOD]
+      input = string_for(env[Rack::PATH_INFO])
+      method = env[Rack::REQUEST_METHOD]
       [input, method]
     end
 
@@ -137,22 +138,16 @@ module Grape
     end
 
     def default_response
-      [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']]
+      headers = Grape::Util::Header.new.merge(Grape::Http::Headers::X_CASCADE => 'pass')
+      [404, headers, ['404 Not Found']]
     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}"] }
+      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_index] } }
     end
 
     def call_with_allow_headers(env, route)

data/lib/grape/util/accept_header_handler.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class AcceptHeaderHandler
+      attr_reader :accept_header, :versions, :vendor, :strict, :cascade
+
+      def initialize(accept_header:, versions:, **options)
+        @accept_header = accept_header
+        @versions = versions
+        @vendor = options.fetch(:vendor, nil)
+        @strict = options.fetch(:strict, false)
+        @cascade = options.fetch(:cascade, true)
+      end
+
+      def match_best_quality_media_type!(content_types: Grape::ContentTypes::CONTENT_TYPES, allowed_methods: nil)
+        return unless vendor
+
+        strict_header_checks!
+        media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types(content_types))
+        if media_type
+          yield media_type
+        else
+          fail!(allowed_methods)
+        end
+      end
+
+      private
+
+      def strict_header_checks!
+        return unless strict
+
+        accept_header_check!
+        version_and_vendor_check!
+      end
+
+      def accept_header_check!
+        return if accept_header.present?
+
+        invalid_accept_header!('Accept header must be set.')
+      end
+
+      def version_and_vendor_check!
+        return if versions.blank? || version_and_vendor?
+
+        invalid_accept_header!('API vendor or version not found.')
+      end
+
+      def q_values_mime_types
+        @q_values_mime_types ||= Rack::Utils.q_values(accept_header).map(&:first)
+      end
+
+      def version_and_vendor?
+        q_values_mime_types.any? { |mime_type| Grape::Util::MediaType.match?(mime_type) }
+      end
+
+      def invalid_accept_header!(message)
+        raise Grape::Exceptions::InvalidAcceptHeader.new(message, error_headers)
+      end
+
+      def invalid_version_header!(message)
+        raise Grape::Exceptions::InvalidVersionHeader.new(message, error_headers)
+      end
+
+      def fail!(grape_allowed_methods)
+        return grape_allowed_methods if 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)
+      end
+
+      def vendor_not_found!(media_types)
+        return unless media_types.all? { |media_type| media_type&.vendor && media_type.vendor != vendor }
+
+        invalid_accept_header!('API vendor not found.')
+      end
+
+      def version_not_found!(media_types)
+        return unless media_types.all? { |media_type| media_type&.version && versions.exclude?(media_type.version) }
+
+        invalid_version_header!('API version not found.')
+      end
+
+      def error_headers
+        cascade ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+      end
+
+      def available_media_types(content_types)
+        [].tap do |available_media_types|
+          base_media_type = "application/vnd.#{vendor}"
+          content_types.each_key do |extension|
+            versions&.reverse_each do |version|
+              available_media_types << "#{base_media_type}-#{version}+#{extension}"
+              available_media_types << "#{base_media_type}-#{version}"
+            end
+            available_media_types << "#{base_media_type}+#{extension}"
+          end
+
+          available_media_types << base_media_type
+          available_media_types.concat(content_types.values.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/base_inheritable.rb

@@ -26,10 +26,10 @@ module Grape
 
       def keys
         if new_values.any?
-          combined = inherited_values.keys
-          combined.concat(new_values.keys)
-          combined.uniq!
-          combined
+          inherited_values.keys.tap do |combined|
+            combined.concat(new_values.keys)
+            combined.uniq!
+          end
         else
           inherited_values.keys
         end

data/lib/grape/util/cache.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require 'forwardable'
-
 module Grape
   module Util
     class Cache

data/lib/grape/util/endpoint_configuration.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Util
-    class EndpointConfiguration < LazyValueHash
+    class EndpointConfiguration < Lazy::ValueHash
     end
   end
 end

data/lib/grape/util/header.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    if Gem::Version.new(Rack.release) >= Gem::Version.new('3')
+      require 'rack/headers'
+      Header = Rack::Headers
+    else
+      require 'rack/utils'
+      Header = Rack::Utils::HeaderHash
+    end
+  end
+end

data/lib/grape/util/inheritable_values.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base_inheritable'
-
 module Grape
   module Util
     class InheritableValues < BaseInheritable

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Block
+        def initialize(&new_block)
+          @block = new_block
+        end
+
+        def evaluate_from(configuration)
+          @block.call(configuration)
+        end
+
+        def evaluate
+          @block.call({})
+        end
+
+        def lazy?
+          true
+        end
+
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Based on https://github.com/HornsAndHooves/lazy_object
+
+module Grape
+  module Util
+    module Lazy
+      class Object < BasicObject
+        attr_reader :callable
+
+        def initialize(&callable)
+          @callable = callable
+        end
+
+        def __target_object__
+          @__target_object__ ||= callable.call
+        end
+
+        def ==(other)
+          __target_object__ == other
+        end
+
+        def !=(other)
+          __target_object__ != other
+        end
+
+        def !
+          !__target_object__
+        end
+
+        def method_missing(method_name, *args, &block)
+          if __target_object__.respond_to?(method_name)
+            __target_object__.send(method_name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_priv = false)
+          __target_object__.respond_to?(method_name, include_priv)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Value
+        attr_reader :access_keys
+
+        def initialize(value, access_keys = [])
+          @value = value
+          @access_keys = access_keys
+        end
+
+        def evaluate_from(configuration)
+          matching_lazy_value = configuration.fetch(@access_keys)
+          matching_lazy_value.evaluate
+        end
+
+        def evaluate
+          @value
+        end
+
+        def lazy?
+          true
+        end
+
+        def reached_by(parent_access_keys, access_key)
+          @access_keys = parent_access_keys + [access_key]
+          self
+        end
+
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueArray < ValueEnumerable
+        def initialize(array)
+          super
+          @value_hash = []
+          array.each_with_index do |value, index|
+            self[index] = value
+          end
+        end
+
+        def evaluate
+          @value_hash.map(&:evaluate)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueEnumerable < Value
+        def [](key)
+          if @value_hash[key].nil?
+            Value.new(nil).reached_by(access_keys, key)
+          else
+            @value_hash[key].reached_by(access_keys, key)
+          end
+        end
+
+        def fetch(access_keys)
+          fetched_keys = access_keys.dup
+          value = self[fetched_keys.shift]
+          fetched_keys.any? ? value.fetch(fetched_keys) : value
+        end
+
+        def []=(key, value)
+          @value_hash[key] = case value
+                             when Hash
+                               ValueHash.new(value)
+                             when Array
+                               ValueArray.new(value)
+                             else
+                               Value.new(value)
+                             end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueHash < ValueEnumerable
+        def initialize(hash)
+          super
+          @value_hash = ActiveSupport::HashWithIndifferentAccess.new
+          hash.each do |key, value|
+            self[key] = value
+          end
+        end
+
+        def evaluate
+          @value_hash.transform_values(&:evaluate)
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/media_type.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class MediaType
+      attr_reader :type, :subtype, :vendor, :version, :format
+
+      # based on the HTTP Accept header with the pattern:
+      # application/vnd.:vendor-:version+:format
+      VENDOR_VERSION_HEADER_REGEX = /\Avnd\.(?<vendor>[a-z0-9.\-_!^]+?)(?:-(?<version>[a-z0-9*.]+))?(?:\+(?<format>[a-z0-9*\-.]+))?\z/.freeze
+
+      def initialize(type:, subtype:)
+        @type = type
+        @subtype = subtype
+        VENDOR_VERSION_HEADER_REGEX.match(subtype) do |m|
+          @vendor = m[:vendor]
+          @version = m[:version]
+          @format = m[:format]
+        end
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          other.type == type &&
+          other.subtype == subtype &&
+          other.vendor == vendor &&
+          other.version == version &&
+          other.format == format
+      end
+
+      def hash
+        [self.class, type, subtype, vendor, version, format].hash
+      end
+
+      class << self
+        def best_quality(header, available_media_types)
+          parse(best_quality_media_type(header, available_media_types))
+        end
+
+        def parse(media_type)
+          return if media_type.blank?
+
+          type, subtype = media_type.split('/', 2)
+          return if type.blank? || subtype.blank?
+
+          new(type: type, subtype: subtype)
+        end
+
+        def match?(media_type)
+          return false if media_type.blank?
+
+          subtype = media_type.split('/', 2).last
+          return false if subtype.blank?
+
+          VENDOR_VERSION_HEADER_REGEX.match?(subtype)
+        end
+
+        def best_quality_media_type(header, available_media_types)
+          header.blank? ? available_media_types.first : Rack::Utils.best_q_match(header, available_media_types)
+        end
+      end
+
+      private_class_method :best_quality_media_type
+    end
+  end
+end