grape 0.12.0 → 0.14.0

data/lib/grape/dsl/settings.rb

@@ -2,24 +2,37 @@ require 'active_support/concern'
 
 module Grape
   module DSL
+    # Keeps track of settings (impemented as key-value pairs, grouped by
+    # types), in two contexts: top-level settings which apply globally no
+    # matter where they're defined, and inheritable settings which apply only
+    # in the current scope and scopes nested under it.
     module Settings
       extend ActiveSupport::Concern
 
       attr_accessor :inheritable_setting, :top_level_setting
 
+      # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting
         @top_level_setting ||= Grape::Util::InheritableSetting.new
       end
 
+      # Fetch our current inheritable settings, which are inherited by
+      # nested scopes but not shared across siblings.
       def inheritable_setting
         @inheritable_setting ||= Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from top_level_setting }
       end
 
+      # @param type [Symbol]
+      # @param key [Symbol]
       def unset(type, key)
         setting = inheritable_setting.send(type)
         setting.delete key
       end
 
+      # @param type [Symbol]
+      # @param key [Symbol]
+      # @param value [Object] will be stored if the value is currently empty
+      # @return either the old value, if it wasn't nil, or the given value
       def get_or_set(type, key, value)
         setting = inheritable_setting.send(type)
         if value.nil?
@@ -29,72 +42,94 @@ module Grape
         end
       end
 
+      # @param key [Symbol]
+      # @param value [Object]
+      # @return (see #get_or_set)
       def global_setting(key, value = nil)
         get_or_set :global, key, value
       end
 
+      # @param key [Symbol]
       def unset_global_setting(key)
         unset :global, key
       end
 
+      # (see #global_setting)
       def route_setting(key, value = nil)
         get_or_set :route, key, value
       end
 
+      # (see #unset_global_setting)
       def unset_route_setting(key)
         unset :route, key
       end
 
+      # (see #global_setting)
       def namespace_setting(key, value = nil)
         get_or_set :namespace, key, value
       end
 
+      # (see #unset_global_setting)
       def unset_namespace_setting(key)
         unset :namespace_setting, key
       end
 
+      # (see #global_setting)
       def namespace_inheritable(key, value = nil)
         get_or_set :namespace_inheritable, key, value
       end
 
+      # (see #unset_global_setting)
       def unset_namespace_inheritable(key)
         unset :namespace_inheritable, key
       end
 
+      # @param key [Symbol]
       def namespace_inheritable_to_nil(key)
         inheritable_setting.namespace_inheritable[key] = nil
       end
 
+      # (see #global_setting)
       def namespace_stackable(key, value = nil)
         get_or_set :namespace_stackable, key, value
       end
 
+      # (see #unset_global_setting)
       def unset_namespace_stackable(key)
         unset :namespace_stackable, key
       end
 
+      # (see #global_setting)
       def api_class_setting(key, value = nil)
         get_or_set :api_class, key, value
       end
 
+      # (see #unset_global_setting)
       def unset_api_class_setting(key)
         unset :api_class_setting, key
       end
 
+      # Fork our inheritable settings to a new instance, copied from our
+      # parent's, but separate so we won't modify it. Every call to this
+      # method should have an answering call to #namespace_end.
       def namespace_start
         @inheritable_setting = Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from inheritable_setting }
       end
 
+      # Set the inheritable settings pointer back up by one level.
       def namespace_end
         route_end
         @inheritable_setting = inheritable_setting.parent
       end
 
+      # Stop defining settings for the current route and clear them for the
+      # next, within a namespace.
       def route_end
         inheritable_setting.route_end
-        reset_validations!
       end
 
+      # Execute the block within a context where our inheritable settings are forked
+      # to a new copy (see #namespace_start).
       def within_namespace(&_block)
         namespace_start
 

data/lib/grape/dsl/validations.rb

@@ -8,22 +8,24 @@ module Grape
       include Grape::DSL::Configuration
 
       module ClassMethods
+        # Clears all defined parameters and validations.
         def reset_validations!
           unset_namespace_stackable :declared_params
           unset_namespace_stackable :validations
           unset_namespace_stackable :params
+          unset_description_field :params
         end
 
+        # Opens a root-level ParamsScope, defining parameter coercions and
+        # validations for the endpoint.
+        # @yield instance context of the new scope
         def params(&block)
           Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
         end
 
         def document_attribute(names, opts)
-          route_setting(:description, {}) unless route_setting(:description)
-
-          route_setting(:description)[:params] ||= {}
-
-          setting = route_setting(:description)[:params]
+          setting = description_field(:params)
+          setting ||= description_field(:params, {})
           Array(names).each do |name|
             setting[name[:full_name].to_s] ||= {}
             setting[name[:full_name].to_s].merge!(opts)

data/lib/grape/endpoint.rb

