cmdx 1.20.0 → 2.0.0

data/lib/cmdx/validators/length.rb

@@ -1,80 +1,67 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Validators
-    # Validates the length of a value against various constraints.
-    #
-    # This validator supports multiple length validation strategies including exact length,
-    # minimum/maximum bounds, and range-based validation. It can be used to ensure
-    # values meet specific length requirements for strings, arrays, and other
-    # enumerable objects.
+  class Validators
+    # Validates the `#length` of `value` against one of: `:within` /
+    # `:not_within` / `:in` / `:not_in` (Range), `:min` + `:max`,
+    # `:gt` / `:lt` (strict comparison), or `:is` / `:is_not` (exact
+    # match). `:gte`, `:lte`, `:eq`, `:not_eq` are accepted as aliases
+    # of `:min`, `:max`, `:is`, `:is_not` respectively (with matching
+    # `_message` overrides). Values without `#length` fail with the
+    # `:nil_message` override or a default.
     module Length
 
       extend self
 
-      # Validates a value's length against specified constraints.
-      #
-      # @param value [String, Array, Hash, Object] The value to validate (must respond to #length)
-      # @param options [Hash] Validation options
-      # @option options [Range] :within Range that the length must fall within (inclusive)
-      # @option options [Range] :not_within Range that the length must not fall within
-      # @option options [Range] :in Alias for :within
-      # @option options [Range] :not_in Range that the length must not fall within
-      # @option options [Integer] :min Minimum allowed length
-      # @option options [Integer] :max Maximum allowed length
-      # @option options [Integer] :is Exact required length
-      # @option options [Integer] :is_not Length that is not allowed
-      # @option options [String] :message Custom error message for all validations
-      # @option options [String] :within_message Custom message for within/range validations
-      # @option options [String] :in_message Custom message for :in validation
-      # @option options [String] :not_within_message Custom message for not_within validation
-      # @option options [String] :not_in_message Custom message for not_in validation
-      # @option options [String] :min_message Custom message for minimum length validation
-      # @option options [String] :max_message Custom message for maximum length validation
-      # @option options [String] :is_message Custom message for exact length validation
-      # @option options [String] :is_not_message Custom message for is_not validation
-      #
-      # @return [nil] Returns nil if validation passes
-      #
-      # @raise [ValidationError] When validation fails
-      # @raise [ArgumentError] When unknown validation options are provided
-      #
-      # @example Exact length validation
-      #   Length.call("hello", is: 5)
-      #   # => nil (validation passes)
-      # @example Range-based validation
-      #   Length.call("test", within: 3..6)
-      #   # => nil (validation passes - length 4 is within range)
-      # @example Min/max validation
-      #   Length.call("username", min: 3, max: 20)
-      #   # => nil (validation passes - length 8 is between 3 and 20)
-      # @example Exclusion validation
-      #   Length.call("short", not_in: 1..3)
-      #   # => nil (validation passes - length 5 is not in excluded range)
-      #
-      # @rbs (untyped value, Hash[Symbol, untyped] options) -> nil
+      ALIASES = {
+        gte: :min,
+        lte: :max,
+        eq: :is,
+        not_eq: :is_not,
+        gte_message: :min_message,
+        lte_message: :max_message,
+        eq_message: :is_message,
+        not_eq_message: :is_not_message
+      }.freeze
+      private_constant :ALIASES
+
+      # @param value [#length, nil]
+      # @param options [Hash{Symbol => Object}] see module summary
+      # @option options [String] :message global failure-message override
+      # @option options [String] :nil_message override when `value` lacks `#length`
+      # @option options [String] :within_message, :in_message, :not_within_message,
+      #   :not_in_message, :min_message, :max_message, :gt_message, :lt_message,
+      #   :is_message, :is_not_message
+      # @return [Validators::Failure, nil]
+      # @raise [ArgumentError] when no recognized length option is given
       def call(value, options = EMPTY_HASH)
-        length = value&.length
+        return nil_failure(options) unless value.respond_to?(:length)
 
-        case options
+        length = value.length
+
+        case options = options.transform_keys(ALIASES)
         in within:
-          raise_within_validation_error!(within.begin, within.end, options) unless within&.cover?(length)
+          within_failure(within.begin, within.end, options) unless within.cover?(length)
         in not_within:
-          raise_not_within_validation_error!(not_within.begin, not_within.end, options) if not_within&.cover?(length)
+          not_within_failure(not_within.begin, not_within.end, options) if not_within.cover?(length)
         in in: xin
-          raise_within_validation_error!(xin.begin, xin.end, options) unless xin&.cover?(length)
+          within_failure(xin.begin, xin.end, options) unless xin.cover?(length)
         in not_in:
-          raise_not_within_validation_error!(not_in.begin, not_in.end, options) if not_in&.cover?(length)
+          not_within_failure(not_in.begin, not_in.end, options) if not_in.cover?(length)
         in min:, max:
-          raise_within_validation_error!(min, max, options) unless length&.between?(min, max)
+          within_failure(min, max, options) unless length.between?(min, max)
         in min:
-          raise_min_validation_error!(min, options) unless !length.nil? && (min <= length)
+          min_failure(min, options) unless min <= length
         in max:
-          raise_max_validation_error!(max, options) unless !length.nil? && (length <= max)
+          max_failure(max, options) unless length <= max
+        in gt:
+          gt_failure(gt, options) unless gt < length
+        in lt:
+          lt_failure(lt, options) unless length < lt
         in is:
-          raise_is_validation_error!(is, options) unless !length.nil? && (length == is)
+          is_failure(is, options) unless length == is
         in is_not:
-          raise_is_not_validation_error!(is_not, options) if !length.nil? && (length == is_not)
+          is_not_failure(is_not, options) if length == is_not
         else
           raise ArgumentError, "unknown length validator options given"
         end
@@ -82,102 +69,113 @@ module CMDx
 
       private
 
-      # Raises validation error for within/range validations.
-      #
-      # @param min [Integer] Minimum length value
-      # @param max [Integer] Maximum length value
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer min, Integer max, Hash[Symbol, untyped] options) -> void
-      def raise_within_validation_error!(min, max, options)
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :nil_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def nil_failure(options)
+        message = options[:nil_message] || options[:message]
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.nil_value"))
+      end
+
+      # @param min [Object]
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :within_message
+      # @option options [String] :in_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def within_failure(min, max, options)
         message = options[:within_message] || options[:in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.within", min:, max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.within", min:, max:))
       end
 
-      # Raises validation error for not_within validations.
-      #
-      # @param min [Integer] Minimum length value
-      # @param max [Integer] Maximum length value
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer min, Integer max, Hash[Symbol, untyped] options) -> void
-      def raise_not_within_validation_error!(min, max, options)
+      # @param min [Object]
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :not_within_message
+      # @option options [String] :not_in_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def not_within_failure(min, max, options)
         message = options[:not_within_message] || options[:not_in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.not_within", min:, max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.not_within", min:, max:))
       end
 
-      # Raises validation error for minimum length validation.
-      #
-      # @param min [Integer] Minimum required length
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer min, Hash[Symbol, untyped] options) -> void
-      def raise_min_validation_error!(min, options)
+      # @param min [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :min_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def min_failure(min, options)
         message = options[:min_message] || options[:message]
         message %= { min: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.min", min:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.min", min:))
       end
 
-      # Raises validation error for maximum length validation.
-      #
-      # @param max [Integer] Maximum allowed length
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer max, Hash[Symbol, untyped] options) -> void
-      def raise_max_validation_error!(max, options)
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :max_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def max_failure(max, options)
         message = options[:max_message] || options[:message]
         message %= { max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.max", max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.max", max:))
+      end
+
+      # @param gt [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :gt_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def gt_failure(gt, options)
+        message = options[:gt_message] || options[:message]
+        message %= { gt: } unless message.nil?
+
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.gt", gt:))
+      end
+
+      # @param lt [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :lt_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def lt_failure(lt, options)
+        message = options[:lt_message] || options[:message]
+        message %= { lt: } unless message.nil?
+
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.lt", lt:))
       end
 
-      # Raises validation error for exact length validation.
-      #
-      # @param is [Integer] Required exact length
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer is, Hash[Symbol, untyped] options) -> void
-      def raise_is_validation_error!(is, options)
+      # @param is [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :is_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def is_failure(is, options) # rubocop:disable Naming/PredicatePrefix
         message = options[:is_message] || options[:message]
         message %= { is: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.is", is:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.is", is:))
       end
 
-      # Raises validation error for is_not length validation.
-      #
-      # @param is_not [Integer] Length that is not allowed
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] Always raised with appropriate message
-      #
-      # @rbs (Integer is_not, Hash[Symbol, untyped] options) -> void
-      def raise_is_not_validation_error!(is_not, options)
+      # @param is_not [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :is_not_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def is_not_failure(is_not, options) # rubocop:disable Naming/PredicatePrefix
         message = options[:is_not_message] || options[:message]
         message %= { is_not: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.length.is_not", is_not:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.length.is_not", is_not:))
       end
 
     end

data/lib/cmdx/validators/numeric.rb

@@ -1,75 +1,64 @@
 # frozen_string_literal: true
 
 module CMDx
