grape 0.16.2 → 0.17.0

data/grape.gemspec

@@ -22,20 +22,6 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'virtus', '>= 1.0.0'
   s.add_runtime_dependency 'builder'
 
-  s.add_development_dependency 'grape-entity', '0.5.0'
-  s.add_development_dependency 'rake', '~> 10'
-  s.add_development_dependency 'maruku'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'rack-test'
-  s.add_development_dependency 'rspec', '~> 3.0'
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'cookiejar'
-  s.add_development_dependency 'rack-contrib'
-  s.add_development_dependency 'mime-types', '< 3.0'
-  s.add_development_dependency 'appraisal'
-  s.add_development_dependency 'benchmark-ips'
-  s.add_development_dependency 'rubocop', '0.35.1'
-
   s.files         = Dir['**/*'].keep_if { |file| File.file?(file) }
   s.test_files    = Dir['spec/**/*']
   s.require_paths = ['lib']

data/lib/grape.rb

@@ -58,6 +58,7 @@ module Grape
     extend ActiveSupport::Autoload
     autoload :Base
     autoload :Validation
+    autoload :ValidationArrayErrors
     autoload :ValidationErrors
     autoload :MissingVendorOption
     autoload :MissingMimeType
@@ -106,6 +107,7 @@ module Grape
     extend ActiveSupport::Autoload
     autoload :InheritableValues
     autoload :StackableValues
+    autoload :ReverseStackableValues
     autoload :InheritableSetting
     autoload :StrictHashConfiguration
     autoload :Registrable

data/lib/grape/api.rb

@@ -88,6 +88,13 @@ module Grape
       def inherit_settings(other_settings)
         top_level_setting.inherit_from other_settings.point_in_time_copy
 
+        # Propagate any inherited params down to our endpoints, and reset any
+        # compiled routes.
+        endpoints.each do |e|
+          e.inherit_settings(top_level_setting.namespace_stackable)
+          e.reset_routes!
+        end
+
         reset_routes!
       end
     end
@@ -123,8 +130,8 @@ module Grape
     # 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(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options) && self.class.namespace_inheritable(:version_options).key?(:cascade)
