grape 2.0.0 → 2.2.0

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

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/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