@@ -12,15 +12,31 @@ module Grape
     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
           if block_given?
-            @before_each = block
+            @before_each << block
           else
             return @before_each
           end
         else
-          @before_each = new_setup
+          @before_each = [new_setup]
+        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
 
@@ -41,10 +57,16 @@ module Grape
         if instance_methods.include?(method_name.to_sym) || instance_methods.include?(method_name.to_s)
           fail NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
         end
+
         define_method(method_name, &block)
         method = instance_method(method_name)
         remove_method(method_name)
-        proc { |endpoint_instance| method.bind(endpoint_instance).call }
+
+        proc do |endpoint_instance|
+          ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
+            method.bind(endpoint_instance).call
+          end
+        end
       end
     end
 
@@ -68,10 +90,12 @@ module Grape
       @options[:method] = Array(options[:method])
       @options[:route_options] ||= {}
 
-      if block_given?
-        @source = block
-        @block = self.class.generate_api_method(method_name, &block)
-      end
+      @lazy_initialize_lock = Mutex.new
+
+      return unless block_given?
+
+      @source = block
+      @block = self.class.generate_api_method(method_name, &block)
     end
 
     def require_option(options, key)
@@ -113,7 +137,7 @@ module Grape
             route_set.add_route(self, {
                                   path_info: route.route_compiled,
                                   request_method: method
-                                },  route_info: route)
+                                }, route_info: route)
           end
         end
       end
@@ -181,20 +205,14 @@ module Grape
     end
 
     def call(env)
+      lazy_initialize!
       dup.call!(env)
     end
 
     def call!(env)
-      extend helpers
-
-      env['api.endpoint'] = self
-      if options[:app]
-        options[:app].call(env)
-      else
-        builder = build_middleware
-        builder.run ->(arg) { run(arg) }
-        builder.call(env)
-      end
+      env[Grape::Env::API_ENDPOINT] = self
+      @env = env
+      @app.call(env)
     end
 
     # Return the collection of endpoints within this endpoint.
@@ -209,51 +227,50 @@ module Grape
 
     protected
 
-    def run(env)
-      @env = env
-      @header = {}
-
-      @request = Grape::Request.new(env)
-      @params = @request.params
-      @headers = @request.headers
+    def run
+      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
+        @header = {}
 
-      cookies.read(@request)
+        @request = Grape::Request.new(env)
+        @params = @request.params
+        @headers = @request.headers
 
-      self.class.before_each.call(self) if self.class.before_each
+        cookies.read(@request)
 
-      run_filters befores
+        self.class.run_before_each(self)
 
-      run_filters before_validations
+        run_filters befores, :before
 
-      # Retrieve validations from this namespace and all parent namespaces.
-      validation_errors = []
+        run_filters before_validations, :before_validation
 
-      # require 'pry-byebug'; binding.pry
+        # Retrieve validations from this namespace and all parent namespaces.
+        validation_errors = []
 
-      route_setting(:saved_validations).each do |validator|
-        begin
-          validator.validate!(params)
-        rescue Grape::Exceptions::Validation => e
-          validation_errors << e
+        route_setting(:saved_validations).each do |validator|
+          begin
+            validator.validate!(params)
+          rescue Grape::Exceptions::Validation => e
+            validation_errors << e
+          end
         end
-      end
 
-      if validation_errors.any?
-        fail Grape::Exceptions::ValidationErrors, errors: validation_errors
-      end
+        if validation_errors.any?
+          fail Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header
+        end
 
-      run_filters after_validations
+        run_filters after_validations, :after_validation
 
-      response_object = @block ? @block.call(self) : nil
-      run_filters afters
-      cookies.write(header)
+        response_object = @block ? @block.call(self) : nil
+        run_filters afters, :after
+        cookies.write(header)
 
-      # The Body commonly is an Array of Strings, the application instance itself, or a File-like object.
-      response_object = file || [body || response_object]
-      [status, header, response_object]
+        # The Body commonly is an Array of Strings, the application instance itself, or a File-like object.
+        response_object = file || [body || response_object]
+        [status, header, response_object]
+      end
     end
 
-    def build_middleware
+    def build_stack
       b = Rack::Builder.new
 
       b.use Rack::Head
@@ -294,21 +311,49 @@ module Grape
             formatters: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:formatters)),
             parsers: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:parsers))
 
-      b
+      b.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
+
+      b.to_app
     end
 
+    def build_helpers
+      helpers = namespace_stackable(:helpers) || []
+      Module.new do
+        helpers.each do |mod_to_include|
+          include mod_to_include
+        end
+      end
+    end
+
+    private :build_stack, :build_helpers
+
     def helpers
-      mod = Module.new
-      (namespace_stackable(:helpers) || []).each do |mod_to_include|
-        mod.send :include, mod_to_include
+      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
-      mod
     end
 
