grape 1.2.3 → 1.2.4

data/lib/grape.rb

@@ -195,6 +195,8 @@ end
 
 require 'grape/config'
 require 'grape/util/content_types'
+require 'grape/util/lazy_value'
+require 'grape/util/endpoint_configuration'
 
 require 'grape/validations/validators/base'
 require 'grape/validations/attributes_iterator'

data/lib/grape/api.rb

@@ -6,7 +6,7 @@ module Grape
   # should subclass this class in order to build an API.
   class API
     # Class methods that we want to call on the API rather than on the API object
-    NON_OVERRIDABLE = (Class.new.methods + %i[call call!]).freeze
+    NON_OVERRIDABLE = (Class.new.methods + %i[call call! configuration]).freeze
 
     class << self
       attr_accessor :base_instance, :instances
@@ -64,8 +64,6 @@ module Grape
       def const_missing(*args)
         if base_instance.const_defined?(*args)
           base_instance.const_get(*args)
-        elsif parent && parent.const_defined?(*args)
-          parent.const_get(*args)
         else
           super
         end
@@ -77,7 +75,7 @@ module Grape
       # too much, you may actually want to provide a new API rather than remount it.
       def mount_instance(opts = {})
         instance = Class.new(@base_parent)
-        instance.configuration = opts[:configuration] || {}
+        instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
         instance.base = self
         replay_setup_on(instance)
         instance
@@ -86,8 +84,8 @@ module Grape
       # Replays the set up to produce an API as defined in this class, can be called
       # on classes that inherit from Grape::API
       def replay_setup_on(instance)
-        @setup.each do |setup_stage|
-          instance.send(setup_stage[:method], *setup_stage[:args], &setup_stage[:block])
+        @setup.each do |setup_step|
+          replay_step_on(instance, setup_step)
         end
       end
 
@@ -112,14 +110,43 @@ module Grape
 
       # Adds a new stage to the set up require to get a Grape::API up and running
       def add_setup(method, *args, &block)
-        setup_stage = { method: method, args: args, block: block }
-        @setup << setup_stage
+        setup_step = { method: method, args: args, block: block }
+        @setup << setup_step
         last_response = nil
         @instances.each do |instance|
-          last_response = instance.send(setup_stage[:method], *setup_stage[:args], &setup_stage[:block])
+          last_response = replay_step_on(instance, setup_step)
         end
         last_response
       end
+
+      def replay_step_on(instance, setup_step)
+        return if skip_immediate_run?(instance, setup_step[:args])
+        instance.send(setup_step[:method], *evaluate_arguments(instance.configuration, *setup_step[:args]), &setup_step[:block])
+      end
+
+      # Skips steps that contain arguments to be lazily executed (on re-mount time)
+      def skip_immediate_run?(instance, args)
+        instance.base_instance? &&
+          (any_lazy?(args) || args.any? { |arg| arg.is_a?(Hash) && any_lazy?(arg.values) })
+      end
+
+      def any_lazy?(args)
+        args.any? { |argument| argument.respond_to?(:lazy?) && argument.lazy? }
+      end
+
+      def evaluate_arguments(configuration, *args)
+        args.map do |argument|
+          if argument.respond_to?(:lazy?) && argument.lazy?
+            configuration.fetch(argument.access_keys).evaluate
+          elsif argument.is_a?(Hash)
+            argument.map { |key, value| [key, evaluate_arguments(configuration, value).first] }.to_h
+          elsif argument.is_a?(Array)
+            evaluate_arguments(configuration, *argument)
+          else
+            argument
+          end
+        end
+      end
     end
   end
 end

data/lib/grape/api/instance.rb

@@ -12,6 +12,15 @@ module Grape
         attr_reader :base
         attr_accessor :configuration
 
+        def given(conditional_option, &block)
+          evaluate_as_instance_with_configuration(block) if conditional_option && block_given?
+        end
+
+        def mounted(&block)
+          return if base_instance?
+          evaluate_as_instance_with_configuration(block)
+        end
+
         def base=(grape_api)
           @base = grape_api
           grape_api.instances << self
@@ -21,6 +30,10 @@ module Grape
           (base && base.to_s) || super
         end
 