+      return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.keys.include?(: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
 

data/lib/grape/dsl/headers.rb

@@ -10,7 +10,7 @@ module Grape
           @header ||= {}
         end
       end
-      alias_method :headers, :header
+      alias headers header
     end
   end
 end

data/lib/grape/dsl/inside_route.rb

@@ -29,9 +29,12 @@ module Grape
         def declared(params, options = {}, declared_params = nil)
           options = options.reverse_merge(include_missing: true, include_parent_namespaces: true)
 
-          declared_params ||= (!options[:include_parent_namespaces] ? route_setting(:declared_params) : (route_setting(:saved_declared_params) || [])).flatten(1) || []
+          all_declared_params = route_setting(:declared_params)
+          current_namespace_declared_params = route_setting(:saved_declared_params).last
 
-          fail ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
+          declared_params ||= options[:include_parent_namespaces] ? all_declared_params : current_namespace_declared_params
+
+          raise ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
 
           if params.is_a? Array
             params.map do |param|
@@ -70,7 +73,7 @@ module Grape
       # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
       # you want only to return params declared against the current/target endpoint.
       def declared(*)
-        fail MethodNotYetAvailable, '#declared is not available prior to parameter validation.'
+        raise MethodNotYetAvailable, '#declared is not available prior to parameter validation.'
       end
 
       # The API version as specified in the URL.
@@ -100,14 +103,12 @@ module Grape
         if permanent
           status 301
           body_message ||= "This resource has been moved permanently to #{url}."
+        elsif env[Grape::Http::Headers::HTTP_VERSION] == 'HTTP/1.1' && request.request_method.to_s.upcase != Grape::Http::Headers::GET
+          status 303
+          body_message ||= "An alternate resource is located at #{url}."
         else
-          if env[Grape::Http::Headers::HTTP_VERSION] == 'HTTP/1.1' && request.request_method.to_s.upcase != Grape::Http::Headers::GET
-            status 303
-            body_message ||= "An alternate resource is located at #{url}."
-          else
-            status 302
-            body_message ||= "This resource has been moved temporarily to #{url}."
-          end
+          status 302
+          body_message ||= "This resource has been moved temporarily to #{url}."
         end
         header 'Location', url
         content_type 'text/plain'
@@ -120,11 +121,8 @@ module Grape
       def status(status = nil)
         case status
         when Symbol
-          if Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.include?(status)
-            @status = Rack::Utils.status_code(status)
-          else
-            fail ArgumentError, "Status code :#{status} is invalid."
-          end
+          raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.include?(status)
+          @status = Rack::Utils.status_code(status)
         when Fixnum
           @status = status
         when nil
@@ -136,7 +134,7 @@ module Grape
             200
           end
         else
-          fail ArgumentError, 'Status code must be Fixnum or Symbol.'
+          raise ArgumentError, 'Status code must be Fixnum or Symbol.'
         end
       end
 
@@ -260,7 +258,7 @@ module Grape
         if key
           representation = (@body || {}).merge(key => representation)
         elsif entity_class.present? && @body
-          fail ArgumentError, "Representation of type #{representation.class} cannot be merged." unless representation.respond_to?(:merge)
+          raise ArgumentError, "Representation of type #{representation.class} cannot be merged." unless representation.respond_to?(:merge)
           representation = @body.merge(representation)
         end
 

data/lib/grape/dsl/middleware.rb

@@ -15,7 +15,21 @@ module Grape
         # @param middleware_class [Class] The class of the middleware you'd like
         #   to inject.
         def use(middleware_class, *args, &block)
-          arr = [middleware_class, *args]
+          arr = [:use, middleware_class, *args]
+          arr << block if block_given?
+
+          namespace_stackable(:middleware, arr)
+        end
+
+        def insert_before(*args, &block)
+          arr = [:insert_before, *args]
+          arr << block if block_given?
+
+          namespace_stackable(:middleware, arr)
+        end
+
+        def insert_after(*args, &block)
+          arr = [:insert_after, *args]
           arr << block if block_given?
 
           namespace_stackable(:middleware, arr)

data/lib/grape/dsl/parameters.rb

@@ -34,13 +34,13 @@ module Grape
         options = names.extract_options!
         names.each do |name|
           params_block = named_params.fetch(name) do
-            fail "Params :#{name} not found!"
+            raise "Params :#{name} not found!"
           end
           instance_exec(options, &params_block)
         end
       end
-      alias_method :use_scope, :use
-      alias_method :includes, :use
+      alias use_scope use
+      alias includes use
 
       # Require one or more parameters for the current endpoint.
       #
@@ -121,8 +121,8 @@ module Grape
 
         # check type for optional parameter group
         if attrs && block_given?
-          fail Grape::Exceptions::MissingGroupTypeError.new if type.nil?
-          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
+          raise Grape::Exceptions::MissingGroupTypeError.new if type.nil?
+          raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
 
         if opts[:using]
@@ -167,7 +167,8 @@ module Grape
       # @yield a parameter definition DSL
       def given(*attrs, &block)
         attrs.each do |attr|
-          fail Grape::Exceptions::UnknownParameter.new(attr) unless declared_param?(attr)
+          attr_ = attr.is_a?(Hash) ? attr.keys[0] : attr
+          raise Grape::Exceptions::UnknownParameter.new(attr_) unless declared_param?(attr_)
         end
         new_lateral_scope(dependent_on: attrs, &block)
       end
@@ -181,7 +182,7 @@ module Grape
         @declared_params.flatten.include?(param)
       end
 
-      alias_method :group, :requires
+      alias group requires
 
       # @param params [Hash] initial hash of parameters
       # @return hash of parameters relevant for the current scope
@@ -189,13 +190,14 @@ module Grape
       def params(params)
         params = @parent.params(params) if @parent
         if @element
-          if params.is_a?(Array)
-            params = params.flat_map { |el| el[@element] || {} }
-          elsif params.is_a?(Hash)
-            params = params[@element] || {}
-          else
-            params = {}
-          end
+          params = if params.is_a?(Array)
+                     # used for calculating parent array indices for error messages
+                     params.map { |el| el[@element] || {} }
+                   elsif params.is_a?(Hash)
+                     params[@element] || {}
+                   else
+                     {}
+                   end
         end
         params
       end

data/lib/grape/dsl/request_response.rb

@@ -23,7 +23,7 @@ module Grape
             namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, {}))
             # define a single mime type
             mime_type = content_types[new_format.to_sym]