-  module Validators
-    # Validates numeric values against various constraints and ranges
-    #
-    # This validator ensures that numeric values meet specified criteria such as
-    # minimum/maximum bounds, exact matches, or range inclusions. It supports
-    # both inclusive and exclusive range validations with customizable error messages.
+  class Validators
+    # Validates a numeric `value` against one of: `:within` / `:not_within`
+    # / `:in` / `:not_in` (Range), `:min` + `:max`, `:gt` / `:lt` (strict
+    # comparison), or `:is` / `:is_not` (exact match). `:gte`, `:lte`,
+    # `:eq`, `:not_eq` are accepted as aliases of `:min`, `:max`, `:is`,
+    # `:is_not` respectively (with matching `_message` overrides). `nil`
+    # fails with `:nil_message` override or default.
     module Numeric
 
       extend self
 
-      # Validates a numeric value against the specified options
-      #
-      # @param value [Numeric] The numeric value to validate
-      # @param options [Hash] Validation configuration options
-      # @option options [Range] :within Range that the value must fall within (inclusive)
-      # @option options [Range] :not_within Range that the value must not fall within
-      # @option options [Range] :in Alias for :within option
-      # @option options [Range] :not_in Alias for :not_within option
-      # @option options [Numeric] :min Minimum allowed value (inclusive)
-      # @option options [Numeric] :max Maximum allowed value (inclusive)
-      # @option options [Numeric] :is Exact value that must match
-      # @option options [Numeric] :is_not Value that must not match
-      # @option options [String] :message Custom error message template
-      # @option options [String] :within_message Custom message for range validations
-      # @option options [String] :not_within_message Custom message for exclusion validations
-      # @option options [String] :min_message Custom message for minimum validation
-      # @option options [String] :max_message Custom message for maximum validation
-      # @option options [String] :is_message Custom message for exact match validation
-      # @option options [String] :is_not_message Custom message for exclusion validation
-      #
-      # @return [nil] Returns nil if validation passes
-      #
-      # @raise [ValidationError] When the value fails validation
-      # @raise [ArgumentError] When unknown validator options are provided
-      #
-      # @example Validate value within a range
-      #   Numeric.call(5, within: 1..10)
-      #   # => nil (validation passes)
-      # @example Validate minimum and maximum bounds
-      #   Numeric.call(15, min: 10, max: 20)
-      #   # => nil (validation passes)
-      # @example Validate exact value match
-      #   Numeric.call(42, is: 42)
-      #   # => nil (validation passes)
-      # @example Validate value exclusion
-      #   Numeric.call(5, not_in: 1..10)
-      #   # => nil (validation passes - 5 is not in 1..10)
-      #
-      # @rbs (Numeric value, Hash[Symbol, untyped] options) -> nil
+      ALIASES = {
+        gte: :min,
+        lte: :max,
+        eq: :is,
+        not_eq: :is_not,
+        gte_message: :min_message,
+        lte_message: :max_message,
+        eq_message: :is_message,
+        not_eq_message: :is_not_message
+      }.freeze
+      private_constant :ALIASES
+
+      # @param value [Numeric, nil]
+      # @param options [Hash{Symbol => Object}] see module summary
+      # @option options [String] :message global failure-message override
+      # @option options [String] :nil_message override when `value` is nil
+      # @option options [String] :within_message, :in_message, :not_within_message,
+      #   :not_in_message, :min_message, :max_message, :gt_message, :lt_message,
+      #   :is_message, :is_not_message
+      # @return [Validators::Failure, nil]
+      # @raise [ArgumentError] when no recognized numeric option is given
       def call(value, options = EMPTY_HASH)
-        case options
+        return nil_failure(options) if value.nil?
+
+        case options = options.transform_keys(ALIASES)
         in within:
-          raise_within_validation_error!(within.begin, within.end, options) unless within&.cover?(value)
+          within_failure(within.begin, within.end, options) unless within.cover?(value)
         in not_within:
-          raise_not_within_validation_error!(not_within.begin, not_within.end, options) if not_within&.cover?(value)
+          not_within_failure(not_within.begin, not_within.end, options) if not_within.cover?(value)
         in in: xin
-          raise_within_validation_error!(xin.begin, xin.end, options) unless xin&.cover?(value)
+          within_failure(xin.begin, xin.end, options) unless xin.cover?(value)
         in not_in:
-          raise_not_within_validation_error!(not_in.begin, not_in.end, options) if not_in&.cover?(value)
+          not_within_failure(not_in.begin, not_in.end, options) if not_in.cover?(value)
         in min:, max:
-          raise_within_validation_error!(min, max, options) unless value&.between?(min, max)
+          within_failure(min, max, options) unless value.between?(min, max)
         in min:
-          raise_min_validation_error!(min, options) unless !value.nil? && (min <= value)
+          min_failure(min, options) unless min <= value
         in max:
-          raise_max_validation_error!(max, options) unless !value.nil? && (value <= max)
+          max_failure(max, options) unless value <= max
+        in gt:
+          gt_failure(gt, options) unless gt < value
+        in lt:
+          lt_failure(lt, options) unless value < lt
         in is:
-          raise_is_validation_error!(is, options) unless !value.nil? && (value == is)
+          is_failure(is, options) unless value == is
         in is_not:
-          raise_is_not_validation_error!(is_not, options) if !value.nil? && (value == is_not)
+          is_not_failure(is_not, options) if value == is_not
         else
           raise ArgumentError, "unknown numeric validator options given"
         end
@@ -77,102 +66,113 @@ module CMDx
 
       private
 
-      # Raises validation error for range inclusion validation
-      #
-      # @param min [Numeric] The minimum value of the allowed range
-      # @param max [Numeric] The maximum value of the allowed range
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric min, Numeric max, Hash[Symbol, untyped] options) -> void
-      def raise_within_validation_error!(min, max, options)
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :nil_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def nil_failure(options)
+        message = options[:nil_message] || options[:message]
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.nil_value"))
+      end
+
+      # @param min [Object]
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :within_message
+      # @option options [String] :in_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def within_failure(min, max, options)
         message = options[:within_message] || options[:in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.within", min:, max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.within", min:, max:))
       end
 
-      # Raises validation error for range exclusion validation
-      #
-      # @param min [Numeric] The minimum value of the excluded range
-      # @param max [Numeric] The maximum value of the excluded range
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric min, Numeric max, Hash[Symbol, untyped] options) -> void
-      def raise_not_within_validation_error!(min, max, options)
+      # @param min [Object]
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :not_within_message
+      # @option options [String] :not_in_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def not_within_failure(min, max, options)
         message = options[:not_within_message] || options[:not_in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.not_within", min:, max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.not_within", min:, max:))
       end
 
-      # Raises validation error for minimum value validation
-      #
-      # @param min [Numeric] The minimum allowed value
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric min, Hash[Symbol, untyped] options) -> void
-      def raise_min_validation_error!(min, options)
+      # @param min [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :min_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def min_failure(min, options)
         message = options[:min_message] || options[:message]
         message %= { min: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.min", min:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.min", min:))
       end
 
-      # Raises validation error for maximum value validation
-      #
-      # @param max [Numeric] The maximum allowed value
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric max, Hash[Symbol, untyped] options) -> void
-      def raise_max_validation_error!(max, options)
+      # @param max [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :max_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def max_failure(max, options)
         message = options[:max_message] || options[:message]
         message %= { max: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.max", max:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.max", max:))
+      end
+
+      # @param gt [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :gt_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def gt_failure(gt, options)
+        message = options[:gt_message] || options[:message]
+        message %= { gt: } unless message.nil?
+
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.gt", gt:))
+      end
+
+      # @param lt [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :lt_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def lt_failure(lt, options)
+        message = options[:lt_message] || options[:message]
+        message %= { lt: } unless message.nil?
+
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.lt", lt:))
       end
 
-      # Raises validation error for exact value match validation
-      #
-      # @param is [Numeric] The exact value that was expected
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric is, Hash[Symbol, untyped] options) -> void
-      def raise_is_validation_error!(is, options)
+      # @param is [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :is_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def is_failure(is, options) # rubocop:disable Naming/PredicatePrefix
         message = options[:is_message] || options[:message]
         message %= { is: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.is", is:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.is", is:))
       end
 
-      # Raises validation error for value exclusion validation
-      #
-      # @param is_not [Numeric] The value that was not allowed
-      # @param options [Hash] Validation options containing custom messages
-      # @option options [Object] :* Any validation option key-value pairs
-      #
-      # @raise [ValidationError] With appropriate error message
-      #
-      # @rbs (Numeric is_not, Hash[Symbol, untyped] options) -> void
-      def raise_is_not_validation_error!(is_not, options)
+      # @param is_not [Object]
+      # @param options [Hash{Symbol => Object}]
+      # @option options [String] :is_not_message
+      # @option options [String] :message
+      # @return [Validators::Failure]
+      def is_not_failure(is_not, options) # rubocop:disable Naming/PredicatePrefix
         message = options[:is_not_message] || options[:message]
         message %= { is_not: } unless message.nil?
 
-        raise ValidationError, message || Locale.t("cmdx.validators.numeric.is_not", is_not:)
+        Failure.new(message || I18nProxy.t("cmdx.validators.numeric.is_not", is_not:))
       end
 
     end