grape 0.16.2 → 0.17.0

data/lib/grape/router/route.rb

@@ -6,13 +6,13 @@ require 'pathname'
 module Grape
   class Router
     class Route
-      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
+      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/
       FIXED_NAMED_CAPTURES = %w(format version).freeze
 
       attr_accessor :pattern, :translator, :app, :index, :regexp, :options
 
-      alias_method :attributes, :translator
+      alias attributes translator
 
       extend Forwardable
       def_delegators :pattern, :path, :origin

data/lib/grape/util/content_types.rb

@@ -1,7 +1,7 @@
 module Grape
   module ContentTypes
     # Content types are listed in order of preference.
-    CONTENT_TYPES = {
+    CONTENT_TYPES = { # rubocop:disable Style/MutableConstant
       xml: 'application/xml',
       serializable_hash: 'application/json',
       json: 'application/json',

data/lib/grape/util/inheritable_setting.rb

@@ -3,7 +3,8 @@ module Grape
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable
+      attr_accessor :route, :api_class, :namespace
+      attr_accessor :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable
       attr_accessor :parent, :point_in_time_copies
 
       # Retrieve global settings.
@@ -28,6 +29,7 @@ module Grape
         # used with a mount, or should every API::Class be a separate namespace by default?
         self.namespace_inheritable = InheritableValues.new
         self.namespace_stackable = StackableValues.new
+        self.namespace_reverse_stackable = ReverseStackableValues.new
 
         self.point_in_time_copies = []
 
@@ -50,6 +52,7 @@ module Grape
 
         namespace_inheritable.inherited_values = parent.namespace_inheritable
         namespace_stackable.inherited_values = parent.namespace_stackable
+        namespace_reverse_stackable.inherited_values = parent.namespace_reverse_stackable
         self.route = parent.route.merge(route)
 
         point_in_time_copies.map { |cloned_one| cloned_one.inherit_from parent }
@@ -67,6 +70,7 @@ module Grape
           new_setting.namespace = namespace.clone
           new_setting.namespace_inheritable = namespace_inheritable.clone
           new_setting.namespace_stackable = namespace_stackable.clone
+          new_setting.namespace_reverse_stackable = namespace_reverse_stackable.clone
           new_setting.route = route.clone
           new_setting.api_class = api_class
 
@@ -87,7 +91,8 @@ module Grape
           route: route.clone,
           namespace: namespace.to_hash,
           namespace_inheritable: namespace_inheritable.to_hash,
-          namespace_stackable: namespace_stackable.to_hash
+          namespace_stackable: namespace_stackable.to_hash,
+          namespace_reverse_stackable: namespace_reverse_stackable.to_hash
         }
       end
     end

data/lib/grape/util/reverse_stackable_values.rb

@@ -0,0 +1,45 @@
+module Grape
+  module Util
+    class ReverseStackableValues
+      attr_accessor :inherited_values
+      attr_accessor :new_values
+
+      def initialize(inherited_values = {})
+        @inherited_values = inherited_values
+        @new_values = {}
+      end
+
+      def [](name)
+        [].tap do |value|
+          value.concat(@new_values[name] || [])
+          value.concat(@inherited_values[name] || [])
+        end
+      end
+
+      def []=(name, value)
+        @new_values[name] ||= []
+        @new_values[name].push value
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      def keys
+        (@new_values.keys + @inherited_values.keys).sort.uniq
+      end
+
+      def to_hash
+        keys.each_with_object({}) do |key, result|
+          result[key] = self[key]
+        end
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.dup
+      end
+    end
+  end
+end

data/lib/grape/util/stackable_values.rb

@@ -2,25 +2,26 @@ module Grape
   module Util
     class StackableValues
       attr_accessor :inherited_values
-      attr_reader :new_values
-      attr_reader :froozen_values
+      attr_accessor :new_values
+      attr_reader :frozen_values
 
       def initialize(inherited_values = {})
         @inherited_values = inherited_values
         @new_values = {}
-        @froozen_values = {}
+        @frozen_values = {}
       end
 
       def [](name)
-        return @froozen_values[name] if @froozen_values.key? name
-        value = [@inherited_values[name], @new_values[name]]
-        value.compact!
-        value.flatten!(1)
+        return @frozen_values[name] if @frozen_values.key? name
+
+        value = []
+        value.concat(@inherited_values[name]) if @inherited_values[name]
+        value.concat(@new_values[name]) if @new_values[name]
         value
       end
 
       def []=(name, value)
-        fail if @froozen_values.key? name
+        raise if @frozen_values.key? name
         @new_values[name] ||= []
         @new_values[name].push value
       end
@@ -29,8 +30,6 @@ module Grape
         new_values.delete key
       end
 
-      attr_writer :new_values
-
       def keys
         (@new_values.keys + @inherited_values.keys).sort.uniq
       end
@@ -42,7 +41,7 @@ module Grape
       end
 
       def freeze_value(key)
-        @froozen_values[key] = self[key].freeze
+        @frozen_values[key] = self[key].freeze
       end
 
       def initialize_copy(other)

data/lib/grape/validations/attributes_iterator.rb

@@ -8,16 +8,41 @@ module Grape
       def initialize(validator, scope, params)
         @scope = scope
         @attrs = validator.attrs
-        @params = Array.wrap(scope.params(params))
+        @original_params = scope.params(params)
+        @params = Array.wrap(@original_params)
       end
 
-      def each
-        @params.each do |resource_params|
-          @attrs.each_with_index do |attr_name, index|
-            if resource_params.is_a?(Hash) && resource_params[attr_name].is_a?(Array)
-              scope.index = index
+      def each(&block)
+        do_each(@params, &block) # because we need recursion for nested arrays
+      end
+
+      private
+
+      def do_each(params_to_process, parent_indicies = [], &block)
+        params_to_process.each_with_index do |resource_params, index|
+          # when we get arrays of arrays it means that target element located inside array
+          # we need this because we want to know parent arrays indicies
+          if resource_params.is_a?(Array)
+            do_each(resource_params, [index] + parent_indicies, &block)
+            next
+          end
+
+          if @scope.type == Array
+            next unless @original_params.is_a?(Array) # do not validate content of array if it isn't array
+            inside_array = true
+          end
+          if inside_array
+            # fill current and parent scopes with correct array indicies
+            parent_scope = @scope.parent
+            parent_indicies.each do |parent_index|
+              parent_scope.index = parent_index
+              parent_scope = parent_scope.parent
             end
-            yield resource_params, attr_name
+            @scope.index = index
+          end
+
+          @attrs.each do |attr_name|
+            yield resource_params, attr_name, inside_array
           end
         end
       end

data/lib/grape/validations/params_scope.rb

@@ -2,6 +2,7 @@ module Grape
   module Validations
     class ParamsScope
       attr_accessor :element, :parent, :index
+      attr_reader :type
 
       include Grape::DSL::Parameters
 
@@ -35,10 +36,19 @@ module Grape
       # @return [Boolean] whether or not this entire scope needs to be
       #   validated
       def should_validate?(parameters)
-        return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
+        return false if @optional && (params(parameters).blank? ||
+                                       any_element_blank?(parameters))
+
         @dependent_on.each do |dependency|
-          return false if params(parameters).try(:[], dependency).blank?
+          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
+          end
         end if @dependent_on
+
         return true if parent.nil?
         parent.should_validate?(parameters)
       end
@@ -48,7 +58,7 @@ module Grape
         case
         when nested?
           # Find our containing element's name, and append ours.
-          "#{@parent.full_name(@element)}#{parent_index}[#{name}]"
+          "#{@parent.full_name(@element)}#{array_index}[#{name}]"
         when lateral?
           # Find the name of the element as if it was at the
           # same nesting level as our parent.
@@ -59,8 +69,8 @@ module Grape
         end
       end
 
-      def parent_index
-        "[#{@parent.index}]" if @parent.present? && @parent.index.present?
+      def array_index
+        "[#{@index}]" if @index.present?
       end
 
       # @return [Boolean] whether or not this scope is the root-level scope
@@ -111,7 +121,7 @@ module Grape
         end
         required_fields.each do |field|
           field_opts = opts[:using][field]
-          fail ArgumentError, "required field not exist: #{field}" unless field_opts
+          raise ArgumentError, "required field not exist: #{field}" unless field_opts
           requires(field, field_opts)
         end
         optional_fields.each do |field|
@@ -146,8 +156,8 @@ module Grape
         # if required params are grouped and no type or unsupported type is provided, raise an error
         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 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
 
         opts = attrs[1] || { type: Array }
@@ -187,7 +197,7 @@ module Grape
           @api.namespace_stackable(:declared_params, @declared_params)
 
           @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params)
