grape 0.19.2 → 1.0.0

data/lib/grape/dsl/inside_route.rb

@@ -46,7 +46,7 @@ module Grape
         end
 
         def declared_hash(passed_params, options, declared_params)
-          declared_params.each_with_object(Hashie::Mash.new) do |declared_param, memo|
+          declared_params.each_with_object(passed_params.class.new) do |declared_param, memo|
             # If it is not a Hash then it does not have children.
             # Find its value or set it to nil.
             if !declared_param.is_a?(Hash)
@@ -56,7 +56,7 @@ module Grape
               declared_param.each_pair do |declared_parent_param, declared_children_params|
                 next unless options[:include_missing] || passed_params.key?(declared_parent_param)
 
-                passed_children_params = passed_params[declared_parent_param] || Hashie::Mash.new
+                passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
                 memo[optioned_param_key(declared_parent_param, options)] = declared(passed_children_params, options, declared_children_params)
               end
             end

data/lib/grape/dsl/parameters.rb

@@ -8,6 +8,32 @@ module Grape
     module Parameters
       extend ActiveSupport::Concern
 
+      # Set the module used to build the request.params.
+      #
+      # @param build_with the ParamBuilder module to use when building request.params
+      #   Available builders are:
+      #
+      #     * Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder (default)
+      #     * Grape::Extensions::Hash::ParamBuilder
+      #     * Grape::Extensions::Hashie::Mash::ParamBuilder
+      #
+      # @example
+      #
+      #     require 'grape/extenstions/hashie_mash'
+      #     class API < Grape::API
+      #       desc "Get collection"
+      #       params do
+      #         build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+      #         requires :user_id, type: Integer
+      #       end
+      #       get do
+      #         params['user_id']
+      #       end
+      #     end
+      def build_with(build_with = nil)
+        @api.namespace_inheritable(:build_params_with, build_with)
+      end
+
       # Include reusable params rules among current.
       # You can define reusable params with helpers method.
       #

data/lib/grape/dsl/routing.rb

@@ -7,7 +7,7 @@ module Grape
       include Grape::DSL::Configuration
 
       module ClassMethods
-        attr_reader :endpoints, :routes
+        attr_reader :endpoints
 
         # Specify an API version.
         #

data/lib/grape/dsl/settings.rb

@@ -9,7 +9,7 @@ module Grape
     module Settings
       extend ActiveSupport::Concern
 
-      attr_accessor :inheritable_setting, :top_level_setting
+      attr_writer :inheritable_setting, :top_level_setting
 
       # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting

data/lib/grape/endpoint.rb

@@ -1,5 +1,3 @@
-require 'grape/middleware/stack'
-
 module Grape
   # An Endpoint is the proxy scope in which all routing
   # blocks are executed. In other words, any methods
@@ -98,6 +96,11 @@ module Grape
       @lazy_initialized = nil
       @block = nil
 
+      @status = nil
+      @file = nil
+      @body = nil
+      @proc = nil
+
       return unless block_given?
 
       @source = block
@@ -239,15 +242,12 @@ module Grape
     def run
       ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
         @header = {}
-
-        @request = Grape::Request.new(env)
+        @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
         @params = @request.params
         @headers = @request.headers
 
         cookies.read(@request)
-
         self.class.run_before_each(self)
-
         run_filters befores, :before
 
         if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
@@ -338,18 +338,22 @@ module Grape
       end
     end
 
-    def run_validators(validators, request)
+    def run_validators(validator_factories, request)
       validation_errors = []
 
-      validators.each do |validator|
-        begin
-          validator.validate(request)
-        rescue Grape::Exceptions::Validation => e
-          validation_errors << e
-          break if validator.fail_fast?
-        rescue Grape::Exceptions::ValidationArrayErrors => e
-          validation_errors += e.errors
-          break if validator.fail_fast?
+      validators = validator_factories.map(&:create_validator)
+
+      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
+        validators.each do |validator|
+          begin
+            validator.validate(request)
+          rescue Grape::Exceptions::Validation => e
+            validation_errors << e
+            break if validator.fail_fast?
+          rescue Grape::Exceptions::ValidationArrayErrors => e
+            validation_errors += e.errors
+            break if validator.fail_fast?
+          end
         end
       end
 

