grape 1.8.0 → 4.0.1

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ContractScopeValidator
+        extend Grape::Util::FreezeOnNew
+
+        attr_reader :schema
+
+        def initialize(schema:)
+          @schema = schema
+        end
+
+        # Validates a given request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
+        # @return [void]
+        def validate(request)
+          res = schema.call(request.params)
+
+          if res.success?
+            request.params.deep_merge!(res.to_h)
+            return
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(build_errors_from_messages(res.errors.messages))
+        end
+
+        def fail_fast?
+          false
+        end
+
+        private
+
+        def build_errors_from_messages(messages)
+          messages.map do |message|
+            full_name = message.path.first.to_s
+            full_name << "[#{message.path[1..].join('][')}]" if message.path.size > 1
+            Grape::Exceptions::Validation.new(params: full_name, message: message.text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,27 +4,24 @@ module Grape
   module Validations
     module Validators
       class DefaultValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
-          @default = options
+        def initialize(attrs, options, required, scope, opts)
           super
-        end
-
-        def validate_param!(attr_name, params)
-          params[attr_name] = if @default.is_a? Proc
-                                @default.call
-                              elsif @default.frozen? || !@default.duplicable?
-                                @default
-                              else
-                                @default.dup
-                              end
+          # !important, lazy call at runtime
+          @default_call =
+            if options.is_a?(Proc)
+              options.arity.zero? ? proc { options.call } : options
+            elsif options.duplicable?
+              proc { options.dup }
+            else
+              proc { options }
+            end
         end
 
         def validate!(params)
-          attrs = SingleAttributeIterator.new(self, @scope, params)
-          attrs.each do |resource_params, attr_name|
-            next unless @scope.meets_dependency?(resource_params, params)
+          @iterator.each(params) do |resource_params, attr_name|
+            next unless scope.meets_dependency?(resource_params, params)
 
-            validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
+            resource_params[attr_name] = @default_call.call(resource_params) if hash_like?(resource_params) && resource_params[attr_name].nil?
           end
         end
       end

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

@@ -4,12 +4,19 @@ module Grape
   module Validations
     module Validators
       class ExactlyOneOfValidator < MultipleParamsBase
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @exactly_one_exception_message = message(:exactly_one)
+          @mutual_exclusion_exception_message = message(:mutual_exclusion)
+        end
+
         def validate_params!(params)
-          keys = keys_in_common(params)
+          known_keys = all_keys
+          keys = keys_in_common(params, known_keys)
           return if keys.length == 1
-          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
 
-          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+          validation_error!(known_keys, @exactly_one_exception_message) if keys.empty?
+          validation_error!(keys, @mutual_exclusion_exception_message)
         end
       end
     end

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

@@ -4,19 +4,29 @@ module Grape
   module Validations
     module Validators
       class ExceptValuesValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
-          @except = options.is_a?(Hash) ? options[:value] : options
+        default_message_key :except_values
+
+        def initialize(attrs, options, required, scope, opts)
           super
+          except = option_value
+          except_proc = except.is_a?(Proc)
+          raise ArgumentError, 'except_values Proc must have arity of zero (use values: with a one-arity predicate for per-element checks)' if except_proc && !except.arity.zero?
+
+          # Zero-arity procs (e.g. -> { User.pluck(:role) }) must be called per-request,
+          # not at definition time, so they are wrapped in a lambda to defer execution.
+          @excepts_call = except_proc ? except : -> { except }
         end
 
         def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key?) && params.key?(attr_name)
+          return unless hash_like?(params) && params.key?(attr_name)
 
-          excepts = @except.is_a?(Proc) ? @except.call : @except
+          excepts = @excepts_call.call
           return if excepts.nil?
 
           param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:except_values)) if param_array.any? { |param| excepts.include?(param) }
+          return if param_array.none? { |param| excepts.include?(param) }
+
+          validation_error!(attr_name)
         end
       end
     end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class LengthValidator < Base
