Lazy initialization of Endpoint and trick with helpers.

Now I'm working on reducing calls to `extend` in `Grape` because they
invalidate Ruby's method cache slowing everything down. I applied a
*clever* trick with subclassing `Endpoint` and including helpers into
this subclass.

It also forced me to fix a thread safety issue reported by @etehtsea
here: #1201 (comment)
because calling `include` twice would be really inconsistent.

Also I'm sorry, 06930da does not actually fix anything, I overlooked it :)

Author: marshall-lee

.rubocop_todo.yml

@@ -22,7 +22,7 @@ Metrics/BlockNesting:
 # Offense count: 5
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 257
+  Max: 300
 
 # Offense count: 23
 Metrics/CyclomaticComplexity:

lib/grape/dsl/inside_route.rb

@@ -18,7 +18,7 @@ class MethodNotYetAvailable < StandardError; end
       #   filter +type+.
       def self.post_filter_methods(type)
         @post_filter_modules ||= { before: PostBeforeFilter }
-        @post_filter_modules[type] || Module.new
+        @post_filter_modules[type]
       end
 
       # Methods which should not be available in filters until the before filter

lib/grape/endpoint.rb

@@ -12,6 +12,14 @@ class Endpoint
     include Grape::DSL::InsideRoute
 
     class << self
+      def new(*args, &block)
+        if self == Endpoint
+          Class.new(Endpoint).new(*args, &block)
+        else
+          super
+        end
+      end
+
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
@@ -25,6 +33,13 @@ def before_each(new_setup = false, &block)
         end
       end
 
+      def run_before_each(endpoint)
+        superclass.run_before_each(endpoint) unless self == Endpoint
+        before_each.each do |blk|
+          blk.call(endpoint) if blk.respond_to? :call
+        end
+      end
+
       # @api private
       #
       # Create an UnboundMethod that is appropriate for executing an endpoint
@@ -75,6 +90,8 @@ def initialize(new_settings, options = {}, &block)
       @options[:method] = Array(options[:method])
       @options[:route_options] ||= {}
 
+      @lazy_initialize_lock = Mutex.new
+
       return unless block_given?
 
       @source = block
@@ -188,14 +205,11 @@ def compile_path(prepared_path, anchor = true, requirements = {})
     end
 
     def call(env)
-      build_app
-      build_helpers
+      lazy_initialize!
       dup.call!(env)
     end
 
     def call!(env)
-      extend helpers
-
       env[Grape::Env::API_ENDPOINT] = self
       @env = env
       @app.call(env)
@@ -223,9 +237,7 @@ def run
 
         cookies.read(@request)
 
-        self.class.before_each.each do |blk|
-          blk.call(self) if blk.respond_to?(:call)
-        end if self.class.before_each.any?
+        self.class.run_before_each(self)
 
         run_filters befores, :before
 
@@ -258,10 +270,6 @@ def run
       end
     end
 
-    def build_app
-      @app ||= options[:app] || build_stack
-    end
-
     def build_stack
       b = Rack::Builder.new
 
@@ -317,8 +325,25 @@ def build_helpers
       end
     end
 
+    private :build_stack, :build_helpers
+
     def helpers
-      @helpers ||= build_helpers
+      lazy_initialize! && @helpers
+    end
+
+    def lazy_initialize!
+      return true if @lazy_initialized
+
+      @lazy_initialize_lock.synchronize do
+        return true if @lazy_initialized
+
+        @app = options[:app] || build_stack
+        @helpers = build_helpers.tap do |mod|
+          self.class.send(:include, mod)
+        end
+
+        @lazy_initialized = true
+      end
     end
 
     def run_filters(filters, type = :other)
@@ -327,7 +352,8 @@ def run_filters(filters, type = :other)
           instance_eval(&filter)
         end
       end
-      extend DSL::InsideRoute.post_filter_methods(type)
+      post_extension = DSL::InsideRoute.post_filter_methods(type)
+      extend post_extension if post_extension
     end
 
     def befores

spec/grape/api_spec.rb

@@ -1088,7 +1088,7 @@ def before
 
       subject.get(:hello) { 'Hello, world.' }
       get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
-      expect(basic_auth_context).to be_an_instance_of(Grape::Endpoint)
+      expect(basic_auth_context).to be_a_kind_of(Grape::Endpoint)
     end
 
     it 'has access to helper methods' do

spec/grape/endpoint_spec.rb

@@ -1028,38 +1028,38 @@ def memoized
 
       # In order that the events finalized (time each block ended)
       expect(@events).to contain_exactly(
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: a_collection_containing_exactly(an_instance_of(Proc)),
                                                                        type: :before }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),
-        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: a_kind_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after }),
-        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                env: an_instance_of(Hash) })
       )
 
       # In order that events were initialized
       expect(@events.sort_by(&:time)).to contain_exactly(
-        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                env: an_instance_of(Hash) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: a_collection_containing_exactly(an_instance_of(Proc)),
                                                                        type: :before }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),
-        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: a_kind_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after })
       )