-          @api.route_setting(:declared_params).concat @declared_params
+          @api.route_setting(:declared_params, @api.namespace_stackable(:declared_params).flatten)
         end
       end
 
@@ -204,7 +214,7 @@ module Grape
         default = validations[:default]
         doc_attrs[:default] = default if validations.key?(:default)
 
-        values = (options_key?(:values, :value, validations)) ? validations[:values][:value] : 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)
@@ -252,7 +262,7 @@ module Grape
       # @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'
+          raise ArgumentError, ':type may not be supplied with :types'
         end
 
         validations[:coerce] = (options_key?(:type, :value, validations) ? validations[:type][:value] : validations[:type]) if validations.key?(:type)
@@ -284,12 +294,12 @@ module Grape
       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)
+        raise 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'
+        raise ArgumentError, 'coerce_with disallowed for type: JSON'
       end
 
       # Add type coercion validation to this scope,
@@ -324,18 +334,16 @@ module Grape
         return unless values && default
         return if values.is_a?(Proc) || default.is_a?(Proc)
         return if values.include?(default) || (Array(default) - Array(values)).empty?
-        fail Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
+        raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
       end
 
       def validate(type, options, attrs, doc_attrs)
         validator_class = Validations.validators[type.to_s]
 
-        if validator_class
-          value = validator_class.new(attrs, options, doc_attrs[:required], self)
-          @api.namespace_stackable(:validations, value)
-        else
-          fail Grape::Exceptions::UnknownValidator.new(type)
-        end
+        raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
+
+        value = validator_class.new(attrs, options, doc_attrs[:required], self)
+        @api.namespace_stackable(:validations, value)
       end
 
       def validate_value_coercion(coerce_type, values)