data/lib/grape/error_formatter/json.rb

@@ -10,7 +10,7 @@ module Grape
           if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
             result = result.merge(backtrace: backtrace)
           end
-          MultiJson.dump(result)
+          ::Grape::Json.dump(result)
         end
 
         private

data/lib/grape/error_formatter/txt.rb

@@ -7,7 +7,7 @@ module Grape
         def call(message, backtrace, options = {}, env = nil)
           message = present(message, env)
 
-          result = message.is_a?(Hash) ? MultiJson.dump(message) : message
+          result = message.is_a?(Hash) ? ::Grape::Json.dump(message) : message
           if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
             result += "\r\n "
             result += backtrace.join("\r\n ")

data/lib/grape/extensions/active_support/hash_with_indifferent_access.rb

@@ -0,0 +1,26 @@
+module Grape
+  module Extensions
+    module ActiveSupport
+      module HashWithIndifferentAccess
+        module ParamBuilder
+          extend ::ActiveSupport::Concern
+
+          included do
+            namespace_inheritable(:build_params_with, Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder)
+          end
+
+          def params_builder
+            Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+          end
+
+          def build_params
+            params = ::ActiveSupport::HashWithIndifferentAccess[rack_params]
+            params.deep_merge!(grape_routing_args) if env[Grape::Env::GRAPE_ROUTING_ARGS]
+            # TODO: remove, in Rails 4 or later ::ActiveSupport::HashWithIndifferentAccess converts nested Hashes into indifferent access ones
+            DeepHashWithIndifferentAccess.deep_hash_with_indifferent_access(params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/extensions/deep_hash_with_indifferent_access.rb

@@ -0,0 +1,18 @@
+module Grape
+  module Extensions
+    module DeepHashWithIndifferentAccess
+      def self.deep_hash_with_indifferent_access(object)
+        case object
+        when ::Hash
+          object.inject(::ActiveSupport::HashWithIndifferentAccess.new) do |new_hash, (key, value)|
+            new_hash.merge!(key => deep_hash_with_indifferent_access(value))
+          end
+        when ::Array
+          object.map { |element| deep_hash_with_indifferent_access(element) }
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/grape/extensions/deep_mergeable_hash.rb

@@ -0,0 +1,19 @@
+module Grape
+  module Extensions
+    class DeepMergeableHash < ::Hash
+      def deep_merge!(other_hash)
+        other_hash.each_pair do |current_key, other_value|
+          this_value = self[current_key]
+
+          self[current_key] = if this_value.is_a?(::Hash) && other_value.is_a?(::Hash)
+                                this_value.deep_merge(other_value)
+                              else
+                                other_value
+                              end
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/grape/extensions/deep_symbolize_hash.rb

@@ -0,0 +1,30 @@
+module Grape
+  module Extensions
+    module DeepSymbolizeHash
+      def self.deep_symbolize_keys_in(object)
+        case object
+        when ::Hash
+          object.each_with_object({}) do |(key, value), new_hash|
+            new_hash[symbolize_key(key)] = deep_symbolize_keys_in(value)
+          end
+        when ::Array
+          object.map { |element| deep_symbolize_keys_in(element) }
+        else
+          object
+        end
+      end
+
+      def self.symbolize_key(key)
+        if key.is_a?(Symbol)
+          key
+        elsif key.is_a?(String)
+          key.to_sym
+        elsif key.respond_to?(:to_sym)
+          key.to_sym
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/grape/extensions/hash.rb

@@ -0,0 +1,23 @@
+module Grape
+  module Extensions
+    module Hash
+      module ParamBuilder
+        extend ::ActiveSupport::Concern
+
+        included do
+          namespace_inheritable(:build_params_with, Grape::Extensions::Hash::ParamBuilder)
+        end
+
+        def build_params
+          params = Grape::Extensions::DeepMergeableHash[rack_params]
+          params.deep_merge!(grape_routing_args) if env[Grape::Env::GRAPE_ROUTING_ARGS]
+          post_process_params(params)
+        end
+
+        def post_process_params(params)
+          Grape::Extensions::DeepSymbolizeHash.deep_symbolize_keys_in(params)
+        end
+      end
+    end
+  end
+end

data/lib/grape/extensions/hashie/mash.rb

@@ -0,0 +1,24 @@
+module Grape
+  module Extensions
+    module Hashie
+      module Mash
+        module ParamBuilder
+          extend ::ActiveSupport::Concern
+          included do
+            namespace_inheritable(:build_params_with, Grape::Extensions::Hashie::Mash::ParamBuilder)
+          end
+
+          def params_builder
+            Grape::Extensions::Hashie::Mash::ParamBuilder
+          end
+
+          def build_params
+            params = ::Hashie::Mash.new(rack_params)
+            params.deep_merge!(grape_routing_args) if env[Grape::Env::GRAPE_ROUTING_ARGS]
+            params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/formatter/json.rb

@@ -4,7 +4,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_json if object.respond_to?(:to_json)
-          MultiJson.dump(object)
+          ::Grape::Json.dump(object)
         end
       end
     end

data/lib/grape/formatter/serializable_hash.rb

@@ -4,9 +4,9 @@ module Grape
       class << self
         def call(object, _env)
           return object if object.is_a?(String)
-          return MultiJson.dump(serialize(object)) if serializable?(object)
+          return ::Grape::Json.dump(serialize(object)) if serializable?(object)
           return object.to_json if object.respond_to?(:to_json)
-          MultiJson.dump(object)
+          ::Grape::Json.dump(object)
         end
 
         private

data/lib/grape/locale/en.yml

@@ -8,7 +8,7 @@ en:
         regexp: 'is invalid'
         blank: 'is empty'
         values: 'does not have a valid value'
-        except: 'has a value not allowed'
+        except_values: 'has a value not allowed'
         missing_vendor_option:
           problem: 'missing :vendor option.'
           summary: 'when version using header, you must specify :vendor option. '

data/lib/grape/middleware/globals.rb

@@ -4,7 +4,7 @@ module Grape
   module Middleware
     class Globals < Base
       def before
-        request = Grape::Request.new(@env)
+        request = Grape::Request.new(@env, build_params_with: @options[:build_params_with])
         @env[Grape::Env::GRAPE_REQUEST] = request
         @env[Grape::Env::GRAPE_REQUEST_HEADERS] = request.headers
         @env[Grape::Env::GRAPE_REQUEST_PARAMS] = request.params if @env[Grape::Env::RACK_INPUT]

data/lib/grape/parser/json.rb

@@ -3,8 +3,8 @@ module Grape
     module Json
       class << self
         def call(object, _env)
-          MultiJson.load(object)
-        rescue MultiJson::ParseError
+          ::Grape::Json.load(object)
+        rescue ::Grape::Json::ParseError
           # handle JSON parsing errors via the rescue handlers or provide error message
           raise Grape::Exceptions::InvalidMessageBody, 'application/json'
         end

data/lib/grape/parser/xml.rb

@@ -3,8 +3,8 @@ module Grape
     module Xml
       class << self
         def call(object, _env)
-          MultiXml.parse(object)
-        rescue MultiXml::ParseError
+          ::Grape::Xml.parse(object)
+        rescue ::Grape::Xml::ParseError
           # handle XML parsing errors via the rescue handlers or provide error message
           raise Grape::Exceptions::InvalidMessageBody, 'application/xml'
         end

data/lib/grape/request.rb

@@ -4,6 +4,11 @@ module Grape
 
     alias rack_params params
 
+    def initialize(env, options = {})
+      extend options[:build_params_with] || Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+      super(env)
+    end
+
     def params
       @params ||= build_params
     end
@@ -14,16 +19,12 @@ module Grape
 
     private
 
-    def build_params
-      params = Hashie::Mash.new(rack_params)
-      if env[Grape::Env::GRAPE_ROUTING_ARGS]
-        args = env[Grape::Env::GRAPE_ROUTING_ARGS].dup
-        # preserve version from query string parameters
-        args.delete(:version)
-        args.delete(:route_info)
-        params.deep_merge!(args)
-      end
-      params
+    def grape_routing_args
+      args = env[Grape::Env::GRAPE_ROUTING_ARGS].dup
+      # preserve version from query string parameters
+      args.delete(:version)
+      args.delete(:route_info)
+      args
     end
 
     def build_headers

data/lib/grape/util/json.rb

@@ -0,0 +1,8 @@
+module Grape
+  if Object.const_defined? :MultiJson
+    Json = ::MultiJson
+  else
+    Json = ::JSON
+    Json::ParseError = Json::ParserError
+  end
+end

data/lib/grape/util/xml.rb

@@ -0,0 +1,8 @@
+module Grape
+  if Object.const_defined? :MultiXml
+    Xml = ::MultiXml
+  else
+    Xml = ::ActiveSupport::XmlMini
+    Xml::ParseError = StandardError
+  end
+end

data/lib/grape/validations.rb

@@ -14,5 +14,9 @@ module Grape
     def self.register_validator(short_name, klass)
       validators[short_name] = klass
     end
+
+    def self.deregister_validator(short_name)
+      validators.delete(short_name)
+    end
   end
 end

data/lib/grape/validations/params_scope.rb

@@ -42,37 +42,45 @@ module Grape
         return false if @optional && (params(parameters).blank? ||
                                        any_element_blank?(parameters))
 
+        return true if parent.nil?
+        parent.should_validate?(parameters)
+      end
+
+      def meets_dependency?(params)
+        return true unless @dependent_on
+
+        params = params.with_indifferent_access
+
         @dependent_on.each do |dependency|
           if dependency.is_a?(Hash)
             dependency_key = dependency.keys[0]
             proc = dependency.values[0]
-            return false unless proc.call(params(parameters).try(:[], dependency_key))
-          elsif params(parameters).try(:[], dependency).blank?
+            return false unless proc.call(params.try(:[], dependency_key))
+          elsif params.respond_to?(:key?) && params.try(:[], dependency).blank?
             return false
           end
-        end if @dependent_on
+        end
 
-        return true if parent.nil?
-        parent.should_validate?(parameters)
+        true
       end
 
       # @return [String] the proper attribute name, with nesting considered.
-      def full_name(name)
+      def full_name(name, index: nil)
         if nested?
           # Find our containing element's name, and append ours.
-          "#{@parent.full_name(@element)}#{array_index}[#{name}]"
+          [@parent.full_name(@element), [@index || index, name].map(&method(:brackets))].compact.join
         elsif lateral?
-          # Find the name of the element as if it was at the
-          # same nesting level as our parent.
-          @parent.full_name(name)
+          # Find the name of the element as if it was at the same nesting level
+          # as our parent. We need to forward our index upward to achieve this.
+          @parent.full_name(name, index: @index)
         else
           # We must be the root scope, so no prefix needed.
           name.to_s
         end
       end
 
-      def array_index
-        "[#{@index}]" if @index.present?
+      def brackets(val)
+        "[#{val}]" if val
       end
 
       # @return [Boolean] whether or not this scope is the root-level scope
@@ -187,7 +195,7 @@ module Grape
           element:      nil,
           parent:       self,
           options:      @optional,
-          type:         Hash,
+          type:         type == Array ? Array : Hash,
           dependent_on: options[:dependent_on],
           &block
         )