-            fail Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
+            raise Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
             namespace_stackable(:content_types, new_format.to_sym => mime_type)
           else
             namespace_inheritable(:format)
@@ -51,11 +51,11 @@ module Grape
         end
 
         def error_formatter(format, options)
-          if options.is_a?(Hash) && options.key?(:with)
-            formatter = options[:with]
-          else
-            formatter = options
-          end
+          formatter = if options.is_a?(Hash) && options.key?(:with)
+                        options[:with]
+                      else
+                        options
+                      end
 
           namespace_stackable(:error_formatters, format.to_sym => formatter)
         end
@@ -106,23 +106,27 @@ module Grape
 
           options = args.extract_options!
           if block_given? && options.key?(:with)
-            fail ArgumentError, 'both :with option and block cannot be passed'
+            raise ArgumentError, 'both :with option and block cannot be passed'
           end
           handler ||= extract_with(options)
 
-          if args.include?(:all)
+          case
+          when args.include?(:all)
             namespace_inheritable(:rescue_all, true)
             namespace_inheritable :all_rescue_handler, handler
+          when args.include?(:grape_exceptions)
+            namespace_inheritable(:rescue_all, true)
+            namespace_inheritable(:rescue_grape_exceptions, true)
           else
             handler_type =
-                case options[:rescue_subclasses]
-                when nil, true
-                  :rescue_handlers
-                else
-                  :base_only_rescue_handlers
-                end
-
-            namespace_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
+              case options[:rescue_subclasses]
+              when nil, true
+                :rescue_handlers
+              else
+                :base_only_rescue_handlers
+              end
+
+            namespace_reverse_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
           end
 
           namespace_stackable(:rescue_options, options)
@@ -149,7 +153,7 @@ module Grape
         # @param model_class [Class] The model class that will be represented.
         # @option options [Class] :with The entity class that will represent the model.
         def represent(model_class, options)
-          fail Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
+          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
           namespace_stackable(:representations, model_class => options[:with])
         end
 
@@ -157,10 +161,10 @@ module Grape
 
         def extract_with(options)
           return unless options.key?(:with)
-          with_option = options[:with]
+          with_option = options.delete(:with)
           return with_option if with_option.instance_of?(Proc)
-          return if with_option.instance_of?(Symbol) || with_option.instance_of?(String)
-          fail ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc"
+          return with_option.to_sym if with_option.instance_of?(Symbol) || with_option.instance_of?(String)
+          raise ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc"
         end
       end
     end

data/lib/grape/dsl/routing.rb

@@ -30,20 +30,21 @@ module Grape
           if args.any?
             options = args.extract_options!
             options = options.reverse_merge(using: :path)
+            requested_versions = args.flatten
 
-            fail Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
+            raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
-            @versions = versions | args
+            @versions = versions | requested_versions
 
             if block_given?
               within_namespace do
-                namespace_inheritable(:version, args)
+                namespace_inheritable(:version, requested_versions)
                 namespace_inheritable(:version_options, options)
 
                 instance_eval(&block)
               end
             else
-              namespace_inheritable(:version, args)
+              namespace_inheritable(:version, requested_versions)
               namespace_inheritable(:version_options, options)
             end
           end
@@ -121,9 +122,9 @@ module Grape
             method: methods,
             path: paths,
             for: self,
-            route_options: ({
+            route_options: {
               params: namespace_stackable_with_hash(:params) || {}
-            }).deep_merge(route_setting(:description) || {}).deep_merge(route_options || {})
+            }.deep_merge(route_setting(:description) || {}).deep_merge(route_options || {})
           }
 
           new_endpoint = Grape::Endpoint.new(inheritable_setting, endpoint_options, &block)
@@ -170,10 +171,10 @@ module Grape
           end
         end
 