+        def base_instance?
+          self == base.base_instance
+        end
+
         # A class-level lock to ensure the API is not compiled by multiple
         # threads simultaneously within the same process.
         LOCK = Mutex.new
@@ -84,14 +97,24 @@ module Grape
         def nest(*blocks, &block)
           blocks.reject!(&:nil?)
           if blocks.any?
-            instance_eval(&block) if block_given?
-            blocks.each { |b| instance_eval(&b) }
+            evaluate_as_instance_with_configuration(block) if block_given?
+            blocks.each { |b| evaluate_as_instance_with_configuration(b) }
             reset_validations!
           else
             instance_eval(&block)
           end
         end
 
+        def evaluate_as_instance_with_configuration(block)
+          value_for_configuration = configuration
+          if value_for_configuration.respond_to?(:lazy?) && value_for_configuration.lazy?
+            self.configuration = value_for_configuration.evaluate
+          end
+          response = instance_eval(&block)
+          self.configuration = value_for_configuration
+          response
+        end
+
         def inherited(subclass)
           subclass.reset!
           subclass.logger = logger.clone

data/lib/grape/dsl/callbacks.rb

@@ -43,6 +43,26 @@ module Grape
         def after(&block)
           namespace_stackable(:afters, block)
         end
+
+        # Allows you to specify a something that will always be executed after a call
+        # API call. Unlike the `after` block, this code will run even on
+        # unsuccesful requests.
+        # @example
+        #   class ExampleAPI < Grape::API
+        #     before do
+        #       ApiLogger.start
+        #     end
+        #     finally do
+        #       ApiLogger.close
+        #     end
+        #   end
+        #
+        # This will make sure that the ApiLogger is opened and close around every
+        # request
+        # @param  ensured_block [Proc] The block to be executed after every api_call
+        def finally(&block)
+          namespace_stackable(:finallies, block)
+        end
       end
     end
   end

data/lib/grape/dsl/desc.rb

@@ -49,7 +49,8 @@ module Grape
       #
       def desc(description, options = {}, &config_block)
         if block_given?
-          config_class = desc_container
+          configuration = defined?(configuration) && configuration.respond_to?(:evaluate) ? configuration.evaluate : {}
+          config_class = desc_container(configuration)
 
           config_class.configure do
             description description
@@ -84,7 +85,7 @@ module Grape
       end
 
       # Returns an object which configures itself via an instance-context DSL.
-      def desc_container
+      def desc_container(endpoint_configuration)
         Module.new do
           include Grape::Util::StrictHashConfiguration.module(
             :summary,
@@ -105,6 +106,9 @@ module Grape
             :security,
             :tags
           )
+          config_context.define_singleton_method(:configuration) do
+            endpoint_configuration
+          end
 
           def config_context.success(*args)
             entity(*args)

data/lib/grape/dsl/inside_route.rb

@@ -61,13 +61,13 @@ module Grape
             else
               # If it is not a Hash then it does not have children.
               # Find its value or set it to nil.
-              has_alias = route_setting(:aliased_params) && route_setting(:aliased_params).find { |current| current[declared_param] }
-              param_alias = has_alias[declared_param] if has_alias
+              has_renaming = route_setting(:renamed_params) && route_setting(:renamed_params).find { |current| current[declared_param] }
+              param_renaming = has_renaming[declared_param] if has_renaming
 
-              next unless options[:include_missing] || passed_params.key?(declared_param) || (param_alias && passed_params.key?(param_alias))
+              next unless options[:include_missing] || passed_params.key?(declared_param) || (param_renaming && passed_params.key?(param_renaming))
 
-              if param_alias
-                memo[optioned_param_key(param_alias, options)] = passed_params[param_alias]
+              if param_renaming
+                memo[optioned_param_key(param_renaming, options)] = passed_params[param_renaming]
               else
                 memo[optioned_param_key(declared_param, options)] = passed_params[declared_param]
               end
@@ -129,13 +129,19 @@ module Grape
         env[Grape::Env::API_VERSION]
       end
 
+      def configuration
+        options[:for].configuration.evaluate
+      end
+
       # End the request and display an error to the
       # end user with the specified message.
       #
       # @param message [String] The message to display.
       # @param status [Integer] the HTTP Status Code. Defaults to default_error_status, 500 if not set.
