grape 0.13.0 → 0.14.0

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

@@ -21,20 +21,17 @@ module Grape
       class Param < Base
         def default_options
           {
-            parameter: 'apiver'
+            parameter: 'apiver'.freeze
           }
         end
 
         def before
           paramkey = options[:parameter]
           potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
-          unless potential_version.nil?
-            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
-            end
-            env['api.version'] = potential_version
-            env['rack.request.query_hash'].delete(paramkey) if env.key? 'rack.request.query_hash'
-          end
+          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
       end
     end

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

@@ -0,0 +1,20 @@
+module Rack
+  module Accept
+    module Header
+      class << self
+        # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44
+        def parse_media_type(media_type)
+          # see http://tools.ietf.org/html/rfc6838#section-4.2 for allowed characters in media type names
+          m = media_type.to_s.match(%r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$})
+          m ? [m[1], m[2], m[3] || ''] : []
+        end
+      end
+    end
+
+    class MediaType
+      def parse_media_type(media_type)
+        Header.parse_media_type(media_type)
+      end
+    end
+  end
+end

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

@@ -33,12 +33,9 @@ module Grape
 
           pieces = path.split('/')
           potential_version = pieces[1]
-          if potential_version =~ options[:pattern]
-            if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: '404 API Version Not Found'
-            end
-            env['api.version'] = potential_version
-          end
+          return unless potential_version =~ options[:pattern]
+          throw :error, status: 404, message: '404 API Version Not Found' if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
+          env[Grape::Env::API_VERSION] = potential_version
         end
 
         private

data/lib/grape/path.rb

@@ -29,18 +29,18 @@ module Grape
       !!(settings[:version] && settings[:version_options][:using] == :path)
     end
 
-    def has_namespace?
+    def namespace?
       namespace && namespace.to_s =~ /^\S/ && namespace != '/'
     end
 
-    def has_path?
+    def path?
       raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
     end
 
     def suffix
       if uses_specific_format?
         "(.#{settings[:format]})"
-      elsif !uses_path_versioning? || (has_namespace? || has_path?)
+      elsif !uses_path_versioning? || (namespace? || path?)
         '(.:format)'
       else
         '(/.:format)'

data/lib/grape/request.rb

@@ -0,0 +1,40 @@
+module Grape
+  class Request < Rack::Request
+    HTTP_PREFIX = 'HTTP_'.freeze
+
+    alias_method :rack_params, :params
+
+    def params
+      @params ||= build_params
+    end
+
+    def headers
+      @headers ||= build_headers
+    end
+
+    private
+
+    def build_params
+      params = Hashie::Mash.new(rack_params)
+      if env[Grape::Env::RACK_ROUTING_ARGS]
+        args = env[Grape::Env::RACK_ROUTING_ARGS].dup
+        # preserve version from query string parameters
+        args.delete(:version)
+        args.delete(:route_info)
+        params.deep_merge!(args)
+      end
+      params
+    end
+
+    def build_headers
+      headers = {}
+      env.each_pair do |k, v|
+        next unless k.to_s.start_with? HTTP_PREFIX
+
+        k = k[5..-1].split('_').each(&:capitalize!).join('-')
+        headers[k] = v
+      end
+      headers
+    end
+  end
+end

data/lib/grape/util/content_types.rb

@@ -1,18 +1,18 @@
 module Grape
   module ContentTypes
     # Content types are listed in order of preference.
-    CONTENT_TYPES = ActiveSupport::OrderedHash[
-                    :xml,  'application/xml',
-                    :serializable_hash, 'application/json',
-                    :json, 'application/json',
-                    :binary, 'application/octet-stream',
-                    :txt,  'text/plain'
-   ]
+    CONTENT_TYPES = {
+      xml: 'application/xml',
+      serializable_hash: 'application/json',
+      json: 'application/json',
+      binary: 'application/octet-stream',
+      txt: 'text/plain'
+    }
 
     def self.content_types_for_settings(settings)