-    def run_filters(filters)
-      (filters || []).each do |filter|
-        instance_eval(&filter)
+    def run_filters(filters, type = :other)
+      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
+        (filters || []).each do |filter|
+          instance_eval(&filter)
+        end
       end
+      post_extension = DSL::InsideRoute.post_filter_methods(type)
+      extend post_extension if post_extension
     end
 
     def befores

data/lib/grape/error_formatter/base.rb

@@ -33,22 +33,22 @@ module Grape
         present_options = {}
         present_options[:with] = message.delete(:with) if message.is_a?(Hash)
 
-        presenter = env['api.endpoint'].entity_class_for_obj(message, present_options)
+        presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(message, present_options)
 
-        unless presenter || env['rack.routing_args'].nil?
+        unless presenter || env[Grape::Env::RACK_ROUTING_ARGS].nil?
           # env['api.endpoint'].route does not work when the error occurs within a middleware
           # the Endpoint does not have a valid env at this moment
-          http_codes = env['rack.routing_args'][:route_info].route_http_codes || []
+          http_codes = env[Grape::Env::RACK_ROUTING_ARGS][:route_info].route_http_codes || []
           found_code = http_codes.find do |http_code|
-            (http_code[0].to_i == env['api.endpoint'].status) && http_code[2].respond_to?(:represent)
-          end if env['api.endpoint'].request
+            (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
+          end if env[Grape::Env::API_ENDPOINT].request
 
           presenter = found_code[2] if found_code
         end
 
         if presenter
           embeds = { env: env }
-          embeds[:version] = env['api.version'] if env['api.version']
+          embeds[:version] = env[Grape::Env::API_VERSION] if env[Grape::Env::API_VERSION]
           message = presenter.represent(message, embeds).serializable_hash
         end
 

data/lib/grape/exceptions/base.rb

@@ -1,8 +1,8 @@
 module Grape
   module Exceptions
     class Base < StandardError
-      BASE_MESSAGES_KEY = 'grape.errors.messages'
-      BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'
+      BASE_MESSAGES_KEY = 'grape.errors.messages'.freeze
+      BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'.freeze
       FALLBACK_LOCALE = :en
 
       attr_reader :status, :message, :headers
@@ -51,16 +51,16 @@ module Grape
 
       def translate_attributes(keys, options = {})
         keys.map do |key|
-          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
+          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.reverse_merge(default: key))
         end.join(', ')
       end
 
       def translate_attribute(key, options = {})
-        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
+        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.reverse_merge(default: key))
       end
 
       def translate_message(key, options = {})
-        translate("#{BASE_MESSAGES_KEY}.#{key}", { default: '' }.merge(options))
+        translate("#{BASE_MESSAGES_KEY}.#{key}", options.reverse_merge(default: ''))
       end
 
       def translate(key, options = {})

data/lib/grape/exceptions/invalid_version_header.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class InvalidVersionHeader < Base
+      def initialize(message, headers)
+        super(message: compose_message('invalid_version_header', message: message), status: 406, headers: headers)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_parameter.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class UnknownParameter < Base
+      def initialize(param)
+        super(message: compose_message('unknown_parameter', param: param))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/validation_errors.rb

@@ -13,7 +13,8 @@ module Grape
           @errors[validation_error.params] ||= []
           @errors[validation_error.params] << validation_error
         end
-        super message: full_messages.join(', '), status: 400
+
+        super message: full_messages.join(', '), status: 400, headers: args[:headers]
       end
 
       def each
@@ -37,12 +38,12 @@ module Grape
         as_json.to_json
       end
 
-      private
-
       def full_messages
         map { |attributes, error| full_message(attributes, error) }.uniq
       end
 
+      private
+
       def full_message(attributes, error)
         I18n.t(
           'grape.errors.format'.to_sym,

data/lib/grape/formatter/serializable_hash.rb

@@ -21,10 +21,11 @@ module Grape
           elsif object.is_a?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false)
             object.map(&:serializable_hash)
           elsif object.is_a?(Hash)
-            object.inject({}) do |h, (k, v)|
+            h = {}
+            object.each_pair do |k, v|
               h[k] = serialize(v)
-              h
             end
+            h
           else
             object
           end

data/lib/grape/http/headers.rb

@@ -20,7 +20,6 @@ module Grape
       HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'.freeze
       HTTP_ACCEPT            = 'HTTP_ACCEPT'.freeze
 
-      ACCEPT                 = 'accept'.freeze
       FORMAT                 = 'format'.freeze
     end
   end

data/lib/grape/locale/en.yml

@@ -28,13 +28,14 @@ en:
           resolution: 'available strategy for :using is :path, :header, :param'
         unknown_validator: 'unknown validator: %{validator_type}'
         unknown_options: 'unknown options: %{options}'
