grape 1.1.0 → 1.7.1

data/lib/grape/router/route.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape/router/pattern'
 require 'grape/router/attribute_translator'
 require 'forwardable'
@@ -6,16 +8,17 @@ require 'pathname'
 module Grape
   class Router
     class Route
-      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/
+      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, :regexp, :options
+      attr_accessor :pattern, :translator, :app, :index, :options
 
       alias attributes translator
 
       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)
@@ -29,26 +32,7 @@ module Grape
       end
 
       def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
-      end
-
-      %i[
-        prefix
-        version
-        settings
-        format
-        description
-        http_codes
-        headers
-        entity
-        details
-        requirements
-        request_method
-        namespace
-      ].each do |method_name|
-        define_method method_name do
-          attributes.public_send method_name
-        end
+        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
       def route_method
@@ -62,10 +46,12 @@ module Grape
       end
 
       def initialize(method, pattern, **options)
-        @suffix     = options[:suffix]
-        @options    = options.merge(method: method.to_s.upcase)
+        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.to_s.upcase)
+        @translator = AttributeTranslator.new(**options, request_method: method_upcase)
       end
 
       def exec(env)
@@ -98,9 +84,9 @@ module Grape
         path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
         path = File.realpath(path) if Pathname.new(path).relative?
         expected ||= name
-        warn <<-EOS
-#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
-        EOS
+        warn <<~WARNING
+          #{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
+        WARNING
       end
     end
   end

data/lib/grape/router.rb

@@ -1,18 +1,14 @@
+# frozen_string_literal: true
+
 require 'grape/router/route'
+require 'grape/util/cache'
 
 module Grape
   class Router
     attr_reader :map, :compiled
 
-    class Any < AttributeTranslator
-      def initialize(pattern, **attributes)
-        @pattern = pattern
-        super(attributes)
-      end
-    end
-
     def self.normalize_path(path)
-      path = "/#{path}"
+      path = +"/#{path}"
       path.squeeze!('/')
       path.sub!(%r{/+\Z}, '')
       path = '/' if path == ''
@@ -25,18 +21,21 @@ module Grape
 
     def initialize
       @neutral_map = []
+      @neutral_regexes = []
       @map = Hash.new { |hash, key| hash[key] = [] }
       @optimized_map = Hash.new { |hash, key| hash[key] = // }
     end
 
     def compile!
       return if compiled
-      @union = Regexp.union(@neutral_map.map(&:regexp))
+
+      @union = Regexp.union(@neutral_regexes)
+      @neutral_regexes = nil
       self.class.supported_methods.each do |method|
         routes = map[method]
         @optimized_map[method] = routes.map.with_index do |route, index|
           route.index = index
-          route.regexp = /(?<_#{index}>#{route.pattern.to_regexp})/
+          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
         end
         @optimized_map[method] = Regexp.union(@optimized_map[method])
       end
@@ -44,12 +43,12 @@ module Grape
     end
 
     def append(route)
-      map[route.request_method.to_s.upcase] << route
+      map[route.request_method] << route
     end
 
     def associate_routes(pattern, **options)
-      regexp = /(?<_#{@neutral_map.length}>)#{pattern.to_regexp}/
-      @neutral_map << Any.new(pattern, regexp: regexp, index: @neutral_map.length, **options)
+      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
+      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
     end
 
     def call(env)
@@ -62,6 +61,7 @@ module Grape
     def recognize_path(input)
       any = with_optimization { greedy_match?(input) }
       return if any == default_response
+
       any.endpoint
     end
 
@@ -82,6 +82,7 @@ module Grape
       map[method].each do |route|
         next if exact_route == route
         next unless route.match?(input)
+
         response = process_route(route, env)
         break unless cascade?(response)
       end
@@ -93,37 +94,35 @@ module Grape
       response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
-      neighbor = greedy_match?(input)
 
-      # If neighbor exists and request method is OPTIONS,
+      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,
-        neighbor.allow_header,
-        neighbor.endpoint
-      ) if neighbor && method == 'OPTIONS' && !cascade
+      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Grape::Http::Headers::OPTIONS && !cascade
 
       route = match?(input, '*')
-      return neighbor.endpoint.call(env) if neighbor && cascade && route
+
+      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
 
       if route
         response = process_route(route, env)
         return response if response && !(cascade = cascade?(response))
       end
 
-      !cascade && neighbor ? call_with_allow_headers(env, neighbor.allow_header, neighbor.endpoint) : nil
+      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+
+      nil
     end
 
     def process_route(route, env)
-      input, = *extract_input_and_method(env)
-      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
+      prepare_env_from_route(env, route)
       route.exec(env)
     end
 
     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)
@@ -144,19 +143,27 @@ module Grape
     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}"] }
     end
 
     def greedy_match?(input)
       return unless @union.match(input)
