grape 0.14.0 → 0.15.0

data/lib/grape/middleware/formatter.rb

@@ -19,6 +19,7 @@ module Grape
       end
 
       def after
+        return unless @app_response
         status, headers, bodies = *@app_response
 
         if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
@@ -34,7 +35,7 @@ module Grape
         headers = ensure_content_type(headers)
 
         if bodies.is_a?(Grape::Util::FileResponse)
-          Rack::Response.new([], status, headers) do |resp|
+          Grape::Util::SendfileResponse.new([], status, headers) do |resp|
             resp.body = bodies.file
           end
         else
@@ -49,7 +50,7 @@ module Grape
 
       def fetch_formatter(headers, options)
         api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
-        Grape::Formatter::Base.formatter_for(api_format, options)
+        Grape::Formatter.formatter_for(api_format, options)
       end
 
       # Set the content type header for the API format if it is not already present.
@@ -92,7 +93,7 @@ module Grape
         fmt = mime_types[request.media_type] if request.media_type
         fmt ||= options[:default_format]
         if content_type_for(fmt)
-          parser = Grape::Parser::Base.parser_for fmt, options
+          parser = Grape::Parser.parser_for fmt, options
           if parser
             begin
               body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))

data/lib/grape/middleware/versioner/param.rb

@@ -21,18 +21,29 @@ module Grape
       class Param < Base
         def default_options
           {
-            parameter: 'apiver'.freeze
+            version_options: {
+              parameter: 'apiver'.freeze
+            }
           }
         end
 
         def before
-          paramkey = options[:parameter]
           potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
           return if potential_version.nil?
           throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
           env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH
         end
+
+        private
+
+        def paramkey
+          version_options[:parameter] || default_options[:version_options][:parameter]
+        end
+
+        def version_options
+          options[:version_options]
+        end
       end
     end
   end

data/lib/grape/parser.rb

@@ -0,0 +1,29 @@
+module Grape
+  module Parser
+    class << self
+      def builtin_parsers
+        {
+          json: Grape::Parser::Json,
+          jsonapi: Grape::Parser::Json,
+          xml: Grape::Parser::Xml
+        }
+      end
+
+      def parsers(options)
+        builtin_parsers.merge(options[:parsers] || {})
+      end
+
+      def parser_for(api_format, options = {})
+        spec = parsers(options)[api_format]
+        case spec
+        when nil
+          nil
+        when Symbol
+          method(spec)
+        else
+          spec
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/sendfile_response.rb

@@ -0,0 +1,19 @@
+module Grape
+  module Util
+    # Response should respond to to_path method
+    # for using Rack::SendFile middleware
+    class SendfileResponse < Rack::Response
+      def respond_to?(method_name, include_all = false)
+        if method_name == :to_path
+          @body.respond_to?(:to_path, include_all)
+        else
+          super
+        end
+      end
+
+      def to_path
+        @body.to_path
+      end
+    end
+  end
+end

data/lib/grape/util/strict_hash_configuration.rb

@@ -98,7 +98,7 @@ module Grape
           new_config_class = config_class(*args)
 
           class_mod.send(:define_method, :config_class) do
-            @config_context ||= new_config_class
+            @config_class ||= new_config_class
           end
         end
       end

data/lib/grape/validations/params_scope.rb

@@ -36,7 +36,9 @@ module Grape
       #   validated
       def should_validate?(parameters)
         return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
-        return false if @dependent_on && params(parameters).try(:[], @dependent_on).blank?
+        @dependent_on.each do |dependency|
+          return false if params(parameters).try(:[], dependency).blank?
+        end if @dependent_on
         return true if parent.nil?
         parent.should_validate?(parameters)
       end
@@ -90,7 +92,11 @@ module Grape
       # Adds a parameter declaration to our list of validations.
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
       def push_declared_params(attrs)
-        @declared_params.concat attrs
+        if lateral?
+          @parent.push_declared_params(attrs)
+        else
+          @declared_params.concat attrs
+        end
       end
 
       private
@@ -141,11 +147,18 @@ module Grape
         type = attrs[1] ? attrs[1][:type] : nil
         if attrs.first && !optional
           fail Grape::Exceptions::MissingGroupTypeError.new if type.nil?
-          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless [Array, Hash, JSON, Array[JSON]].include?(type)
+          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
 
         opts = attrs[1] || { type: Array }
-        self.class.new(api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block)
+
+        self.class.new(
+          api:      @api,
+          element:  attrs.first,
+          parent:   self,
+          optional: optional,
+          type:     opts[:type],
+          &block)
       end
 
       # Returns a new parameter scope, not nested under any current-level param