-        alias_method :group, :namespace
-        alias_method :resource, :namespace
-        alias_method :resources, :namespace
-        alias_method :segment, :namespace
+        alias group namespace
+        alias resource namespace
+        alias resources namespace
+        alias segment namespace
 
         # An array of API routes.
         def routes

data/lib/grape/dsl/settings.rb

@@ -94,12 +94,28 @@ module Grape
         get_or_set :namespace_stackable, key, value
       end
 
+      def namespace_reverse_stackable(key, value = nil)
+        get_or_set :namespace_reverse_stackable, key, value
+      end
+
       def namespace_stackable_with_hash(key)
         settings = get_or_set :namespace_stackable, key, nil
         return if settings.blank?
         settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
       end
 
+      def namespace_reverse_stackable_with_hash(key)
+        settings = get_or_set :namespace_reverse_stackable, key, nil
+        return if settings.blank?
+        result = {}
+        settings.each do |setting|
+          setting.each do |field, value|
+            result[field] ||= value
+          end
+        end
+        result
+      end
+
       # (see #unset_global_setting)
       def unset_namespace_stackable(key)
         unset :namespace_stackable, key

data/lib/grape/endpoint.rb

@@ -1,3 +1,5 @@
+require 'grape/middleware/stack'
+
 module Grape
   # An Endpoint is the proxy scope in which all routing
   # blocks are executed. In other words, any methods
@@ -12,21 +14,14 @@ module Grape
 
     class << self
       def new(*args, &block)
-        if self == Endpoint
-          Class.new(Endpoint).new(*args, &block)
-        else
-          super
-        end
+        self == Endpoint ? Class.new(Endpoint).new(*args, &block) : super
       end
 
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
-          if block_given?
-            @before_each << block
-          else
-            return @before_each
-          end
+          return @before_each unless block_given?
+          @before_each << block
         else
           @before_each = [new_setup]
         end
@@ -34,9 +29,7 @@ module Grape
 
       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
+        before_each.each { |blk| blk.call(endpoint) if blk.respond_to?(:call) }
       end
 
       # @api private
@@ -54,7 +47,7 @@ module Grape
       # @raise [NameError] an instance method with the same name already exists
       def generate_api_method(method_name, &block)
         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")
+          raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
         end
 
         define_method(method_name, &block)
@@ -69,6 +62,18 @@ module Grape
       end
     end
 
+    # Create a new endpoint.
+    # @param new_settings [InheritableSetting] settings to determine the params,
+    #   validations, and other properties from.
+    # @param options [Hash] attributes of this endpoint
+    # @option options path [String or Array] the path to this endpoint, within
+    #   the current scope.
+    # @option options method [String or Array] which HTTP method(s) can be used
+    #   to reach this endpoint.
+    # @option options route_options [Hash]
+    # @note This happens at the time of API definition, so in this context the
+    # endpoint does not know if it will be mounted under a different endpoint.
+    # @yield a block defining what your API should do when this endpoint is hit
     def initialize(new_settings, options = {}, &block)
       require_option(options, :path)
       require_option(options, :method)
@@ -97,8 +102,22 @@ module Grape
       @block = self.class.generate_api_method(method_name, &block)
     end
 
+    # Update our settings from a given set of stackable parameters. Used when
+    # the endpoint's API is mounted under another one.
+    def inherit_settings(namespace_stackable)
+      inheritable_setting.route[:saved_validations] += namespace_stackable[:validations]
+      parent_declared_params = namespace_stackable[:declared_params]
+
+      if parent_declared_params
+        inheritable_setting.route[:declared_params] ||= []
+        inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten)
+      end
+
+      endpoints && endpoints.each { |e| e.inherit_settings(namespace_stackable) }
+    end
+
     def require_option(options, key)
-      fail Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
+      raise Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
     end
 
     def method_name
@@ -171,7 +190,7 @@ module Grape
 
     def prepare_version
       version = namespace_inheritable(:version) || []
-      return if version.length == 0
+      return if version.empty?
       version.length == 1 ? version.first.to_s : version
     end
 
@@ -229,9 +248,12 @@ module Grape
 
         run_filters befores, :before
 
+        allowed_methods = env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED]
+        raise Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => allowed_methods) if allowed_methods
+
         run_filters before_validations, :before_validation
 
