grape 0.13.0 → 0.14.0

data/lib/grape/dsl/parameters.rb

@@ -31,7 +31,7 @@ module Grape
       #     end
       def use(*names)
         named_params = Grape::DSL::Configuration.stacked_hash_to_hash(@api.namespace_stackable(:named_params)) || {}
-        options = names.last.is_a?(Hash) ? names.pop : {}
+        options = names.extract_options!
         names.each do |name|
           params_block = named_params.fetch(name) do
             fail "Params :#{name} not found!"
@@ -49,19 +49,30 @@ module Grape
       #   the :using hash. The last key can be a hash, which specifies
       #   options for the parameters
       # @option attrs :type [Class] the type to coerce this parameter to before
-      #   passing it to the endpoint. See Grape::ParameterTypes for supported
-      #   types, or use a class that defines `::parse` as a custom type
+      #   passing it to the endpoint. See {Grape::Validations::Types} for a list of
+      #   types that are supported automatically. Custom classes may be used
+      #   where they define a class-level `::parse` method, or in conjunction
+      #   with the `:coerce_with` parameter. `JSON` may be supplied to denote
+      #   `JSON`-formatted objects or arrays of objects. `Array[JSON]` accepts
+      #   the same values as `JSON` but will wrap single objects in an `Array`.
+      # @option attrs :types [Array<Class>] may be supplied in place of +:type+
+      #   to declare an attribute that has multiple allowed types. See
+      #   {Validations::Types::MultipleTypeCoercer} for more details on coercion
+      #   and validation rules for variant-type parameters.
       # @option attrs :desc [String] description to document this parameter
       # @option attrs :default [Object] default value, if parameter is optional
       # @option attrs :values [Array] permissable values for this field. If any
       #   other value is given, it will be handled as a validation error
       # @option attrs :using [Hash[Symbol => Hash]] a hash defining keys and
-      #   options, like that returned by Grape::Entity#documentation. The value
+      #   options, like that returned by {Grape::Entity#documentation}. The value
       #   of each key is an options hash accepting the same parameters
       # @option attrs :except [Array[Symbol]] a list of keys to exclude from
       #   the :using Hash. The meaning of this depends on if :all or :none was
       #   passed; :all + :except will make the :except fields optional, whereas
       #   :none + :except will make the :except fields required
+      # @option attrs :coerce_with [#parse, #call] method to be used when coercing
+      #   the parameter to the type named by `attrs[:type]`. Any class or object
+      #   that defines `::parse` or `::call` may be used.
       #
       # @example
       #
@@ -86,7 +97,7 @@ module Grape
       def requires(*attrs, &block)
         orig_attrs = attrs.clone
 
-        opts = attrs.last.is_a?(Hash) ? attrs.pop.clone : {}
+        opts = attrs.extract_options!.clone
         opts[:presence] = true
 
         if opts[:using]
@@ -94,8 +105,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block_given? ? new_scope(orig_attrs, &block) :
-              push_declared_params(attrs)
+          block_given? ? new_scope(orig_attrs, &block) : push_declared_params(attrs)
         end
       end
 
@@ -106,7 +116,7 @@ module Grape
       def optional(*attrs, &block)
         orig_attrs = attrs.clone
 
-        opts = attrs.last.is_a?(Hash) ? attrs.pop.clone : {}
+        opts = attrs.extract_options!.clone
         type = opts[:type]
 
         # check type for optional parameter group
@@ -120,8 +130,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block_given? ? new_scope(orig_attrs, true, &block) :
-              push_declared_params(attrs)
+          block_given? ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs)
         end
       end
 
@@ -153,7 +162,7 @@ module Grape
       # the given parameter is present. The parameters are not nested.
       # @param attr [Symbol] the parameter which, if present, triggers the
       #   validations
-      # @throws Grape::Exceptions::UnknownParameter if `attr` has not been
+      # @raise Grape::Exceptions::UnknownParameter if `attr` has not been
       #   defined in this scope yet
       # @yield a parameter definition DSL
       def given(attr, &block)
@@ -163,7 +172,7 @@ module Grape
 
       # Test for whether a certain parameter has been defined in this params
       # block yet.
-      # @returns [Boolean] whether the parameter has been defined
+      # @return [Boolean] whether the parameter has been defined
       def declared_param?(param)
         # @declared_params also includes hashes of options and such, but those
         # won't be flattened out.

data/lib/grape/dsl/request_response.rb

@@ -104,7 +104,7 @@ module Grape
             handler = block
           end
 
-          options = args.last.is_a?(Hash) ? args.pop : {}
+          options = args.extract_options!
           handler ||= proc { options[:with] } if options.key?(:with)
 
           if args.include?(:all)

data/lib/grape/dsl/routing.rb

@@ -28,9 +28,8 @@ module Grape
         #
         def version(*args, &block)
           if args.any?
-            options = args.pop if args.last.is_a? Hash
-            options ||= {}
-            options = { using: :path }.merge(options)
+            options = args.extract_options!
+            options = options.reverse_merge(using: :path)
 
             fail Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
@@ -76,7 +75,7 @@ module Grape
 
             if app.respond_to?(:inheritable_setting, true)
               mount_path = Rack::Mount::Utils.normalize_path(path)
-              app.top_level_setting.namespace_stackable[:mount_path] =  mount_path
+              app.top_level_setting.namespace_stackable[:mount_path] = mount_path
 
               app.inherit_settings(inheritable_setting)
 

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
 
@@ -74,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)
@@ -119,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
@@ -187,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.
@@ -215,9 +227,8 @@ module Grape
 
     protected
 
-    def run(env)
+    def run
       ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @env = env
         @header = {}
 
         @request = Grape::Request.new(env)
@@ -226,7 +237,7 @@ module Grape
 
         cookies.read(@request)
 
-        self.class.before_each.call(self) if self.class.before_each
+        self.class.run_before_each(self)
 
         run_filters befores, :before
 
@@ -235,8 +246,6 @@ module Grape
         # Retrieve validations from this namespace and all parent namespaces.
         validation_errors = []
 
-        # require 'pry-byebug'; binding.pry
-
         route_setting(:saved_validations).each do |validator|
           begin
             validator.validate!(params)
@@ -261,7 +270,7 @@ module Grape
       end
     end
 
-    def build_middleware
+    def build_stack
       b = Rack::Builder.new
 
       b.use Rack::Head
@@ -302,15 +311,39 @@ 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, type = :other)
@@ -319,6 +352,8 @@ module Grape
           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/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/locale/en.yml

@@ -35,7 +35,7 @@ en:
         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:
@@ -45,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.
@@ -50,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