@@ -347,7 +355,7 @@ module Grape
           value_types = value_types.map { |type| Virtus::Attribute.build(type) }
         end
         return unless value_types.any? { |v| !v.is_a?(coerce_type) }
-        fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
+        raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
       end
 
       def extract_message_option(attrs)
@@ -359,6 +367,10 @@ module Grape
       def options_key?(type, key, validations)
         validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil?
       end
+
+      def any_element_blank?(parameters)
+        params(parameters).respond_to?(:any?) && params(parameters).any?(&:blank?)
+      end
     end
   end
 end

data/lib/grape/validations/types.rb

@@ -45,14 +45,14 @@ module Grape
         String,
         Symbol,
         Rack::Multipart::UploadedFile
-      ]
+      ].freeze
 
       # Types representing data structures.
       STRUCTURES = [
         Hash,
         Array,
         Set
-      ]
+      ].freeze
 
       # Types for which Grape provides special coercion
       # and type-checking logic.
@@ -61,14 +61,14 @@ module Grape
         Array[JSON] => JsonArray,
         ::File => File,
         Rack::Multipart::UploadedFile => File
-      }
+      }.freeze
 
       GROUPS = [
         Array,
         Hash,
         JSON,
         Array[JSON]
-      ]
+      ].freeze
 
       # Is the given class a primitive type as recognized by Grape?
       #

data/lib/grape/validations/types/build_coercer.rb

@@ -26,7 +26,15 @@ module Grape
         converter_options = {
           nullify_blank: true
         }
-        conversion_type = type
+        conversion_type = if method == JSON
+                            Object
+                            # because we want just parsed JSON content:
+                            # if type is Array and data is `"{}"`
+                            # result will be [] because Virtus converts hashes
+                            # to arrays
+                          else
+                            type
+                          end
 
         # Use a special coercer for multiply-typed parameters.
         if Types.multiple?(type)

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: message(:all_or_none)
+          raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
         end
         params
       end
@@ -13,7 +13,7 @@ module Grape
       private
 
       def only_subset_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).length > 0 && keys_in_common(resource_params).length < attrs.length }
+        scoped_params.any? { |resource_params| !keys_in_common(resource_params).empty? && keys_in_common(resource_params).length < attrs.length }
       end
     end
   end

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

@@ -9,21 +9,20 @@ module Grape
 
         key_exists = params.key?(attr_name)
 
-        if @scope.root?
-          # root scope. validate if it's a required param. if it's optional, validate only if key exists in hash
-          should_validate = @required || key_exists
-        else # nested scope
-          should_validate = # required param, and scope contains some values (if scoping element contains no values, treat as blank)
-            (@required && params.present?) ||
-            # optional param but key inside scoping element exists
-            (!@required && params.key?(attr_name))
-        end
+        should_validate = if @scope.root?
+                            # root scope. validate if it's a required param. if it's optional, validate only if key exists in hash
+                            @required || key_exists
+                          else # nested scope
+                            (@required && params.present?) ||
+                              # optional param but key inside scoping element exists
+                              (!@required && params.key?(attr_name))
+                          end
 
         return unless should_validate
 
-        return if value == false || value.present?
+        return if false == value || value.present?
 
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank)
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:blank)
       end
     end
   end