grape 1.2.5 → 1.4.0

data/lib/grape/router/pattern.rb

@@ -1,34 +1,33 @@
+# 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, type: :grape }.freeze
+      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
       DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
 
-      attr_reader :origin, :path, :capture, :pattern
+      attr_reader :origin, :path, :pattern, :to_regexp
 
       extend Forwardable
       def_delegators :pattern, :named_captures, :params
-      def_delegators :@regexp, :===
+      def_delegators :to_regexp, :===
       alias match? ===
 
       def initialize(pattern, **options)
         @origin  = pattern
         @path    = build_path(pattern, **options)
-        @capture = extract_capture(options)
-        @pattern = Mustermann.new(@path, pattern_options)
-        @regexp  = to_regexp
-      end
-
-      def to_regexp
-        @to_regexp ||= @pattern.to_regexp
+        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+        @to_regexp = @pattern.to_regexp
       end
 
       private
 
-      def pattern_options
+      def pattern_options(options)
+        capture = extract_capture(**options)
         options = DEFAULT_PATTERN_OPTIONS.dup
         options[:capture] = capture if capture.present?
         options
@@ -36,27 +35,32 @@ module Grape
 
       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
 
-        pattern = pattern.split('/').tap do |parts|
+        pattern = -pattern.split('/').tap do |parts|
           parts[parts.length - 1] = '?' + parts.last
         end.join('/') if pattern.end_with?('*path')
 
-        pattern + suffix.to_s
+        PatternCache[[pattern, suffix]]
       end
 
       def extract_capture(requirements: {}, **options)
         requirements = {}.merge(requirements)
-        supported_capture.each_with_object(requirements) do |field, capture|
+        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
           option = Array(options[field])
           capture[field] = option.map(&:to_s) if option.present?
         end
       end
 
-      def supported_capture
-        DEFAULT_SUPPORTED_CAPTURE
+      class PatternCache < Grape::Util::Cache
+        def initialize
+          @cache = Hash.new do |h, (pattern, suffix)|
+            h[[pattern, suffix]] = -"#{pattern}#{suffix}"
+          end
+        end
       end
     end
   end

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)

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/util/base_inheritable.rb

@@ -1,10 +1,11 @@
+# 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
-      attr_accessor :new_values
+      attr_accessor :inherited_values, :new_values
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
@@ -24,10 +25,18 @@ module Grape
       end
 
       def keys
-        combined = inherited_values.keys
-        combined.concat(new_values.keys)
-        combined.uniq!
-        combined
+        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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     class EndpointConfiguration < LazyValueHash

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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     # A branchable, inheritable settings object which can store both stackable

data/lib/grape/util/inheritable_values.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base_inheritable'
 
 module Grape

data/lib/grape/util/json.rb

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

data/lib/grape/util/lazy_block.rb

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

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

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

data/lib/grape/util/registrable.rb

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

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'stackable_values'
 
 module Grape
@@ -6,6 +8,8 @@ module Grape
       protected
 
       def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
         [].tap do |value|
           value.concat(new_value)
           value.concat(inherited_value)

data/lib/grape/util/stackable_values.rb

@@ -1,31 +1,23 @@
+# frozen_string_literal: true
+
 require_relative 'base_inheritable'
 
 module Grape
   module Util
     class StackableValues < BaseInheritable
-      attr_reader :frozen_values
-
-      def initialize(*_args)
-        super
-
-        @frozen_values = {}
-      end
-
+      # Even if there is no value, an empty array will be returned.
       def [](name)
-        return @frozen_values[name] if @frozen_values.key? name
+        inherited_value = inherited_values[name]
+        new_value = new_values[name]
 
-        inherited_value = @inherited_values[name]
-        new_value = @new_values[name] || []
-
-        return new_value unless inherited_value
+        return new_value || [] unless inherited_value
 
         concat_values(inherited_value, new_value)
       end
 
       def []=(name, value)
-        raise if @frozen_values.key? name
-        @new_values[name] ||= []
-        @new_values[name].push value
+        new_values[name] ||= []
+        new_values[name].push value
       end
 
       def to_hash
@@ -34,13 +26,11 @@ module Grape
         end
       end
 
-      def freeze_value(key)
-        @frozen_values[key] = self[key].freeze
-      end
-
       protected
 
       def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
         [].tap do |value|
           value.concat(inherited_value)
           value.concat(new_value)