+        unknown_parameter: 'unknown parameter: %{param}'
         incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
         mutual_exclusion: 'are mutually exclusive'
         at_least_one: 'are missing, at least one parameter must be provided'
         exactly_one: 'are missing, exactly one parameter must be provided'
         all_or_none: 'provide all or none of parameters'
         missing_group_type: 'group type is required'
-        unsupported_group_type: 'group type must be Array or Hash'
+        unsupported_group_type: 'group type must be Array, Hash, JSON or Array[JSON]'
         invalid_message_body:
           problem: "message body does not match declared format"
           resolution:
@@ -44,4 +45,7 @@ en:
         invalid_accept_header:
           problem: 'Invalid accept header'
           resolution: '%{message}'
+        invalid_version_header:
+          problem: 'Invalid version header'
+          resolution: '%{message}'
 

data/lib/grape/middleware/auth/base.rb

@@ -12,7 +12,7 @@ module Grape
         end
 
         def context
-          env['api.endpoint']
+          env[Grape::Env::API_ENDPOINT]
         end
 
         def call(env)
@@ -26,7 +26,7 @@ module Grape
             auth_proc         = options[:proc]
             auth_proc_context = context
 
-            strategy_info   = Grape::Middleware::Auth::Strategies[options[:type]]
+            strategy_info = Grape::Middleware::Auth::Strategies[options[:type]]
 
             throw(:error, status: 401, message: 'API Authorization Failed.') unless strategy_info.present?
 

data/lib/grape/middleware/auth/dsl.rb

@@ -12,7 +12,7 @@ module Grape
           # only `:http_basic`, `:http_digest` are supported.
           def auth(type = nil, options = {}, &block)
             if type
-              namespace_inheritable(:auth, { type: type.to_sym, proc: block }.merge(options))
+              namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block))
               use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
             else
               namespace_inheritable(:auth)

data/lib/grape/middleware/auth/strategies.rb

@@ -5,7 +5,7 @@ module Grape
         module_function
 
         def add(label, strategy, option_fetcher = ->(_) { [] })
-          auth_strategies[label] =  StrategyInfo.new(strategy, option_fetcher)
+          auth_strategies[label] = StrategyInfo.new(strategy, option_fetcher)
         end
 
         def auth_strategies

data/lib/grape/middleware/base.rb

@@ -2,6 +2,7 @@ module Grape
   module Middleware
     class Base
       attr_reader :app, :env, :options
+      TEXT_HTML = 'text/html'.freeze
 
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
@@ -37,6 +38,7 @@ module Grape
       end
 
       def response
+        return @app_response if @app_response.is_a?(Rack::Response)
         Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
@@ -49,13 +51,15 @@ module Grape
       end
 
       def content_type
-        content_type_for(env['api.format'] || options[:format]) || 'text/html'
+        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || TEXT_HTML
       end
 
       def mime_types
-        content_types.each_with_object({}) do |(k, v), types_without_params|
-          types_without_params[k] = v.split(';').first
-        end.invert
+        types_without_params = {}
+        content_types.each_pair do |k, v|
+          types_without_params[v.split(';').first] = k
+        end
+        types_without_params
       end
     end
   end

data/lib/grape/middleware/error.rb

@@ -47,6 +47,7 @@ module Grape
       end
 
       def rescuable?(klass)
+        return false if klass == Grape::Exceptions::InvalidVersionHeader
         options[:rescue_all] || (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error } || (options[:base_only_rescue_handlers] || []).include?(klass)
       end
 
@@ -59,7 +60,7 @@ module Grape
       end
 
       def error!(message, status = options[:default_status], headers = {}, backtrace = [])
-        headers = { Grape::Http::Headers::CONTENT_TYPE => content_type }.merge(headers)
+        headers = headers.reverse_merge(Grape::Http::Headers::CONTENT_TYPE => content_type)
         rack_response(format_message(message, backtrace), status, headers)
       end
 
@@ -82,7 +83,7 @@ module Grape
       end
 
       def format_message(message, backtrace)
-        format = env['api.format'] || options[:format]
+        format = env[Grape::Env::API_FORMAT] || options[:format]
         formatter = Grape::ErrorFormatter::Base.formatter_for(format, options)
         throw :error, status: 406, message: "The requested format '#{format}' is not supported." unless formatter
         formatter.call(message, backtrace, options, env)

data/lib/grape/middleware/filter.rb

@@ -3,7 +3,7 @@ module Grape
     # This is a simple middleware for adding before and after filters
     # to Grape APIs. It is used like so:
     #
-    #     use Grape::Middleware::Filter, before: lambda { do_something }, after: lambda { do_something }
+    #     use Grape::Middleware::Filter, before: -> { do_something }, after: -> { do_something }
     class Filter < Base
       def before
         app.instance_eval(&options[:before]) if options[:before]