Lazy lookup and lazy object (#2002)

ericproulx · web-flow · commit 002280415a46 · 2020-03-01T16:56:08.000-05:00
* mime_types middleware cache.

* Replace %w by actual Supporter methods CONST

* Replace %w by Supported methods CONST

* Fixed [] leak. Its now generating empty array when needed.

* Introducing lazy generated lookup tables (cache) and lazy_object.

* Using Lazy_Object for request headers and Lazy lookup table when generating string. It reduced string allocations and lazy_object add a significant performance

* Added CHANGELOG.md entry.

* Change - to .freeze

* keys.include? replaced by key?(name)
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3,6 +3,7 @@
 #### Features
 
 * Your contribution here.
+* [#2002](https://github.com/ruby-grape/grape/pull/2002): Objects allocation optimization (lazy_lookup) - [@ericproulx](https://github.com/ericproulx).
 
 #### Fixes
 
diff --git a/lib/grape/api/instance.rb b/lib/grape/api/instance.rb
@@ -74,7 +74,7 @@ def call!(env)
         # (see #cascade?)
         def cascade(value = nil)
           if value.nil?
-            inheritable_setting.namespace_inheritable.keys.include?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
+            inheritable_setting.namespace_inheritable.key?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
           else
             namespace_inheritable(:cascade, value)
           end
@@ -178,7 +178,7 @@ def call(env)
       # errors from reaching upstream. This is effectivelly done by unsetting
       # X-Cascade. Default :cascade is true.
       def cascade?
-        return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.keys.include?(:cascade)
+        return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.key?(:cascade)
         return self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options) && self.class.namespace_inheritable(:version_options).key?(:cascade)
         true
       end
@@ -209,7 +209,7 @@ def add_head_not_allowed_methods_and_options_methods
             route_settings[:endpoint] = route.app
 
             # using the :any shorthand produces [nil] for route methods, substitute all manually
-            route_settings[:methods] = %w[GET PUT POST DELETE PATCH HEAD OPTIONS] if route_settings[:methods].include?('*')
+            route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS if route_settings[:methods].include?('*')
           end
         end
 
diff --git a/lib/grape/dsl/inside_route.rb b/lib/grape/dsl/inside_route.rb
@@ -177,7 +177,7 @@ def redirect(url, permanent: false, body: nil, **_options)
       def status(status = nil)
         case status
         when Symbol
-          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.include?(status)
+          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(status)
           @status = Rack::Utils.status_code(status)
         when Integer
           @status = status
diff --git a/lib/grape/dsl/routing.rb b/lib/grape/dsl/routing.rb
@@ -142,11 +142,11 @@ def route(methods, paths = ['/'], route_options = {}, &block)
           reset_validations!
         end
 
-        %w[get post put head delete options patch].each do |meth|
-          define_method meth do |*args, &block|
+        Grape::Http::Headers::SUPPORTED_METHODS.each do |supported_method|
+          define_method supported_method.downcase do |*args, &block|
             options = args.extract_options!
             paths = args.first || ['/']
-            route(meth.upcase, paths, options, &block)
+            route(supported_method, paths, options, &block)
           end
         end
 
diff --git a/lib/grape/http/headers.rb b/lib/grape/http/headers.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/lazy_object'
+
 module Grape
   module Http
     module Headers
@@ -27,6 +29,29 @@ module Headers
 
       FORMAT                 = 'format'
 
+      HTTP_HEADERS = Grape::Util::LazyObject.new do
+        common_http_headers = %w[
+          Version
+          Host
+          Connection
+          Cache-Control
+          Dnt
+          Upgrade-Insecure-Requests
+          User-Agent
+          Sec-Fetch-Dest
+          Accept
+          Sec-Fetch-Site
+          Sec-Fetch-Mode
+          Sec-Fetch-User
+          Accept-Encoding
+          Accept-Language
+          Cookie
+        ].freeze
+        common_http_headers.each_with_object({}) do |header, response|
+          response["HTTP_#{header.upcase.tr('-', '_')}"] = header
+        end.freeze
+      end
+
       def self.find_supported_method(route_method)
         Grape::Http::Headers::SUPPORTED_METHODS.detect { |supported_method| supported_method.casecmp(route_method).zero? }
       end
diff --git a/lib/grape/middleware/base.rb b/lib/grape/middleware/base.rb
@@ -74,11 +74,9 @@ def content_type
       end
 
       def mime_types
-        types_without_params = {}
-        content_types.each_pair do |k, v|
+        @mime_type ||= content_types.each_pair.with_object({}) do |(k, v), types_without_params|
           types_without_params[v.split(';').first] = k
         end
-        types_without_params
       end
 
       private
diff --git a/lib/grape/namespace.rb b/lib/grape/namespace.rb
@@ -1,5 +1,7 @@
 # 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.
@@ -25,13 +27,21 @@ def requirements
 
     # (see ::joined_space_path)
     def self.joined_space(settings)
-      (settings || []).map(&:space).join('/')
+      settings&.map(&:space)
     end
 
     # 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(joined_space(settings))
+      Grape::Router.normalize_path(JoinedSpaceCache[joined_space(settings)])
+    end
+
+    class JoinedSpaceCache < Grape::Util::Cache
+      def initialize
+        @cache ||= Hash.new do |h, joined_space|
+          h[joined_space] = -joined_space.join('/')
+        end
+      end
     end
   end
 end
diff --git a/lib/grape/path.rb b/lib/grape/path.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/cache'
+
 module Grape
   # Represents a path to an endpoint.
   class Path
@@ -58,7 +60,7 @@ def suffix
     end
 
     def path
-      Grape::Router.normalize_path(parts.join('/'))
+      Grape::Router.normalize_path(PartsCache[parts])
     end
 
     def path_with_suffix
@@ -71,6 +73,14 @@ def to_s
 
     private
 
+    class PartsCache < Grape::Util::Cache
+      def initialize
+        @cache ||= Hash.new do |h, parts|
+          h[parts] = -parts.join('/')
+        end
+      end
+    end
+
     def parts
       parts = [mount_path, root_prefix].compact
       parts << ':version' if uses_path_versioning?
diff --git a/lib/grape/request.rb b/lib/grape/request.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/lazy_object'
+
 module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'
@@ -30,14 +32,17 @@ def grape_routing_args
     end
 
     def build_headers
-      headers = {}
-      env.each_pair do |k, v|
-        next unless k.to_s.start_with? HTTP_PREFIX
-
-        k = k[5..-1].split('_').each(&:capitalize!).join('-')
-        headers[k] = v
+      Grape::Util::LazyObject.new do
+        env.each_pair.with_object({}) do |(k, v), headers|
+          next unless k.to_s.start_with? HTTP_PREFIX
+          transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
+          headers[transformed_header] = v
+        end
       end
-      headers
+    end
+
+    def transform_header(header)
+      -header[5..-1].split('_').each(&:capitalize!).join('-')
     end
   end
 end
diff --git a/lib/grape/router.rb b/lib/grape/router.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'grape/router/route'
+require 'grape/util/cache'
 
 module Grape
   class Router
@@ -16,12 +17,20 @@ def initialize(pattern, regexp, index, **attributes)
       end
     end
 
+    class NormalizePathCache < Grape::Util::Cache
+      def initialize
+        @cache ||= Hash.new do |h, path|
+          normalized_path = +"/#{path}"
+          normalized_path.squeeze!('/')
+          normalized_path.sub!(%r{/+\Z}, '')
+          normalized_path = '/' if normalized_path.empty?
+          h[path] = -normalized_path
+        end
+      end
+    end
+
     def self.normalize_path(path)
-      path = +"/#{path}"
-      path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
+      NormalizePathCache[path]
     end
 
     def self.supported_methods
@@ -160,7 +169,7 @@ def greedy_match?(input)
     end
 
     def call_with_allow_headers(env, methods, endpoint)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods.join(', ')
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods.join(', ').freeze
       endpoint.call(env)
     end
 
diff --git a/lib/grape/router/pattern.rb b/lib/grape/router/pattern.rb
@@ -2,35 +2,32 @@
 
 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
@@ -43,23 +40,27 @@ def build_path(pattern, anchor: false, suffix: nil, **_options)
           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}"
+        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
diff --git a/lib/grape/util/base_inheritable.rb b/lib/grape/util/base_inheritable.rb
@@ -31,6 +31,10 @@ def keys
         combined.uniq!
         combined
       end
+
+      def key?(name)
+        inherited_values.key?(name) || new_values.key?(name)
+      end
     end
   end
 end
diff --git a/lib/grape/util/cache.rb b/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
diff --git a/lib/grape/util/lazy_object.rb b/lib/grape/util/lazy_object.rb
diff --git a/lib/grape/util/reverse_stackable_values.rb b/lib/grape/util/reverse_stackable_values.rb
diff --git a/lib/grape/util/stackable_values.rb b/lib/grape/util/stackable_values.rb
diff --git a/lib/grape/validations/params_scope.rb b/lib/grape/validations/params_scope.rb
