grape 1.6.0 → 1.6.2

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

@@ -2,47 +2,49 @@
 
 module Grape
   module Validations
-    class DefaultValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        @default = options
-        super
-      end
+    module Validators
+      class DefaultValidator < Base
+        def initialize(attrs, options, required, scope, **opts)
+          @default = options
+          super
+        end
 
-      def validate_param!(attr_name, params)
-        params[attr_name] = if @default.is_a? Proc
-                              @default.call
-                            elsif @default.frozen? || !duplicatable?(@default)
-                              @default
-                            else
-                              duplicate(@default)
-                            end
-      end
+        def validate_param!(attr_name, params)
+          params[attr_name] = if @default.is_a? Proc
+                                @default.call
+                              elsif @default.frozen? || !duplicatable?(@default)
+                                @default
+                              else
+                                duplicate(@default)
+                              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)
+        def validate!(params)
+          attrs = SingleAttributeIterator.new(self, @scope, params)
+          attrs.each 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?
+            validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
+          end
         end
-      end
 
-      private
+        private
 
-      # return true if we might be able to dup this object
-      def duplicatable?(obj)
-        !obj.nil? &&
-          obj != true &&
-          obj != false &&
-          !obj.is_a?(Symbol) &&
-          !obj.is_a?(Numeric)
-      end
+        # return true if we might be able to dup this object
+        def duplicatable?(obj)
+          !obj.nil? &&
+            obj != true &&
+            obj != false &&
+            !obj.is_a?(Symbol) &&
+            !obj.is_a?(Numeric)
+        end
 
-      # make a best effort to dup the object
-      def duplicate(obj)
-        obj.dup
-      rescue TypeError
-        obj
+        # make a best effort to dup the object
+        def duplicate(obj)
+          obj.dup
+        rescue TypeError
+          obj
+        end
       end
     end
   end

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

@@ -4,13 +4,15 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    class ExactlyOneOfValidator < MultipleParamsBase
-      def validate_params!(params)
-        keys = keys_in_common(params)
-        return if keys.length == 1
-        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+    module Validators
+      class ExactlyOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          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))
+          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+        end
       end
     end
   end

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

@@ -2,20 +2,22 @@
 
 module Grape
   module Validations
-    class ExceptValuesValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        @except = options.is_a?(Hash) ? options[:value] : options
-        super
-      end
+    module Validators
+      class ExceptValuesValidator < Base
+        def initialize(attrs, options, required, scope, **opts)
+          @except = options.is_a?(Hash) ? options[:value] : options
+          super
+        end
 
-      def validate_param!(attr_name, params)
-        return unless params.respond_to?(:key?) && params.key?(attr_name)
+        def validate_param!(attr_name, params)
+          return unless params.respond_to?(:key?) && params.key?(attr_name)
 
-        excepts = @except.is_a?(Proc) ? @except.call : @except
-        return if excepts.nil?
+          excepts = @except.is_a?(Proc) ? @except.call : @except
+          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) }
+          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) }
+        end
       end
     end
   end

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

@@ -2,34 +2,36 @@
 
 module Grape
   module Validations
-    class MultipleParamsBase < Base
-      def validate!(params)
-        attributes = MultipleAttributesIterator.new(self, @scope, params)
-        array_errors = []
-
-        attributes.each do |resource_params, skip_value|
-          next if skip_value
-
-          begin
-            validate_params!(resource_params)
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
+    module Validators
+      class MultipleParamsBase < Base
+        def validate!(params)
+          attributes = MultipleAttributesIterator.new(self, @scope, params)
+          array_errors = []
+
+          attributes.each do |resource_params, skip_value|
+            next if skip_value
+
+            begin
+              validate_params!(resource_params)
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
-        end
 
-        raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
-      end
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
+        end
 
-      private
+        private
 
-      def keys_in_common(resource_params)
-        return [] unless resource_params.is_a?(Hash)
+        def keys_in_common(resource_params)
+          return [] unless resource_params.is_a?(Hash)
 
-        all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
-      end
+          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+        end
 
-      def all_keys
-        attrs.map { |attr| @scope.full_name(attr) }
+        def all_keys
+          attrs.map { |attr| @scope.full_name(attr) }
+        end
       end
     end
   end

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

@@ -4,12 +4,14 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    class MutualExclusionValidator < MultipleParamsBase
-      def validate_params!(params)
-        keys = keys_in_common(params)
-        return if keys.length <= 1
+    module Validators
+      class MutualExclusionValidator < MultipleParamsBase
+        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))
+          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+        end
       end
     end
   end

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

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

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