-        run_validators validations, request unless env[Grape::Env::GRAPE_METHOD_NOT_ALLOWED]
+        run_validators validations, request
 
         run_filters after_validations, :after_validation
 
@@ -245,53 +267,48 @@ module Grape
       end
     end
 
-    def build_stack
-      b = Rack::Builder.new
-
-      b.use Rack::Head
-      b.use Grape::Middleware::Error,
-            format: namespace_inheritable(:format),
-            content_types: namespace_stackable_with_hash(:content_types),
-            default_status: namespace_inheritable(:default_error_status),
-            rescue_all: namespace_inheritable(:rescue_all),
-            default_error_formatter: namespace_inheritable(:default_error_formatter),
-            error_formatters: namespace_stackable_with_hash(:error_formatters),
-            rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
-            rescue_handlers: namespace_stackable_with_hash(:rescue_handlers) || {},
-            base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
-            all_rescue_handler: namespace_inheritable(:all_rescue_handler)
-
-      (namespace_stackable(:middleware) || []).each do |m|
-        m = m.dup
-        block = m.pop if m.last.is_a?(Proc)
-        block ? b.use(*m, &block) : b.use(*m)
-      end
+    def build_stack(helpers)
+      stack = Grape::Middleware::Stack.new
+
+      stack.use Rack::Head
+      stack.use Class.new(Grape::Middleware::Error),
+                helpers: helpers,
+                format: namespace_inheritable(:format),
+                content_types: namespace_stackable_with_hash(:content_types),
+                default_status: namespace_inheritable(:default_error_status),
+                rescue_all: namespace_inheritable(:rescue_all),
+                rescue_grape_exceptions: namespace_inheritable(:rescue_grape_exceptions),
+                default_error_formatter: namespace_inheritable(:default_error_formatter),
+                error_formatters: namespace_stackable_with_hash(:error_formatters),
+                rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
+                rescue_handlers: namespace_reverse_stackable_with_hash(:rescue_handlers) || {},
+                base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
+                all_rescue_handler: namespace_inheritable(:all_rescue_handler)
+
+      stack.concat namespace_stackable(:middleware)
 
       if namespace_inheritable(:version)
-        b.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-              versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil,
-              version_options: namespace_inheritable(:version_options),
-              prefix: namespace_inheritable(:root_prefix)
-
+        stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
+                  versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil,
+                  version_options: namespace_inheritable(:version_options),
+                  prefix: namespace_inheritable(:root_prefix)
       end
 
-      b.use Grape::Middleware::Formatter,
-            format: namespace_inheritable(:format),
-            default_format: namespace_inheritable(:default_format) || :txt,
-            content_types: namespace_stackable_with_hash(:content_types),
-            formatters: namespace_stackable_with_hash(:formatters),
-            parsers: namespace_stackable_with_hash(:parsers)
-
-      b.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
+      stack.use Grape::Middleware::Formatter,
+                format: namespace_inheritable(:format),
+                default_format: namespace_inheritable(:default_format) || :txt,
+                content_types: namespace_stackable_with_hash(:content_types),
+                formatters: namespace_stackable_with_hash(:formatters),
+                parsers: namespace_stackable_with_hash(:parsers)
 
-      b.to_app
+      builder = stack.build
+      builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
+      builder.to_app
     end
 
     def build_helpers
       helpers = namespace_stackable(:helpers) || []
-      Module.new do
-        helpers.each { |mod_to_include| include mod_to_include }
-      end
+      Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
     private :build_stack, :build_helpers
@@ -306,10 +323,8 @@ module Grape
       @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
+        @helpers = build_helpers.tap { |mod| self.class.send(:include, mod) }
+        @app = options[:app] || build_stack(@helpers)
 
         @lazy_initialized = true
       end
@@ -323,10 +338,12 @@ module Grape
           validator.validate(request)
         rescue Grape::Exceptions::Validation => e
           validation_errors << e
+        rescue Grape::Exceptions::ValidationArrayErrors => e
+          validation_errors += e.errors
         end
       end
 
-      validation_errors.any? && fail(Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header)
+      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header)
     end
 
     def run_filters(filters, type = :other)