+        def initialize(attrs, options, required, scope, opts)
+          super
+
+          @min, @max, @is = options.values_at(:min, :max, :is)
+          validate_boundary!(:min, @min)
+          validate_boundary!(:max, @max)
+          raise ArgumentError, "min `#{@min}` cannot be greater than max `#{@max}`" if @min && @max && @min > @max
+
+          return if @is.nil?
+          raise ArgumentError, 'is must be an integer greater than zero' unless @is.is_a?(Integer) && @is.positive?
+          raise ArgumentError, 'is cannot be combined with min or max' unless @min.nil? && @max.nil?
+        end
+
+        def validate_param!(attr_name, params)
+          return unless hash_like?(params)
+
+          param = params[attr_name]
+
+          return unless param.respond_to?(:length)
+
+          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max) || (!@is.nil? && param.length != @is)
+
+          validation_error!(attr_name, message do
+            if @min && @max
+              translate(:length, min: @min, max: @max)
+            elsif @min
+              translate(:length_min, min: @min)
+            elsif @max
+              translate(:length_max, max: @max)
+            else
+              translate(:length_is, is: @is)
+            end
+          end)
+        end
+
+        private
+
+        def validate_boundary!(name, val)
+          raise ArgumentError, "`#{name}` must be an integer greater than or equal to zero" if !val.nil? && (!val.is_a?(Integer) || val.negative?)
+        end
+      end
+    end
+  end
+end

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

@@ -5,28 +5,31 @@ module Grape
     module Validators
       class MultipleParamsBase < Base
         def validate!(params)
-          attributes = MultipleAttributesIterator.new(self, @scope, params)
-          array_errors = []
+          array_errors = nil
 
-          attributes.each do |resource_params|
+          @iterator.each(params) do |resource_params|
             validate_params!(resource_params)
           rescue Grape::Exceptions::Validation => e
-            array_errors << e
+            (array_errors ||= []) << e
           end
 
-          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors
         end
 
         private
 
-        def keys_in_common(resource_params)
-          return [] unless resource_params.is_a?(Hash)
+        def iterator_class
+          MultipleAttributesIterator
+        end
+
+        def keys_in_common(resource_params, known_keys = all_keys)
+          return [] unless hash_like?(resource_params)
 
-          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+          known_keys & resource_params.keys.map! { |attr| scope.full_name(attr) }
         end
 
         def all_keys
-          attrs.map { |attr| @scope.full_name(attr) }
+          attrs.map { |attr| scope.full_name(attr) }
         end
       end
     end

data/lib/grape/validations/validators/{mutual_exclusion_validator.rb → mutually_exclusive_validator.rb}

@@ -3,12 +3,14 @@
 module Grape
   module Validations
     module Validators
-      class MutualExclusionValidator < MultipleParamsBase
+      class MutuallyExclusiveValidator < MultipleParamsBase
+        default_message_key :mutual_exclusion
+
         def validate_params!(params)
           keys = keys_in_common(params)
           return if keys.length <= 1
 
-          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+          validation_error!(keys)
         end
       end
     end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      # Validates that a Hash parameter matches at least one of a set of
+      # variant schemas. Each variant is a list of pre-built validators
+      # captured by evaluating the variant's block in a {Grape::Validations::OneofCollector}-backed
+      # {ParamsScope}. At request time we try each variant in order against
+      # a deep-dup of the value; the first variant that produces no errors
+      # wins and its (possibly coerced) hash replaces the original.
+      class OneofValidator < Base
+        default_message_key :oneof
+
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @variants = Array(options)
+        end
+
+        def validate_param!(attr_name, params)
+          return unless hash_like?(params)
+
+          value = params[attr_name]
+          return if value.nil? && !required?
+
+          winning_candidate = nil
+          @variants.each do |variant_validators|
+            candidate = value.deep_dup
+            if variant_matches?(variant_validators, candidate)
+              winning_candidate = candidate
+              break
+            end
+          end
+
+          return params[attr_name] = winning_candidate if winning_candidate
+
+          validation_error!(attr_name)
+        end
+
+        private
+
+        def variant_matches?(variant_validators, candidate)
+          variant_validators.each { |v| v.validate!(candidate) }
+          true
+        rescue Grape::Exceptions::Validation, Grape::Exceptions::ValidationArrayErrors
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -4,10 +4,12 @@ module Grape
   module Validations
     module Validators
       class PresenceValidator < Base