@@ -191,7 +204,7 @@ module Grape
         default = validations[:default]
         doc_attrs[:default] = default if validations.key?(:default)
 
-        values = validations[:values]
+        values = (options_key?(:values, :value, validations)) ? validations[:values][:value] : validations[:values]
         doc_attrs[:values] = values if values
 
         coerce_type = guess_coerce_type(coerce_type, values)
@@ -211,6 +224,7 @@ module Grape
         if validations.key?(:presence) && validations[:presence]
           validate('presence', validations[:presence], attrs, doc_attrs)
           validations.delete(:presence)
+          validations.delete(:message) if validations.key?(:message)
         end
 
         # Before we run the rest of the validators, let's handle
@@ -241,8 +255,12 @@ module Grape
           fail ArgumentError, ':type may not be supplied with :types'
         end
 
-        validations[:coerce] = validations[:type] if validations.key?(:type)
-        validations[:coerce] = validations.delete(:types) if validations.key?(:types)
+        validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type)
+        validations[:coerce_message] = (options_key?(:type, :message, validations) ? validations[:type][:message] : nil) if validations.key?(:type)
+        validations[:coerce] = (options_key?(:types, :value, validations) ? validations[:types][:value] : validations[:types]) if validations.key?(:types)
+        validations[:coerce_message] = (options_key?(:types, :message, validations) ? validations[:types][:message] : nil) if validations.key?(:types)
+
+        validations.delete(:types) if validations.key?(:types)
 
         coerce_type = validations[:coerce]
 
@@ -287,11 +305,13 @@ module Grape
 
         coerce_options = {
           type: validations[:coerce],
-          method: validations[:coerce_with]
+          method: validations[:coerce_with],
+          message: validations[:coerce_message]
         }
         validate('coerce', coerce_options, attrs, doc_attrs)
         validations.delete(:coerce_with)
         validations.delete(:coerce)
+        validations.delete(:coerce_message)
       end
 
       def guess_coerce_type(coerce_type, values)
@@ -303,7 +323,7 @@ module Grape
       def check_incompatible_option_values(values, default)
         return unless values && default
         return if values.is_a?(Proc) || default.is_a?(Proc)
-        return if values.include?(default)
+        return if values.include?(default) || (Array(default) - Array(values)).empty?
         fail Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
       end
 
@@ -329,6 +349,16 @@ module Grape
         return unless value_types.any? { |v| !v.is_a?(coerce_type) }
         fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
       end
+
+      def extract_message_option(attrs)
+        return nil unless attrs.is_a?(Array)
+        opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
+        (opts.key?(:message) && !opts[:message].nil?) ? opts.delete(:message) : nil
+      end
+
+      def options_key?(type, key, validations)
+        validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil?
+      end
     end
   end
 end

data/lib/grape/validations/types.rb

@@ -63,6 +63,13 @@ module Grape
         Rack::Multipart::UploadedFile => File
       }
 
+      GROUPS = [
+        Array,
+        Hash,
+        JSON,
+        Array[JSON]
+      ]
+
       # Is the given class a primitive type as recognized by Grape?
       #
       # @param type [Class] type to check
@@ -126,6 +133,15 @@ module Grape
         SPECIAL.key? type
       end
 
+      # Is the declared type a supported group type?
+      # Currently supported group types are Array, Hash, JSON, and Array[JSON]
+      #
+      # @param type [Array<Class>,Class] type to check
+      # @return [Boolean] +true+ if the type is a supported group type
+      def self.group?(type)
+        GROUPS.include? type
+      end
+
       # A valid custom type must implement a class-level `parse` method, taking
       #   one String argument and returning the parsed value in its correct type.
       # @param type [Class] type to check

data/lib/grape/validations/validators/all_or_none.rb

@@ -5,7 +5,7 @@ module Grape
       def validate!(params)
         super
         if scope_requires_params && only_subset_present
-          fail Grape::Exceptions::Validation, params: all_keys, message_key: :all_or_none
+          fail Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
         end
         params
       end

data/lib/grape/validations/validators/allow_blank.rb

@@ -2,7 +2,7 @@ module Grape
   module Validations
     class AllowBlankValidator < Base
       def validate_param!(attr_name, params)
-        return if @option || !params.is_a?(Hash)
+        return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
 
         value = params[attr_name]
         value = value.strip if value.respond_to?(:strip)
@@ -23,7 +23,7 @@ module Grape
 
         return if value == false || value.present?
 
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :blank
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank)
       end
     end
   end

data/lib/grape/validations/validators/at_least_one_of.rb

