grape 1.1.0 → 1.5.3

data/lib/grape/util/stackable_values.rb

@@ -1,37 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base_inheritable'
+
 module Grape
   module Util
-    class StackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
-      attr_reader :frozen_values
-
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
-        @frozen_values = {}
-      end
-
+    class StackableValues < BaseInheritable
+      # Even if there is no value, an empty array will be returned.
       def [](name)
-        return @frozen_values[name] if @frozen_values.key? name
-
-        value = []
-        value.concat(@inherited_values[name] || [])
-        value.concat(@new_values[name] || [])
-        value
-      end
+        inherited_value = inherited_values[name]
+        new_value = new_values[name]
 
-      def []=(name, value)
-        raise if @frozen_values.key? name
-        @new_values[name] ||= []
-        @new_values[name].push value
-      end
+        return new_value || [] unless inherited_value
 
-      def delete(key)
-        new_values.delete key
+        concat_values(inherited_value, new_value)
       end
 
-      def keys
-        (@new_values.keys + @inherited_values.keys).sort.uniq
+      def []=(name, value)
+        new_values[name] ||= []
+        new_values[name].push value
       end
 
       def to_hash
@@ -40,14 +26,15 @@ module Grape
         end
       end
 
-      def freeze_value(key)
-        @frozen_values[key] = self[key].freeze
-      end
+      protected
+
+      def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
 
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        [].tap do |value|
+          value.concat(inherited_value)
+          value.concat(new_value)
+        end
       end
     end
   end

data/lib/grape/util/strict_hash_configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     module StrictHashConfiguration

data/lib/grape/util/xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   if Object.const_defined? :MultiXml
     Xml = ::MultiXml

data/lib/grape/validations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   # Registry to store and locate known Validators.
   module Validations

data/lib/grape/validations/attributes_iterator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AttributesIterator
@@ -29,9 +31,7 @@ module Grape
 
           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|
@@ -41,11 +41,21 @@ module Grape
             @scope.index = index
           end
 
-          @attrs.each do |attr_name|
-            yield resource_params, attr_name, inside_array
-          end
+          yield_attributes(resource_params, @attrs, &block)
         end
       end
+
+      def yield_attributes(_resource_params, _attrs)
+        raise NotImplementedError
+      end
+
+      # This is a special case so that we can ignore tree's where option
+      # values are missing lower down. Unfortunately we can remove this
+      # are the parameter parsing stage as they are required to ensure
+      # the correct indexing is maintained
+      def skip?(val)
+        val == Grape::DSL::Parameters::EmptyOptionalValue
+      end
     end
   end
 end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class MultipleAttributesIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, _attrs)
+        yield resource_params, skip?(resource_params)
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class ParamsScope
@@ -36,23 +38,32 @@ module Grape
         configure_declared_params
       end
 
+      def configuration
+        @api.configuration.respond_to?(:evaluate) ? @api.configuration.evaluate : @api.configuration
+      end
+
       # @return [Boolean] whether or not this entire scope needs to be
       #   validated
       def should_validate?(parameters)
-        return false if @optional && (params(parameters).blank? || all_element_blank?(parameters))
-        return false unless meets_dependency?(params(parameters), parameters)
+        scoped_params = params(parameters)
+
+        return false if @optional && (scoped_params.blank? || all_element_blank?(scoped_params))
+        return false unless meets_dependency?(scoped_params, parameters)
         return true if parent.nil?
         parent.should_validate?(parameters)
       end
 
       def meets_dependency?(params, request_params)
+        return true unless @dependent_on
+
         if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
           return false
         end
 
-        return true unless @dependent_on
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
-        params = params.with_indifferent_access
+
+        # params might be anything what looks like a hash, so it must implement a `key?` method
+        return false unless params.respond_to?(:key?)
 
         @dependent_on.each do |dependency|
           if dependency.is_a?(Hash)
@@ -71,7 +82,7 @@ module Grape
       def full_name(name, index: nil)
         if nested?
           # Find our containing element's name, and append ours.
-          [@parent.full_name(@element), [@index || index, name].map(&method(:brackets))].compact.join
+          "#{@parent.full_name(@element)}#{brackets(@index || index)}#{brackets(name)}"
         elsif lateral?
           # 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.
@@ -116,11 +127,12 @@ module Grape
       # @param attrs [Array] (see Grape::DSL::Parameters#requires)
       def push_declared_params(attrs, **opts)
         if lateral?
-          @parent.push_declared_params(attrs, opts)
+          @parent.push_declared_params(attrs, **opts)
         else
           if opts && opts[:as]
-            @api.route_setting(:aliased_params, @api.route_setting(:aliased_params) || [])
-            @api.route_setting(:aliased_params) << { attrs.first => opts[:as] }
+            @api.route_setting(:renamed_params, @api.route_setting(:renamed_params) || [])
+            @api.route_setting(:renamed_params) << { attrs.first => opts[:as] }
+            attrs = [opts[:as]]
           end
 
           @declared_params.concat attrs