@@ -232,16 +240,28 @@ module Grape
         default = validations[:default]
         doc_attrs[:default] = default if validations.key?(:default)
 
-        values = options_key?(:values, :value, validations) ? validations[:values][:value] : validations[:values]
+        if (values_hash = validations[:values]).is_a? Hash
+          values = values_hash[:value]
+          # NB: excepts is deprecated
+          excepts = values_hash[:except]
+        else
+          values = validations[:values]
+        end
         doc_attrs[:values] = values if values
 
-        coerce_type = guess_coerce_type(coerce_type, values)
+        except_values = options_key?(:except_values, :value, validations) ? validations[:except_values][:value] : validations[:except_values]
+
+        # NB. values and excepts should be nil, Proc, Array, or Range.
+        # Specifically, values should NOT be a Hash
+
+        # use values or excepts to guess coerce type when stated type is Array
+        coerce_type = guess_coerce_type(coerce_type, values, except_values, excepts)
 
         # default value should be present in values array, if both exist and are not procs
-        check_incompatible_option_values(values, default)
+        check_incompatible_option_values(default, values, except_values, excepts)
 
         # type should be compatible with values array, if both exist
-        validate_value_coercion(coerce_type, values)
+        validate_value_coercion(coerce_type, values, except_values, excepts)
 
         doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
 