+
       last_match = Regexp.last_match
       @neutral_map.detect { |route| last_match["_#{route.index}"] }
     end
 
-    def call_with_allow_headers(env, methods, endpoint)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods
-      endpoint.call(env)
+    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)
+    end
+
+    def prepare_env_from_route(env, route)
+      input, = *extract_input_and_method(env)
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
     end
 
     def cascade?(response)

data/lib/grape/{serve_file → serve_stream}/file_body.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Grape
-  module ServeFile
+  module ServeStream
     CHUNK_SIZE = 16_384
 
     # Class helps send file through API

data/lib/grape/{serve_file → serve_stream}/sendfile_response.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Grape
-  module ServeFile
+  module ServeStream
     # Response should respond to to_path method
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response

data/lib/grape/{serve_file/file_response.rb → serve_stream/stream_response.rb}

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 module Grape
-  module ServeFile
-    # A simple class used to identify responses which represent files and do not
+  module ServeStream
+    # A simple class used to identify responses which represent streams (or files) and do not
     # need to be formatted or pre-read by Rack::Response
-    class FileResponse
-      attr_reader :file
+    class StreamResponse
+      attr_reader :stream
 
-      # @param file [Object]
-      def initialize(file)
-        @file = file
+      # @param stream [Object]
+      def initialize(stream)
+        @stream = stream
       end
 
       # Equality provided mostly for tests.
       #
       # @return [Boolean]
       def ==(other)
-        file == other.file
+        stream == other.stream
       end
     end
   end

data/lib/grape/types/invalid_value.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# only exists to make it shorter for external use
+module Grape
+  module Types
+    InvalidValue = Class.new(Grape::Validations::Types::InvalidValue)
+  end
+end

data/lib/grape/util/base_inheritable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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.
+    class BaseInheritable
+      attr_accessor :inherited_values, :new_values
+
+      # @param inherited_values [Object] An object implementing an interface
+      #   of the Hash class.
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
+        @new_values = {}
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.dup
+      end
+
+      def keys
+        if new_values.any?
+          combined = inherited_values.keys
+          combined.concat(new_values.keys)
+          combined.uniq!
+          combined
+        else
+          inherited_values.keys
+        end
+      end
+
+      def key?(name)
+        inherited_values.key?(name) || new_values.key?(name)
+      end
+    end
+  end
+end

data/lib/grape/util/cache.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'forwardable'
+
+module Grape
+  module Util
+    class Cache
+      include Singleton
+
+      attr_reader :cache
+
+      class << self
+        extend Forwardable
+        def_delegators :cache, :[]
+        def_delegators :instance, :cache
+      end
+    end
+  end
+end

data/lib/grape/util/endpoint_configuration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class EndpointConfiguration < LazyValueHash
+    end
+  end
+end

data/lib/grape/util/env.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 module Grape
   module Env