+        default_message_key :presence
+
         def validate_param!(attr_name, params)
-          return if params.respond_to?(:key?) && params.key?(attr_name)
+          return if hash_like?(params) && params.key?(attr_name)
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
+          validation_error!(attr_name)
         end
       end
     end

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

@@ -4,11 +4,19 @@ module Grape
   module Validations
     module Validators
       class RegexpValidator < Base
+        default_message_key :regexp
+
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @value = option_value
+        end
+
         def validate_param!(attr_name, params)
-          return unless params.respond_to?(:key?) && params.key?(attr_name)
-          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
+          return unless hash_like?(params) && params.key?(attr_name)
+
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || scrub(param.to_s).match?(@value) }
 
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
+          validation_error!(attr_name)
         end
       end
     end

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

@@ -4,24 +4,16 @@ module Grape
   module Validations
     module Validators
       class SameAsValidator < Base
-        def validate_param!(attr_name, params)
-          confirmation = options_key?(:value) ? @option[:value] : @option
-          return if params[attr_name] == params[confirmation]
-
-          raise Grape::Exceptions::Validation.new(
-            params: [@scope.full_name(attr_name)],
-            message: build_message
-          )
+        def initialize(attrs, options, required, scope, opts)
+          super
+          @value = option_value
         end
 
-        private
+        def validate_param!(attr_name, params)
+          return unless hash_like?(params)
+          return if params[attr_name] == params[@value]
 
-        def build_message
-          if options_key?(:message)
-            @option[:message]
-          else
-            format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
-          end
+          validation_error!(attr_name, message { translate(:same_as, parameter: @value) })
         end
       end
     end

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

@@ -4,92 +4,63 @@ module Grape
   module Validations
     module Validators
       class ValuesValidator < Base
-        def initialize(attrs, options, required, scope, **opts)
-          if options.is_a?(Hash)
-            @excepts = options[:except]
-            @values = options[:value]
-            @proc = options[:proc]
+        default_message_key :values
 
-            ActiveSupport::Deprecation.warn('The values validator except option is deprecated. Use the except validator instead.') if @excepts
-
-            raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
-
-            ActiveSupport::Deprecation.warn('The values validator proc option is deprecated. The lambda expression can now be assigned directly to values.') if @proc
+        def initialize(attrs, options, required, scope, opts)
+          super
+          values = option_value
+
+          # Zero-arity procs return a collection per-request (e.g. DB-backed lists).
+          # Non-zero-arity procs are per-element predicates, called directly at validation time.
+          # Non-Proc values are wrapped in a zero-arity lambda for a uniform call interface.
+          if values.is_a?(Proc)
+            @values_call = values
+            @values_is_predicate = !values.arity.zero?
           else
-            @excepts = nil
-            @values = nil
-            @proc = nil
-            @values = options
+            @values_call = -> { values }
+            @values_is_predicate = false
           end
-          super
         end
 
         def validate_param!(attr_name, params)
-          return unless params.is_a?(Hash)
+          return unless hash_like?(params)
 
-          val = params[attr_name]
+          val = scrub(params[attr_name])
 
           return if val.nil? && !required_for_root_scope?
+          return if val != false && val.blank? && allow_blank?
+          return if check_values?(val, attr_name)
 
-          # don't forget that +false.blank?+ is true
-          return if val != false && val.blank? && @allow_blank
-
-          param_array = val.nil? ? [nil] : Array.wrap(val)
-
-          raise validation_exception(attr_name, except_message) \
-          unless check_excepts(param_array)
-
-          raise validation_exception(attr_name, message(:values)) \
-          unless check_values(param_array, attr_name)
-
-          raise validation_exception(attr_name, message(:values)) \
-            if @proc && !validate_proc(@proc, param_array)
+          validation_error!(attr_name)
         end
 
         private
 