-      def error!(message, status = nil, headers = nil)
+      # @param additional_headers [Hash] Addtional headers for the response.
+      def error!(message, status = nil, additional_headers = nil)
         self.status(status || namespace_inheritable(:default_error_status))
+        headers = additional_headers.present? ? header.merge(additional_headers) : header
         throw :error, message: message, status: self.status, headers: headers
       end
 

data/lib/grape/endpoint.rb

@@ -245,33 +245,37 @@ module Grape
         @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
         @params = @request.params
         @headers = @request.headers
+        begin
+          cookies.read(@request)
+          self.class.run_before_each(self)
+          run_filters befores, :before
+
+          if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
+            raise Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => allowed_methods) unless options?
+            header 'Allow', allowed_methods
+            response_object = ''
+            status 204
+          else
+            run_filters before_validations, :before_validation
+            run_validators validations, request
+            remove_renamed_params
+            run_filters after_validations, :after_validation
+            response_object = @block ? @block.call(self) : nil
+          end
 
-        cookies.read(@request)
-        self.class.run_before_each(self)
-        run_filters befores, :before
-
-        if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
-          raise Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => allowed_methods) unless options?
-          header 'Allow', allowed_methods
-          response_object = ''
-          status 204
-        else
-          run_filters before_validations, :before_validation
-          run_validators validations, request
-          remove_aliased_params
-          run_filters after_validations, :after_validation
-          response_object = @block ? @block.call(self) : nil
-        end
+          run_filters afters, :after
+          cookies.write(header)
 
-        run_filters afters, :after
-        cookies.write(header)
+          # status verifies body presence when DELETE
+          @body ||= response_object
 
-        # status verifies body presence when DELETE
-        @body ||= response_object
+          # The body commonly is an Array of Strings, the application instance itself, or a File-like object
+          response_object = file || [body]
 
-        # The Body commonly is an Array of Strings, the application instance itself, or a File-like object
-        response_object = file || [body]
-        [status, header, response_object]
+          [status, header, response_object]
+        ensure
+          run_filters finallies, :finally
+        end
       end
     end
 
@@ -320,14 +324,14 @@ module Grape
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
-    def remove_aliased_params
-      return unless route_setting(:aliased_params)
-      route_setting(:aliased_params).flat_map(&:keys).each do |aliased_param|
-        @params.delete(aliased_param)
+    def remove_renamed_params
+      return unless route_setting(:renamed_params)
+      route_setting(:renamed_params).flat_map(&:keys).each do |renamed_param|
+        @params.delete(renamed_param)
       end
     end
 
-    private :build_stack, :build_helpers, :remove_aliased_params
+    private :build_stack, :build_helpers, :remove_renamed_params
 
     def helpers
       lazy_initialize! && @helpers
@@ -392,6 +396,10 @@ module Grape
       namespace_stackable(:afters) || []
     end
 
+    def finallies
+      namespace_stackable(:finallies) || []
+    end
+
     def validations
       route_setting(:saved_validations) || []
     end

data/lib/grape/middleware/error.rb

@@ -21,7 +21,7 @@ module Grape
           },
           rescue_handlers: {}, # rescue handler blocks
           base_only_rescue_handlers: {}, # rescue handler blocks rescuing only the base class
-          all_rescue_handler: nil # rescue handler block to rescue from all exceptions
+          all_rescue_handler: nil, # rescue handler block to rescue from all exceptions
         }
       end
 
@@ -32,7 +32,6 @@ module Grape
 
       def call!(env)
         @env = env
-
         begin
           error_response(catch(:error) do
             return @app.call(@env)

data/lib/grape/util/endpoint_configuration.rb

@@ -0,0 +1,6 @@
+module Grape
+  module Util
+    class EndpointConfiguration < LazyValueHash
+    end
+  end
+end

data/lib/grape/util/lazy_value.rb

@@ -0,0 +1,90 @@
+module Grape
+  module Util
+    class LazyValue
+      attr_reader :access_keys
+      def initialize(value, access_keys = [])
+        @value = value
+        @access_keys = access_keys
+      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] = if value.is_a?(Hash)
+                             LazyValueHash.new(value)
+                           elsif value.is_a?(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