@@ -2,12 +2,14 @@
 
 module Grape
   module Validations
-    class RegexpValidator < Base
-      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)) }
+    module Validators
+      class RegexpValidator < Base
+        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)) }
 
-        raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
+        end
       end
     end
   end

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

@@ -2,24 +2,26 @@
 
 module Grape
   module Validations
-    class SameAsValidator < Base
-      def validate_param!(attr_name, params)
-        confirmation = options_key?(:value) ? @option[:value] : @option
-        return if params[attr_name] == params[confirmation]
+    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
-        )
-      end
+          raise Grape::Exceptions::Validation.new(
+            params: [@scope.full_name(attr_name)],
+            message: build_message
+          )
+        end
 
-      private
+        private
 
-      def build_message
-        if options_key?(:message)
-          @option[:message]
-        else
-          format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
+        def build_message
+          if options_key?(:message)
+            @option[:message]
+          else
+            format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
+          end
         end
       end
     end

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

@@ -2,84 +2,86 @@
 
 module Grape
   module Validations
-    class ValuesValidator < Base
-      def initialize(attrs, options, required, scope, **opts)
-        if options.is_a?(Hash)
-          @excepts = options[:except]
-          @values = options[:value]
-          @proc = options[:proc]
-
-          warn '[DEPRECATION] 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)
-
-          warn '[DEPRECATION] The values validator proc option is deprecated. ' \
-               'The lambda expression can now be assigned directly to values.' if @proc
-        else
-          @excepts = nil
-          @values = nil
-          @proc = nil
-          @values = options
+    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]
+
+            warn '[DEPRECATION] 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)
+
+            warn '[DEPRECATION] The values validator proc option is deprecated. ' \
+                 'The lambda expression can now be assigned directly to values.' if @proc
+          else
+            @excepts = nil
+            @values = nil
+            @proc = nil
+            @values = options
+          end
+          super
         end
-        super
-      end
 
-      def validate_param!(attr_name, params)
-        return unless params.is_a?(Hash)
+        def validate_param!(attr_name, params)
+          return unless params.is_a?(Hash)
 
-        val = params[attr_name]
+          val = params[attr_name]
 
-        return if val.nil? && !required_for_root_scope?
+          return if val.nil? && !required_for_root_scope?
 
-        # don't forget that +false.blank?+ is true
-        return if val != false && val.blank? && @allow_blank
+          # don't forget that +false.blank?+ is true
+          return if val != false && val.blank? && @allow_blank
 
-        param_array = val.nil? ? [nil] : Array.wrap(val)
+          param_array = val.nil? ? [nil] : Array.wrap(val)
 
-        raise validation_exception(attr_name, except_message) \
+          raise validation_exception(attr_name, except_message) \
           unless check_excepts(param_array)
 
-        raise validation_exception(attr_name, message(:values)) \
+          raise validation_exception(attr_name, message(:values)) \
           unless check_values(param_array, attr_name)
 
-        raise validation_exception(attr_name, message(:values)) \
+          raise validation_exception(attr_name, message(:values)) \
           if @proc && !param_array.all? { |param| @proc.call(param) }
-      end
+        end
 
-      private
+        private
 
-      def check_values(param_array, attr_name)
-        values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
-        return true if values.nil?
+        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
+          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
-        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?
+        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
+          param_array.none? { |param| excepts.include?(param) }
+        end
 
-      def except_message
-        options = instance_variable_get(:@option)
-        options_key?(:except_message) ? options[:except_message] : message(:except_values)
-      end
+        def except_message
+          options = instance_variable_get(:@option)
+          options_key?(:except_message) ? options[:except_message] : message(:except_values)
+        end
 
-      def required_for_root_scope?
-        @required && @scope.root?
-      end
+        def required_for_root_scope?
+          @required && @scope.root?
+        end
 
-      def validation_exception(attr_name, message)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+        def validation_exception(attr_name, message)
+          Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+        end
       end
     end
   end

data/lib/grape/validations.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require 'grape/validations/attributes_iterator'
+require 'grape/validations/single_attribute_iterator'
+require 'grape/validations/multiple_attributes_iterator'
+require 'grape/validations/params_scope'
+require 'grape/validations/types'
+
 module Grape
   # Registry to store and locate known Validators.
   module Validations

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.6.0'
+  VERSION = '1.6.2'
 end

data/lib/grape.rb

@@ -7,7 +7,9 @@ require 'rack/accept'
 require 'rack/auth/basic'
 require 'rack/auth/digest/md5'
 require 'set'
+require 'active_support'
 require 'active_support/version'
+require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR > 6
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/array/extract_options'