-      return nil if settings.nil? || settings.blank?
+      return if settings.blank?
 
-      settings.each_with_object(ActiveSupport::OrderedHash.new) { |value, result| result.merge!(value) }
+      settings.each_with_object({}) { |value, result| result.merge!(value) }
     end
 
     def self.content_types_for(from_settings)

data/lib/grape/util/env.rb

@@ -0,0 +1,22 @@
+module Grape
+  module Env
+    API_VERSION = 'api.version'.freeze
+    API_ENDPOINT = 'api.endpoint'.freeze
+    API_REQUEST_INPUT = 'api.request.input'.freeze
+    API_REQUEST_BODY = 'api.request.body'.freeze
+    API_TYPE = 'api.type'.freeze
+    API_SUBTYPE = 'api.subtype'.freeze
+    API_VENDOR = 'api.vendor'.freeze
+    API_FORMAT = 'api.format'.freeze
+
+    RACK_INPUT = 'rack.input'.freeze
+    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'.freeze
+    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'.freeze
+    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'.freeze
+    RACK_ROUTING_ARGS = 'rack.routing_args'.freeze
+
+    GRAPE_REQUEST = 'grape.request'.freeze
+    GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze
+    GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze
+  end
+end

data/lib/grape/util/strict_hash_configuration.rb

@@ -64,7 +64,8 @@ module Grape
           end
 
           define_method 'to_hash' do
-            merge_hash = setting_name.keys.each_with_object({}) { |k, hash| hash[k] = send("#{k}_context").to_hash }
+            merge_hash = {}
+            setting_name.each_key { |k| merge_hash[k] = send("#{k}_context").to_hash }
 
             @settings.to_hash.merge(
               merge_hash

data/lib/grape/validations/attributes_iterator.rb

@@ -3,15 +3,20 @@ module Grape
     class AttributesIterator
       include Enumerable
 
+      attr_reader :scope
+
       def initialize(validator, scope, params)
+        @scope = scope
         @attrs = validator.attrs
-        @params = scope.params(params)
-        @params = (@params.is_a?(Array) ? @params : [@params])
+        @params = Array.wrap(scope.params(params))
       end
 
       def each
         @params.each do |resource_params|
-          @attrs.each do |attr_name|
+          @attrs.each_with_index do |attr_name, index|
+            if resource_params.is_a?(Hash) && resource_params[attr_name].is_a?(Array)
+              scope.index = index
+            end
             yield resource_params, attr_name
           end
         end

data/lib/grape/validations/params_scope.rb

@@ -1,7 +1,7 @@
 module Grape
   module Validations
     class ParamsScope
-      attr_accessor :element, :parent
+      attr_accessor :element, :parent, :index
 
       include Grape::DSL::Parameters
 
@@ -46,7 +46,7 @@ module Grape
         case
         when nested?
           # Find our containing element's name, and append ours.
-          "#{@parent.full_name(@element)}[#{name}]"
+          "#{@parent.full_name(@element)}#{parent_index}[#{name}]"
         when lateral?
           # Find the name of the element as if it was at the
           # same nesting level as our parent.
@@ -57,6 +57,10 @@ module Grape
         end
       end
 
+      def parent_index
+        "[#{@parent.index}]" if @parent.present? && @parent.index.present?
+      end
+
       # @return [Boolean] whether or not this scope is the root-level scope
       def root?
         !@parent
@@ -137,7 +141,7 @@ 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].include?(type)
+          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless [Array, Hash, JSON, Array[JSON]].include?(type)
         end
 
         opts = attrs[1] || { type: Array }
@@ -177,10 +181,7 @@ module Grape
       def validates(attrs, validations)
         doc_attrs = { required: validations.keys.include?(:presence) }
 
-        # special case (type = coerce)
-        validations[:coerce] = validations.delete(:type) if validations.key?(:type)
-
-        coerce_type = validations[:coerce]
+        coerce_type = infer_coercion(validations)
 
         doc_attrs[:type] = coerce_type.to_s if coerce_type
 
