grape 1.2.4 → 1.2.5

data/lib/grape/util/lazy_value.rb

@@ -7,6 +7,11 @@ module Grape
         @access_keys = access_keys
       end
 
+      def evaluate_from(configuration)
+        matching_lazy_value = configuration.fetch(@access_keys)
+        matching_lazy_value.evaluate
+      end
+
       def evaluate
         @value
       end

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,45 +1,16 @@
+require_relative 'stackable_values'
+
 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
+    class ReverseStackableValues < StackableValues
+      protected
 
-      def [](name)
+      def concat_values(inherited_value, new_value)
         [].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]
+          value.concat(new_value)
+          value.concat(inherited_value)
         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

@@ -1,23 +1,25 @@
+require_relative 'base_inheritable'
+
 module Grape
   module Util
-    class StackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+    class StackableValues < BaseInheritable
       attr_reader :frozen_values
 
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
+      def initialize(*_args)
+        super
+
         @frozen_values = {}
       end
 
       def [](name)
         return @frozen_values[name] if @frozen_values.key? name
 
-        value = []
-        value.concat(@inherited_values[name] || [])
-        value.concat(@new_values[name] || [])
-        value
+        inherited_value = @inherited_values[name]
+        new_value = @new_values[name] || []
+
+        return new_value unless inherited_value
+
+        concat_values(inherited_value, new_value)
       end
 
       def []=(name, value)
@@ -26,14 +28,6 @@ module Grape
         @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]
@@ -44,10 +38,13 @@ module Grape
         @frozen_values[key] = self[key].freeze
       end
 
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+      protected
+
+      def concat_values(inherited_value, new_value)
+        [].tap do |value|
+          value.concat(inherited_value)
+          value.concat(new_value)
+        end
       end
     end
   end

data/lib/grape/validations/attributes_iterator.rb

@@ -41,11 +41,13 @@ 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
     end
   end
 end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Validations
+    class MultipleAttributesIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, _attrs)
+        yield resource_params
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -76,7 +76,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.
@@ -184,14 +184,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
@@ -412,13 +410,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)

data/lib/grape/validations/single_attribute_iterator.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Validations
+    class SingleAttributeIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, attrs)
+        attrs.each do |attr_name|
+          yield resource_params, attr_name
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validator_factory.rb

@@ -1,17 +1,12 @@
 module Grape
   module Validations
     class ValidatorFactory
-      def initialize(**options)
-        @validator_class = options.delete(:validator_class)
-        @options         = options
-      end
-
-      def create_validator
-        @validator_class.new(@options[:attributes],
-                             @options[:options],
-                             @options[:required],
-                             @options[:params_scope],
-                             @options[:opts])
+      def self.create_validator(**options)
+        options[:validator_class].new(options[:attributes],
+                                      options[:options],
+                                      options[:required],
+                                      options[:params_scope],
+                                      options[:opts])
       end
     end
   end

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

@@ -1,19 +1,12 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AllOrNoneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && only_subset_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
-        end
-        params
-      end
-
-      private
-
-      def only_subset_present
-        scoped_params.any? { |resource_params| !keys_in_common(resource_params).empty? && keys_in_common(resource_params).length < attrs.length }
+      def validate_params!(params)
+        keys = keys_in_common(params)
+        return if keys.empty? || keys.length == all_keys.length
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:all_or_none)
       end
     end
   end

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

@@ -1,19 +1,11 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class AtLeastOneOfValidator < MultipleParamsBase
-      def validate!(params)
-        super
-        if scope_requires_params && no_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
-        end
-        params
-      end
-
-      private
-
-      def no_exclusive_params_are_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+      def validate_params!(params)
+        return unless keys_in_common(params).empty?
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
       end
     end
   end

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

@@ -35,18 +35,19 @@ module Grape
       # @raise [Grape::Exceptions::Validation] if validation failed
       # @return [void]
       def validate!(params)
-        attributes = AttributesIterator.new(self, @scope, params)
+        attributes = SingleAttributeIterator.new(self, @scope, params)
+        # we collect errors inside array because
+        # there may be more than one error per field
         array_errors = []
+
         attributes.each do |resource_params, attr_name|
           next if !@scope.required? && resource_params.empty?
-          next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
           next unless @scope.meets_dependency?(resource_params, params)
-
           begin
-            validate_param!(attr_name, resource_params)
+            if @required || resource_params.respond_to?(:key?) && resource_params.key?(attr_name)
+              validate_param!(attr_name, resource_params)
+            end
           rescue Grape::Exceptions::Validation => e
-            # we collect errors inside array because
-            # there may be more than one error per field
             array_errors << e
           end
         end
@@ -56,10 +57,10 @@ module Grape
 
       def self.convert_to_short_name(klass)
         ret = klass.name.gsub(/::/, '/')
-                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                   .tr('-', '_')
-                   .downcase
+        ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        ret.tr!('-', '_')
+        ret.downcase!
         File.basename(ret, '_validator')
       end
 

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

@@ -1,6 +1,10 @@
 module Grape
   class API
     Boolean = Virtus::Attribute::Boolean
+
+    class Instance
+      Boolean = Virtus::Attribute::Boolean
+    end
   end
 
   module Validations

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

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

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

@@ -1,28 +1,11 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/mutual_exclusion'
-    class ExactlyOneOfValidator < MutualExclusionValidator
-      def validate!(params)
-        super
-        if scope_requires_params && none_of_restricted_params_is_present
-          raise 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
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).empty? }
+    class ExactlyOneOfValidator < MultipleParamsBase
+      def validate_params!(params)
+        return if keys_in_common(params).length == 1
+        raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
       end
     end
   end

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

@@ -1,26 +1,30 @@
 module Grape
   module Validations
     class MultipleParamsBase < Base
-      attr_reader :scoped_params
-
       def validate!(params)
-        @scoped_params = [@scope.params(params)].flatten
-        params
-      end
+        attributes = MultipleAttributesIterator.new(self, @scope, params)
+        array_errors = []
 
-      private
+        attributes.each do |resource_params|
+          begin
+            validate_params!(resource_params)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
+          end
+        end
 
-      def scope_requires_params
-        @scope.required? || scoped_params.any? { |param| param.respond_to?(:any?) && param.any? }
+        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
       end
 
+      private
+
       def keys_in_common(resource_params)
         return [] unless resource_params.is_a?(Hash)
-        (all_keys & resource_params.stringify_keys.keys).map(&:to_s)
+        all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
       end
 
       def all_keys
-        attrs.map(&:to_s)
+        attrs.map { |attr| @scope.full_name(attr) }
       end
     end
   end

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

@@ -1,24 +1,12 @@
+require 'grape/validations/validators/multiple_params_base'
+
 module Grape
   module Validations
-    require 'grape/validations/validators/multiple_params_base'
     class MutualExclusionValidator < MultipleParamsBase
-      attr_reader :processing_keys_in_common
-
-      def validate!(params)
-        super
-        if two_or_more_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
-        end
-        params
-      end
-
-      private
-
-      def two_or_more_exclusive_params_are_present
-        scoped_params.any? do |resource_params|
-          @processing_keys_in_common = keys_in_common(resource_params)
-          @processing_keys_in_common.length > 1
-        end
+      def validate_params!(params)
+        keys = keys_in_common(params)
+        return if keys.length <= 1
+        raise Grape::Exceptions::Validation, params: keys, message: message(:mutual_exclusion)
       end
     end
   end