@@ -178,14 +190,12 @@ module Grape
           raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
 
-        opts = attrs[1] || { type: Array }
-
         self.class.new(
           api:      @api,
-          element:  attrs.first,
+          element:  attrs[1][:as] || attrs.first,
           parent:   self,
           optional: optional,
-          type:     opts[:type],
+          type:     type || Array,
           &block
         )
       end
@@ -229,14 +239,14 @@ module Grape
           @parent.push_declared_params [element => @declared_params]
         else
           @api.namespace_stackable(:declared_params, @declared_params)
-
-          @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params)
-          @api.route_setting(:declared_params, @api.namespace_stackable(:declared_params).flatten)
         end
+
+        # params were stored in settings, it can be cleaned from the params scope
+        @declared_params = nil
       end
 
       def validates(attrs, validations)
-        doc_attrs = { required: validations.keys.include?(:presence) }
+        doc_attrs = { required: validations.key?(:presence) }
 
         coerce_type = infer_coercion(validations)
 
@@ -276,9 +286,7 @@ module Grape
         full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
         @api.document_attribute(full_attrs, doc_attrs)
 
-        # slice out fail_fast attribute
-        opts = {}
-        opts[:fail_fast] = validations.delete(:fail_fast) || false
+        opts = derive_validator_options(validations)
 
         # Validate for presence before any other validators
         if validations.key?(:presence) && validations[:presence]
@@ -406,13 +414,15 @@ module Grape
 
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
-        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)
+        validator_options = {
+          attributes:      attrs,
+          options:         options,
+          required:        doc_attrs[:required],
+          params_scope:    self,
+          opts:            opts,
+          validator_class: validator_class
+        }
+        @api.namespace_stackable(:validations, validator_options)
       end
 
       def validate_value_coercion(coerce_type, *values_list)
@@ -421,8 +431,8 @@ module Grape
         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) }
+          if coerce_type == Grape::API::Boolean
+            value_types = value_types.map { |type| Grape::API::Boolean.build(type) }
           end
           unless value_types.all? { |v| v.is_a? coerce_type }
             raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
@@ -440,8 +450,19 @@ module Grape
         validations[type].respond_to?(:key?) && validations[type].key?(key) && !validations[type][key].nil?
       end
 
-      def all_element_blank?(parameters)
-        params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
+      def all_element_blank?(scoped_params)
+        scoped_params.respond_to?(:all?) && scoped_params.all?(&:blank?)
+      end
+
+      # Validators don't have access to each other and they don't need, however,
+      # some validators might influence others, so their options should be shared
+      def derive_validator_options(validations)
+        allow_blank = validations[:allow_blank]
+
+        {
+          allow_blank: allow_blank.is_a?(Hash) ? allow_blank[:value] : allow_blank,
+          fail_fast:   validations.delete(:fail_fast) || false
+        }
       end
     end
   end

data/lib/grape/validations/single_attribute_iterator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class SingleAttributeIterator < AttributesIterator
+      private
+
+      def yield_attributes(val, attrs)
+        attrs.each do |attr_name|
+          yield val, attr_name, empty?(val), skip?(val)
+        end
+      end
+
+      # Primitives like Integers and Booleans don't respond to +empty?+.
+      # It could be possible to use +blank?+ instead, but
+      #
+      #     false.blank?
+      #     => true
+      def empty?(val)
+        val.respond_to?(:empty?) ? val.empty? : val.nil?
+      end
+    end
+  end
+end

data/lib/grape/validations/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'types/build_coercer'
 require_relative 'types/custom_type_coercer'
 require_relative 'types/custom_type_collection_coercer'
@@ -5,10 +7,7 @@ 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'
+require_relative 'types/invalid_value'
 
 module Grape
   module Validations
@@ -23,12 +22,7 @@ module Grape
     # 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.
+      # Types representing a single value, which are coerced.
       PRIMITIVES = [
         # Numerical
         Integer,
@@ -42,10 +36,11 @@ module Grape
         Time,
 
         # Misc
-        Virtus::Attribute::Boolean,
+        Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile
+        TrueClass,
+        FalseClass
       ].freeze
 
       # Types representing data structures.
@@ -55,8 +50,7 @@ module Grape
         Set
       ].freeze
 
-      # Types for which Grape provides special coercion
-      # and type-checking logic.
+      # Special custom types provided by Grape.
       SPECIAL = {
         JSON => Json,
         Array[JSON] => JsonArray,
@@ -86,8 +80,6 @@ module 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
@@ -104,25 +96,6 @@ module Grape
         (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
@@ -152,8 +125,6 @@ module Grape
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !recognized?(type) &&
-          !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1
       end
@@ -166,7 +137,11 @@ module Grape
       def self.collection_of_custom?(type)
         (type.is_a?(Array) || type.is_a?(Set)) &&
           type.length == 1 &&
-          custom?(type.first)
+          (custom?(type.first) || special?(type.first))
+      end
+
+      def self.map_special(type)
+        SPECIAL.fetch(type, type)
       end
     end
   end