@@ -5,7 +5,7 @@ module Grape
       def validate!(params)
         super
         if scope_requires_params && no_exclusive_params_are_present
-          fail Grape::Exceptions::Validation, params: all_keys, message_key: :at_least_one
+          fail Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
         end
         params
       end

data/lib/grape/validations/validators/base.rb

@@ -17,6 +17,22 @@ module Grape
         @scope = scope
       end
 
+      # Validates a given request.
+      # @note This method must be thread-safe.
+      # @note Override #validate! unless you need to access the entire request.
+      # @param request [Grape::Request] the request currently being handled
+      # @raise [Grape::Exceptions::Validation] if validation failed
+      # @return [void]
+      def validate(request)
+        validate!(request.params)
+      end
+
+      # Validates a given parameter hash.
+      # @note This method must be thread-safe.
+      # @note Override #validate iff you need to access the entire request.
+      # @param params [Hash] parameters to validate
+      # @raise [Grape::Exceptions::Validation] if validation failed
+      # @return [void]
       def validate!(params)
         attributes = AttributesIterator.new(self, @scope, params)
         attributes.each do |resource_params, attr_name|
@@ -39,6 +55,16 @@ module Grape
         short_name = convert_to_short_name(klass)
         Validations.register_validator(short_name, klass)
       end
+
+      def message(default_key = nil)
+        options = instance_variable_get(:@option)
+        options_key?(:message) ? options[:message] : default_key
+      end
+
+      def options_key?(key, options = nil)
+        options = instance_variable_get(:@option) if options.nil?
+        options.respond_to?(:key?) && options.key?(key) && !options[key].nil?
+      end
     end
   end
 end

data/lib/grape/validations/validators/coerce.rb

@@ -5,18 +5,31 @@ module Grape
 
   module Validations
     class CoerceValidator < Base
+      def initialize(*_args)
+        super
+        @converter = Types.build_coercer(type, @option[:method])
+      end
+
       def validate_param!(attr_name, params)
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :coerce unless params.is_a? Hash
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
         new_value = coerce_value(params[attr_name])
         if valid_type?(new_value)
           params[attr_name] = new_value
         else
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :coerce
+          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce)
         end
       end
 
       private
 
+      # @!attribute [r] converter
+      # Object that will be used for parameter coercion and type checking.
+      #
+      # See {Types.build_coercer}
+      #
+      # @return [Virtus::Attribute]
+      attr_reader :converter
+
       def valid_type?(val)
         # Special value to denote coercion failure
         return false if val.instance_of?(Types::InvalidValue)
@@ -47,18 +60,7 @@ module Grape
       #
       # @return [Class]
       def type
-        @option[:type]
-      end
-
-      # Create and cache the attribute object
-      # that will be used for parameter coercion
-      # and type checking.
-      #
-      # See {Types.build_coercer}
-      #
-      # @return [Virtus::Attribute]
-      def converter
-        @converter ||= Types.build_coercer(type, @option[:method])
+        @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
       end
     end
   end

data/lib/grape/validations/validators/default.rb

@@ -15,7 +15,7 @@ module Grape
 
         attrs = AttributesIterator.new(self, @scope, params)
         attrs.each do |resource_params, attr_name|
-          if resource_params[attr_name].nil?
+          if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
             validate_param!(attr_name, resource_params)
           end
         end

data/lib/grape/validations/validators/exactly_one_of.rb

@@ -5,11 +5,20 @@ module Grape
       def validate!(params)
         super
         if scope_requires_params && none_of_restricted_params_is_present
-          fail Grape::Exceptions::Validation, params: all_keys, message_key: :exactly_one
+          fail Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
         end
         params
       end
 
+      def message(default_key = nil)
+        options = instance_variable_get(:@option)
+        if options_key?(:message)
+          (options_key?(default_key, options[:message]) ? options[:message][default_key] : options[:message])
+        else
+          default_key
+        end
+      end
+
       private
 
       def none_of_restricted_params_is_present

data/lib/grape/validations/validators/mutual_exclusion.rb

@@ -7,7 +7,7 @@ module Grape
       def validate!(params)
         super
         if two_or_more_exclusive_params_are_present
-          fail Grape::Exceptions::Validation, params: processing_keys_in_common, message_key: :mutual_exclusion
+          fail Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
         end
         params
       end

data/lib/grape/validations/validators/presence.rb

@@ -8,7 +8,7 @@ module Grape
 
       def validate_param!(attr_name, params)
         return if params.respond_to?(:key?) && params.key?(attr_name)
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :presence
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)
       end
     end
   end