@@ -212,19 +213,87 @@ module Grape
           validations.delete(:presence)
         end
 
-        # Before we run the rest of the validators, lets handle
+        # Before we run the rest of the validators, let's handle
         # whatever coercion so that we are working with correctly
         # type casted values
-        if validations.key? :coerce
-          validate('coerce', validations[:coerce], attrs, doc_attrs)
-          validations.delete(:coerce)
-        end
+        coerce_type validations, attrs, doc_attrs
 
         validations.each do |type, options|
           validate(type, options, attrs, doc_attrs)
         end
       end
 
+      # Validate and comprehend the +:type+, +:types+, and +:coerce_with+
+      # options that have been supplied to the parameter declaration.
+      # The +:type+ and +:types+ options will be removed from the
+      # validations list, replaced appropriately with +:coerce+ and
+      # +:coerce_with+ options that will later be passed to
+      # {Validators::CoerceValidator}. The type that is returned may be
+      # used for documentation and further validation of parameter
+      # options.
+      #
+      # @param validations [Hash] list of validations supplied to the
+      #   parameter declaration
+      # @return [class-like] type to which the parameter will be coerced
+      # @raise [ArgumentError] if the given type options are invalid
+      def infer_coercion(validations)
+        if validations.key?(:type) && validations.key?(:types)
+          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)
+
+        coerce_type = validations[:coerce]
+
+        # Special case - when the argument is a single type that is a
+        # variant-type collection.
+        if Types.multiple?(coerce_type) && validations.key?(:type)
+          validations[:coerce] = Types::VariantCollectionCoercer.new(
+            coerce_type,
+            validations.delete(:coerce_with)
+          )
+        end
+        validations.delete(:type)
+
+        coerce_type
+      end
+
+      # Enforce correct usage of :coerce_with parameter.
+      # We do not allow coercion without a type, nor with
+      # +JSON+ as a type since this defines its own coercion
+      # method.
+      def check_coerce_with(validations)
+        return unless validations.key?(:coerce_with)
+        # type must be supplied for coerce_with..
+        fail ArgumentError, 'must supply type for coerce_with' unless validations.key?(:coerce)
+
+        # but not special JSON types, which
+        # already imply coercion method
+        return unless [JSON, Array[JSON]].include? validations[:coerce]
+        fail ArgumentError, 'coerce_with disallowed for type: JSON'
+      end
+
+      # Add type coercion validation to this scope,
+      # if any has been specified.
+      # This validation has special handling since it is
+      # composited from more than one +requires+/+optional+
+      # parameter, and needs to be run before most other
+      # validations.
+      def coerce_type(validations, attrs, doc_attrs)
+        check_coerce_with(validations)
+
+        return unless validations.key?(:coerce)
+
+        coerce_options = {
+          type: validations[:coerce],
+          method: validations[:coerce_with]
+        }
+        validate('coerce', coerce_options, attrs, doc_attrs)
+        validations.delete(:coerce_with)
+        validations.delete(:coerce)
+      end
+
       def guess_coerce_type(coerce_type, values)
         return coerce_type if !values || values.is_a?(Proc)
         return values.first.class if coerce_type == Array && (values.is_a?(Range) || !values.empty?)
@@ -257,9 +326,8 @@ module Grape
         if coerce_type == Virtus::Attribute::Boolean
           value_types = value_types.map { |type| Virtus::Attribute.build(type) }
         end
-        if value_types.any? { |v| !v.is_a?(coerce_type) }
-          fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
-        end
+        return unless value_types.any? { |v| !v.is_a?(coerce_type) }
+        fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
       end
     end
   end

data/lib/grape/validations/types.rb