@@ -346,17 +366,31 @@ module Grape
         validations.delete(:coerce_message)
       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?)
+      def guess_coerce_type(coerce_type, *values_list)
+        return coerce_type unless coerce_type == Array
+        values_list.each do |values|
+          next if !values || values.is_a?(Proc)
+          return values.first.class if values.is_a?(Range) || !values.empty?
+        end
         coerce_type
       end
 
-      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) || (Array(default) - Array(values)).empty?
-        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
+      def check_incompatible_option_values(default, values, except_values, excepts)
+        return unless default && !default.is_a?(Proc)
+
+        if values && !values.is_a?(Proc)
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) \
+            unless Array(default).all? { |def_val| values.include?(def_val) }
+        end
+
+        if except_values && !except_values.is_a?(Proc)
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values) \
+            unless Array(default).none? { |def_val| except_values.include?(def_val) }
+        end
+
+        return unless excepts && !excepts.is_a?(Proc)
+        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, excepts) \
+          unless Array(default).none? { |def_val| excepts.include?(def_val) }
       end
 
       def validate(type, options, attrs, doc_attrs, opts)
@@ -364,24 +398,28 @@ module Grape
 
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
-        value = validator_class.new(attrs, options, doc_attrs[:required], self, opts)
-        @api.namespace_stackable(:validations, value)
+        factory = Grape::Validations::ValidatorFactory.new(attributes:      attrs,
+                                                           options:         options,
+                                                           required:        doc_attrs[:required],
+                                                           params_scope:    self,
+                                                           opts:            opts,
+                                                           validator_class: validator_class)
+        @api.namespace_stackable(:validations, factory)
       end
 
-      def validate_value_coercion(coerce_type, values)
-        return unless coerce_type && values
-        return if values.is_a?(Proc)
-        if values.is_a?(Hash)
-          return if values[:value] && values[:value].is_a?(Proc)
-          return if values[:except] && values[:except].is_a?(Proc)
-        end
+      def validate_value_coercion(coerce_type, *values_list)
+        return unless coerce_type
         coerce_type = coerce_type.first if coerce_type.is_a?(Array)
-        value_types = values.is_a?(Range) ? [values.begin, values.end] : values
-        if coerce_type == Virtus::Attribute::Boolean
-          value_types = value_types.map { |type| Virtus::Attribute.build(type) }
+        values_list.each do |values|
+          next if !values || values.is_a?(Proc)
+          value_types = values.is_a?(Range) ? [values.begin, values.end] : values
+          if coerce_type == Virtus::Attribute::Boolean
+            value_types = value_types.map { |type| Virtus::Attribute.build(type) }
+          end
+          unless value_types.all? { |v| v.is_a? coerce_type }
+            raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
+          end
         end
-        return unless value_types.any? { |v| !v.is_a?(coerce_type) }
-        raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
       end
 
       def extract_message_option(attrs)