-    API_VERSION = 'api.version'.freeze
-    API_ENDPOINT = 'api.endpoint'.freeze
-    API_REQUEST_INPUT = 'api.request.input'.freeze
-    API_REQUEST_BODY = 'api.request.body'.freeze
-    API_TYPE = 'api.type'.freeze
-    API_SUBTYPE = 'api.subtype'.freeze
-    API_VENDOR = 'api.vendor'.freeze
-    API_FORMAT = 'api.format'.freeze
+    API_VERSION = 'api.version'
+    API_ENDPOINT = 'api.endpoint'
+    API_REQUEST_INPUT = 'api.request.input'
+    API_REQUEST_BODY = 'api.request.body'
+    API_TYPE = 'api.type'
+    API_SUBTYPE = 'api.subtype'
+    API_VENDOR = 'api.vendor'
+    API_FORMAT = 'api.format'
 
-    RACK_INPUT = 'rack.input'.freeze
-    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'.freeze
-    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'.freeze
-    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'.freeze
+    RACK_INPUT = 'rack.input'
+    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'
+    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'
+    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'
 
-    GRAPE_REQUEST = 'grape.request'.freeze
-    GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze
-    GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze
-    GRAPE_ROUTING_ARGS = 'grape.routing_args'.freeze
-    GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'.freeze
+    GRAPE_REQUEST = 'grape.request'
+    GRAPE_REQUEST_HEADERS = 'grape.request.headers'
+    GRAPE_REQUEST_PARAMS = 'grape.request.params'
+    GRAPE_ROUTING_ARGS = 'grape.routing_args'
+    GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'
   end
 end

data/lib/grape/util/inheritable_setting.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     # 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
-      attr_accessor :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable
-      attr_accessor :parent, :point_in_time_copies
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
 
       # Retrieve global settings.
       def self.global

data/lib/grape/util/inheritable_values.rb

@@ -1,14 +1,10 @@
-module Grape
-  module Util
-    class InheritableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+# frozen_string_literal: true
 
-      def initialize(inherited_values = {})
-        self.inherited_values = inherited_values
-        self.new_values = {}
-      end
+require_relative 'base_inheritable'
 
+module Grape
+  module Util
+    class InheritableValues < BaseInheritable
       def [](name)
         values[name]
       end
@@ -17,26 +13,12 @@ module Grape
         new_values[name] = value
       end
 
-      def delete(key)
-        new_values.delete key
-      end
-
       def merge(new_hash)
-        values.merge(new_hash)
-      end
-
-      def keys
-        (new_values.keys + inherited_values.keys).sort.uniq
+        values.merge!(new_hash)
       end
 
       def to_hash
-        values.clone
-      end
-
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        values
       end
 
       protected

data/lib/grape/util/json.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'json'
+
 module Grape
   if Object.const_defined? :MultiJson
     Json = ::MultiJson

data/lib/grape/util/lazy_block.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class LazyBlock
+      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

data/lib/grape/util/lazy_object.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Based on https://github.com/HornsAndHooves/lazy_object
+
+module Grape
+  module Util
+    class LazyObject < 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

data/lib/grape/util/lazy_value.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class LazyValue
+      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
+
+    class LazyValueEnumerable < LazyValue
+      def [](key)
+        if @value_hash[key].nil?
+          LazyValue.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
+                             LazyValueHash.new(value)
+                           when Array
+                             LazyValueArray.new(value)
+                           else
+                             LazyValue.new(value)
+                           end
+      end
+    end
+
+    class LazyValueArray < LazyValueEnumerable
+      def initialize(array)
+        super
+        @value_hash = []
+        array.each_with_index do |value, index|
+          self[index] = value
+        end
+      end
+
+      def evaluate
+        evaluated = []
+        @value_hash.each_with_index do |value, index|
+          evaluated[index] = value.evaluate
+        end
+        evaluated
+      end
+    end
+
+    class LazyValueHash < LazyValueEnumerable
+      def initialize(hash)
+        super
+        @value_hash = {}.with_indifferent_access
+        hash.each do |key, value|
+          self[key] = value
+        end
+      end
+
+      def evaluate
+        evaluated = {}.with_indifferent_access
+        @value_hash.each do |key, value|
+          evaluated[key] =  value.evaluate
+        end
+        evaluated
+      end
+    end
+  end
+end

data/lib/grape/util/registrable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     module Registrable