@@ -0,0 +1,144 @@
+require_relative 'types/build_coercer'
+require_relative 'types/custom_type_coercer'
+require_relative 'types/multiple_type_coercer'
+require_relative 'types/variant_collection_coercer'
+require_relative 'types/json'
+require_relative 'types/file'
+
+# Patch for Virtus::Attribute::Collection
+# See the file for more details
+require_relative 'types/virtus_collection_patch'
+
+module Grape
+  module Validations
+    # Module for code related to grape's system for
+    # coercion and type validation of incoming request
+    # parameters.
+    #
+    # Grape uses a number of tests and assertions to
+    # work out exactly how a parameter should be handled,
+    # based on the +type+ and +coerce_with+ options that
+    # may be supplied to {Grape::Dsl::Parameters#requires}
+    # and {Grape::Dsl::Parameters#optional}. The main
+    # entry point for this process is {Types.build_coercer}.
+    module Types
+      # Instances of this class may be used as tokens to denote that
+      # a parameter value could not be coerced.
+      class InvalidValue; end
+
+      # Types representing a single value, which are coerced through Virtus
+      # or special logic in Grape.
+      PRIMITIVES = [
+        # Numerical
+        Integer,
+        Float,
+        BigDecimal,
+        Numeric,
+
+        # Date/time
+        Date,
+        DateTime,
+        Time,
+
+        # Misc
+        Virtus::Attribute::Boolean,
+        String,
+        Symbol,
+        Rack::Multipart::UploadedFile
+      ]
+
+      # Types representing data structures.
+      STRUCTURES = [
+        Hash,
+        Array,
+        Set
+      ]
+
+      # Types for which Grape provides special coercion
+      # and type-checking logic.
+      SPECIAL = {
+        JSON => Json,
+        Array[JSON] => JsonArray,
+        ::File => File,
+        Rack::Multipart::UploadedFile => File
+      }
+
+      # Is the given class a primitive type as recognized by Grape?
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] whether or not the type is known by Grape as a valid
+      #   type for a single value
+      def self.primitive?(type)
+        PRIMITIVES.include?(type)
+      end
+
+      # Is the given class a standard data structure (collection or map)
+      # as recognized by Grape?
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] whether or not the type is known by Grape as a valid
+      #   data structure type
+      # @note This method does not yet consider 'complex types', which inherit
+      #   Virtus.model.
+      def self.structure?(type)
+        STRUCTURES.include?(type)
+      end
+
+      # Is the declared type in fact an array of multiple allowed types?
+      # For example the declaration +types: [Integer,String]+ will attempt
+      # first to coerce given values to integer, but will also accept any
+      # other string.
+      #
+      # @param type [Array<Class>,Set<Class>] type (or type list!) to check
+      # @return [Boolean] +true+ if the given value will be treated as
+      #   a list of types.
+      def self.multiple?(type)
+        (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
+      end
+
+      # Does the given class implement a type system that Grape
+      # (i.e. the underlying virtus attribute system) supports
+      # out-of-the-box? Currently supported are +axiom-types+
+      # and +virtus+.
+      #
+      # The type will be passed to +Virtus::Attribute.build+,
+      # and the resulting attribute object will be expected to
+      # respond correctly to +coerce+ and +value_coerced?+.
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] +true+ where the type is recognized
+      def self.recognized?(type)
+        return false if type.is_a?(Array) || type.is_a?(Set)
+
+        type.is_a?(Virtus::Attribute) ||
+          type.ancestors.include?(Axiom::Types::Type) ||
+          type.include?(Virtus::Model::Core)
+      end
+
+      # Does Grape provide special coercion and validation
+      # routines for the given class? This does not include
+      # automatic handling for primitives, structures and
+      # otherwise recognized types. See {Types::SPECIAL}.
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] +true+ if special routines are available
+      def self.special?(type)
+        SPECIAL.key? 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
+      # @return [Boolean] whether or not the type can be used as a custom type
+      def self.custom?(type)
+        !primitive?(type) &&
+          !structure?(type) &&
+          !multiple?(type) &&
+          !recognized?(type) &&
+          !special?(type) &&
+          type.respond_to?(:parse) &&
+          type.method(:parse).arity == 1
+      end
+    end
+  end
+end