-        def check_values(param_array, attr_name)
-          values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
-          return true if values.nil?
-
-          begin
-            return param_array.all? { |param| values.call(param) } if values.is_a? Proc
-          rescue StandardError => e
-            warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
-            return false
-          end
-          param_array.all? { |param| values.include?(param) }
-        end
-
-        def check_excepts(param_array)
-          excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
-          return true if excepts.nil?
-
-          param_array.none? { |param| excepts.include?(param) }
-        end
+        def check_values?(val, attr_name)
+          param_array = val.nil? ? [nil] : Array.wrap(val)
 
-        def validate_proc(proc, param_array)
-          case proc.arity
-          when 0
-            param_array.all? { |_param| proc.call }
-          when 1
-            param_array.all? { |param| proc.call(param) }
+          if @values_is_predicate
+            begin
+              param_array.all? { |param| @values_call.call(param) }
+            rescue StandardError => e
+              warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
+              false
+            end
           else
-            raise ArgumentError, 'proc arity must be 0 or 1'
-          end
-        end
+            values = @values_call.call
+            return true if values.nil?
 
-        def except_message
-          options = instance_variable_get(:@option)
-          options_key?(:except_message) ? options[:except_message] : message(:except_values)
+            param_array.all? { |param| values.include?(param) }
+          end
         end
 
         def required_for_root_scope?
-          @required && @scope.root?
-        end
+          return false unless required?
+
+          current_scope = scope
+          current_scope = current_scope.parent while current_scope.lateral?
 
-        def validation_exception(attr_name, message)
-          Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+          current_scope.root?
         end
       end
     end

data/lib/grape/validations.rb

@@ -1,34 +1,21 @@
 # frozen_string_literal: true
 
 module Grape
-  # Registry to store and locate known Validators.
   module Validations
+    extend Grape::Util::Registry
+
     module_function
 
-    def validators
-      @validators ||= {}
-    end
+    def require_validator(short_name)
+      raise Grape::Exceptions::UnknownValidator, short_name unless registry.key?(short_name)
 
-    # Register a new validator, so it can be used to validate parameters.
-    # @param short_name [String] all lower-case, no spaces
-    # @param klass [Class] the validator class. Should inherit from
-    #   Validations::Base.
-    def register_validator(short_name, klass)
-      validators[short_name] = klass
+      registry[short_name]
     end
 
-    def deregister_validator(short_name)
-      validators.delete(short_name)
-    end
+    def build_short_name(klass)
+      return if klass.name.blank?
 
-    # Find a validator and if not found will try to load it
-    def require_validator(short_name)
-      str_name = short_name.to_s
-      validators.fetch(str_name) do
-        Grape::Validations::Validators.const_get("#{str_name.camelize}Validator")
-      end
-    rescue NameError
-      raise Grape::Exceptions::UnknownValidator.new(short_name)
+      klass.name.demodulize.underscore.delete_suffix('_validator')
     end
   end
 end

data/lib/grape/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Grape
-  # The current version of Grape.
-  VERSION = '1.8.0'
+  VERSION = '4.0.1'
 end

data/lib/grape/xml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Grape
+  # Since multi_xml 0.9.0 the canonical constant is MultiXML; MultiXml is a
+  # deprecated alias (removed in v1.0) that warns on use. Prefer MultiXML so
+  # Grape::Xml.parse doesn't trip the deprecation, falling back to the legacy
+  # constant and then ActiveSupport::XmlMini.
+  # https://github.com/sferik/multi_xml/blob/v0.9.1/CHANGELOG.md
+  if defined?(::MultiXML)
+    Xml = ::MultiXML
+  elsif defined?(::MultiXml)
+    Xml = ::MultiXml
+  else
+    Xml = ::ActiveSupport::XmlMini
+    Xml::ParseError = StandardError
+  end
+end