cmdx 1.0.1 → 1.1.1

data/lib/cmdx/validators/length.rb

@@ -2,108 +2,58 @@
 
 module CMDx
   module Validators
-    # Length validator for parameter validation based on size constraints.
+    # Validator class for validating the length of values.
     #
-    # The Length validator validates the length/size of parameter values such as
-    # strings, arrays, and other objects that respond to #length. It supports
-    # various constraint types including ranges, boundaries, and exact lengths.
-    #
-    # @example Range-based length validation
-    #   class ProcessUserTask < CMDx::Task
-    #     required :username, length: { within: 3..20 }
-    #     required :password, length: { in: 8..128 }
-    #     required :bio, length: { not_within: 500..1000 }  # Avoid medium length
-    #   end
-    #
-    # @example Boundary length validation
-    #   class ProcessContentTask < CMDx::Task
-    #     required :title, length: { min: 5 }
-    #     required :description, length: { max: 500 }
-    #     required :slug, length: { min: 3, max: 50 }  # Combined min/max
-    #   end
-    #
-    # @example Exact length validation
-    #   class ProcessCodeTask < CMDx::Task
-    #     required :country_code, length: { is: 2 }  # ISO country codes
-    #     required :postal_code, length: { is_not: 4 }  # Avoid 4-digit codes
-    #   end
-    #
-    # @example Custom error messages
-    #   class ProcessUserTask < CMDx::Task
-    #     required :username, length: {
-    #       within: 3..20,
-    #       within_message: "must be between %{min} and %{max} characters"
-    #     }
-    #     required :password, length: {
-    #       min: 8,
-    #       min_message: "must be at least %{min} characters for security"
-    #     }
-    #   end
-    #
-    # @example Length validation behavior
-    #   # String length validation
-    #   Length.call("hello", length: { min: 3 })      # passes (length: 5)
-    #   Length.call("hi", length: { min: 3 })         # raises ValidationError
-    #
-    #   # Array length validation
-    #   Length.call([1, 2, 3], length: { is: 3 })     # passes
-    #   Length.call([1, 2], length: { is: 3 })        # raises ValidationError
-    #
-    # @see CMDx::Validators::Numeric For numeric value validation
-    # @see CMDx::Parameter Parameter validation integration
-    # @see CMDx::ValidationError Raised when validation fails
-    module Length
-
-      extend self
-
-      # Validates that a parameter value meets the specified length constraints.
-      #
-      # Validates the length of the value using the specified constraint type.
-      # Only one constraint option can be used at a time, except for :min and :max
-      # which can be combined together.
-      #
-      # @param value [#length] The parameter value to validate (must respond to #length)
-      # @param options [Hash] Validation configuration options
-      # @option options [Hash] :length Length validation configuration
-      # @option options [Range] :length.within Allowed length range
-      # @option options [Range] :length.not_within Forbidden length range
-      # @option options [Range] :length.in Alias for :within
-      # @option options [Range] :length.not_in Alias for :not_within
-      # @option options [Integer] :length.min Minimum allowed length
-      # @option options [Integer] :length.max Maximum allowed length
-      # @option options [Integer] :length.is Exact required length
-      # @option options [Integer] :length.is_not Forbidden exact length
-      # @option options [String] :length.*_message Custom error messages for each constraint
+    # This validator ensures that a value's length meets specified criteria.
+    # It supports various length validation options including exact length,
+    # minimum/maximum bounds, range validation, and exclusion patterns.
+    class Length < Validator
+
+      # Validates that the given value's length meets the specified criteria.
       #
-      # @return [void]
-      # @raise [ValidationError] If value doesn't meet the length constraints
-      # @raise [ArgumentError] If no valid length constraint options are provided
+      # @param value [Object] the value to validate (must respond to #length)
+      # @param options [Hash] validation options containing length configuration
+      # @option options [Hash] :length length validation configuration
+      # @option options [Range] :length.within acceptable length range
+      # @option options [Range] :length.not_within unacceptable length range
+      # @option options [Range] :length.in alias for :within
+      # @option options [Range] :length.not_in alias for :not_within
+      # @option options [Integer] :length.min minimum acceptable length
+      # @option options [Integer] :length.max maximum acceptable length
+      # @option options [Integer] :length.is exact required length
+      # @option options [Integer] :length.is_not exact forbidden length
+      # @option options [String] :length.message custom error message
+      # @option options [String] :length.within_message custom error message for within validation
+      # @option options [String] :length.not_within_message custom error message for not_within validation
+      # @option options [String] :length.in_message alias for :within_message
+      # @option options [String] :length.not_in_message alias for :not_within_message
+      # @option options [String] :length.min_message custom error message for minimum validation
+      # @option options [String] :length.max_message custom error message for maximum validation
+      # @option options [String] :length.is_message custom error message for exact validation
+      # @option options [String] :length.is_not_message custom error message for exact exclusion validation
       #
-      # @example Range validation
-      #   Length.call("hello", length: { within: 3..10 })
-      #   # => passes without error
+      # @return [void]
       #
-      # @example Failed range validation
-      #   Length.call("hi", length: { within: 3..10 })
-      #   # => raises ValidationError: "length must be within 3 and 10"
+      # @raise [ValidationError] if the value's length doesn't meet the criteria
+      # @raise [ArgumentError] if no known length validator options are provided
       #
-      # @example Minimum length validation
-      #   Length.call("password123", length: { min: 8 })
-      #   # => passes without error
+      # @example Validating within a range
+      #   Validators::Length.call("hello", length: { within: 1..10 })
+      #   #=> nil (no error raised)
       #
-      # @example Combined min/max validation
-      #   Length.call("username", length: { min: 3, max: 20 })
-      #   # => passes without error
+      # @example Validating minimum length
+      #   Validators::Length.call("hi", length: { min: 5 })
+      #   # raises ValidationError: "length must be at least 5"
       #
-      # @example Exact length validation
-      #   Length.call("US", length: { is: 2 })
-      #   # => passes without error (country code)
+      # @example Validating exact length
+      #   Validators::Length.call("test", length: { is: 4 })
+      #   #=> nil (no error raised)
       #
-      # @example Array length validation
-      #   Length.call([1, 2, 3, 4], length: { max: 5 })
-      #   # => passes without error
+      # @example Validating with custom message
+      #   Validators::Length.call("", length: { min: 1, message: "cannot be empty" })
+      #   # raises ValidationError: "cannot be empty"
       def call(value, options = {})
-        case options[:length]
+        case options
         in { within: within }
           raise_within_validation_error!(within.begin, within.end, options) unless within.cover?(value.length)
         in { not_within: not_within }
@@ -129,16 +79,21 @@ module CMDx
 
       private
 
-      # Raises validation error for range-based length violations.
+      # Raises a validation error for within/in range validation.
+      #
+      # @param min [Integer] the minimum acceptable length
+      # @param max [Integer] the maximum acceptable length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
       #
-      # @param min [Integer] Range minimum length
-      # @param max [Integer] Range maximum length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_within_validation_error!(5, 10, {})
+      #   # raises ValidationError: "length must be within 5 and 10"
       def raise_within_validation_error!(min, max, options)
-        message = options.dig(:length, :within_message) ||
-                  options.dig(:length, :in_message) ||
-                  options.dig(:length, :message)
+        message = options[:within_message] || options[:in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -149,16 +104,21 @@ module CMDx
         )
       end
 
-      # Raises validation error for forbidden range violations.
+      # Raises a validation error for not_within/not_in range validation.
+      #
+      # @param min [Integer] the minimum forbidden length
+      # @param max [Integer] the maximum forbidden length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
       #
-      # @param min [Integer] Range minimum length
-      # @param max [Integer] Range maximum length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_not_within_validation_error!(5, 10, {})
+      #   # raises ValidationError: "length must not be within 5 and 10"
       def raise_not_within_validation_error!(min, max, options)
-        message = options.dig(:length, :not_within_message) ||
-                  options.dig(:length, :not_in_message) ||
-                  options.dig(:length, :message)
+        message = options[:not_within_message] || options[:not_in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -169,14 +129,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for minimum length violations.
+      # Raises a validation error for minimum length validation.
+      #
+      # @param min [Integer] the minimum acceptable length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param min [Integer] Minimum required length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_min_validation_error!(5, {})
+      #   # raises ValidationError: "length must be at least 5"
       def raise_min_validation_error!(min, options)
-        message = options.dig(:length, :min_message) ||
-                  options.dig(:length, :message)
+        message = options[:min_message] || options[:message]
         message %= { min: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -186,14 +152,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for maximum length violations.
+      # Raises a validation error for maximum length validation.
+      #
+      # @param max [Integer] the maximum acceptable length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param max [Integer] Maximum allowed length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_max_validation_error!(10, {})
+      #   # raises ValidationError: "length must be at most 10"
       def raise_max_validation_error!(max, options)
-        message = options.dig(:length, :max_message) ||
-                  options.dig(:length, :message)
+        message = options[:max_message] || options[:message]
         message %= { max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -203,14 +175,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for exact length violations.
+      # Raises a validation error for exact length validation.
       #
-      # @param is [Integer] Required exact length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @param is [Integer] the exact required length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_is_validation_error!(5, {})
+      #   # raises ValidationError: "length must be 5"
       def raise_is_validation_error!(is, options)
-        message = options.dig(:length, :is_message) ||
-                  options.dig(:length, :message)
+        message = options[:is_message] || options[:message]
         message %= { is: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -220,14 +198,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for forbidden exact length violations.
+      # Raises a validation error for exact length exclusion validation.
+      #
+      # @param is_not [Integer] the exact forbidden length
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param is_not [Integer] Forbidden exact length
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_is_not_validation_error!(5, {})
+      #   # raises ValidationError: "length must not be 5"
       def raise_is_not_validation_error!(is_not, options)
-        message = options.dig(:length, :is_not_message) ||
-                  options.dig(:length, :message)
+        message = options[:is_not_message] || options[:message]
         message %= { is_not: } unless message.nil?
 
         raise ValidationError, message || I18n.t(

data/lib/cmdx/validators/numeric.rb

@@ -2,108 +2,67 @@
 
 module CMDx
   module Validators
-    # Numeric validator for parameter validation based on numeric value constraints.
+    # Validator class for validating numeric values with various constraints.
     #
-    # The Numeric validator validates numeric parameter values against various
-    # constraints including ranges, boundaries, and exact values. It works with
-    # any numeric type including integers, floats, decimals, and other numeric objects.
-    #
-    # @example Range-based numeric validation
-    #   class ProcessOrderTask < CMDx::Task
-    #     required :quantity, numeric: { within: 1..100 }
-    #     required :price, numeric: { in: 0.01..999.99 }
-    #     required :discount, numeric: { not_within: 90..100 }  # Avoid excessive discounts
-    #   end
-    #
-    # @example Boundary numeric validation
-    #   class ProcessUserTask < CMDx::Task
-    #     required :age, numeric: { min: 18 }
-    #     required :score, numeric: { max: 100 }
-    #     required :rating, numeric: { min: 1, max: 5 }  # Combined min/max
-    #   end
-    #
-    # @example Exact numeric validation
-    #   class ProcessConfigTask < CMDx::Task
-    #     required :version, numeric: { is: 2 }  # Specific version required
-    #     required :legacy_flag, numeric: { is_not: 0 }  # Must not be zero
-    #   end
-    #
-    # @example Custom error messages
-    #   class ProcessOrderTask < CMDx::Task
-    #     required :quantity, numeric: {
-    #       within: 1..100,
-    #       within_message: "must be between %{min} and %{max} items"
-    #     }
-    #     required :age, numeric: {
-    #       min: 18,
-    #       min_message: "must be at least %{min} years old"
-    #     }
-    #   end
-    #
-    # @example Numeric validation behavior
-    #   # Integer validation
-    #   Numeric.call(25, numeric: { min: 18 })         # passes
-    #   Numeric.call(15, numeric: { min: 18 })         # raises ValidationError
-    #
-    #   # Float validation
-    #   Numeric.call(99.99, numeric: { max: 100.0 })   # passes
-    #   Numeric.call(101.5, numeric: { max: 100.0 })   # raises ValidationError
-    #
-    # @see CMDx::Validators::Length For length/size validation
-    # @see CMDx::Parameter Parameter validation integration
-    # @see CMDx::ValidationError Raised when validation fails
-    module Numeric
-
-      extend self
-
-      # Validates that a parameter value meets the specified numeric constraints.
-      #
-      # Validates the numeric value using the specified constraint type.
-      # Only one constraint option can be used at a time, except for :min and :max
-      # which can be combined together.
-      #
-      # @param value [Numeric] The parameter value to validate (must be numeric)
-      # @param options [Hash] Validation configuration options
-      # @option options [Hash] :numeric Numeric validation configuration
-      # @option options [Range] :numeric.within Allowed value range
-      # @option options [Range] :numeric.not_within Forbidden value range
-      # @option options [Range] :numeric.in Alias for :within
-      # @option options [Range] :numeric.not_in Alias for :not_within
-      # @option options [Numeric] :numeric.min Minimum allowed value
-      # @option options [Numeric] :numeric.max Maximum allowed value
-      # @option options [Numeric] :numeric.is Exact required value
-      # @option options [Numeric] :numeric.is_not Forbidden exact value
-      # @option options [String] :numeric.*_message Custom error messages for each constraint
+    # This validator ensures that numeric values meet specified criteria such as
+    # being within a range, having minimum/maximum values, or matching exact values.
+    # It supports both inclusive and exclusive range validation, as well as discrete
+    # value matching and rejection.
+    class Numeric < Validator
+
+      # Validates that the given numeric value meets the specified constraints.
+      #
+      # @param value [Numeric] the numeric value to validate
+      # @param options [Hash] validation options containing numeric configuration
+      # @option options [Hash] :numeric numeric validation configuration
+      # @option options [Range] :numeric.within the range the value must be within
+      # @option options [Range] :numeric.not_within the range the value must not be within
+      # @option options [Range] :numeric.in alias for :within
+      # @option options [Range] :numeric.not_in alias for :not_within
+      # @option options [Numeric] :numeric.min the minimum allowed value (can be combined with :max)
+      # @option options [Numeric] :numeric.max the maximum allowed value (can be combined with :min)
+      # @option options [Numeric] :numeric.is the exact value required
+      # @option options [Numeric] :numeric.is_not the exact value that is not allowed
+      # @option options [String] :numeric.message custom error message for any validation
+      # @option options [String] :numeric.within_message custom error message for within validation
+      # @option options [String] :numeric.in_message alias for :within_message
+      # @option options [String] :numeric.not_within_message custom error message for not_within validation
+      # @option options [String] :numeric.not_in_message alias for :not_within_message
+      # @option options [String] :numeric.min_message custom error message for min validation
+      # @option options [String] :numeric.max_message custom error message for max validation
+      # @option options [String] :numeric.is_message custom error message for is validation
+      # @option options [String] :numeric.is_not_message custom error message for is_not validation
       #
       # @return [void]
-      # @raise [ValidationError] If value doesn't meet the numeric constraints
-      # @raise [ArgumentError] If no valid numeric constraint options are provided
+      #
+      # @raise [ValidationError] if the value doesn't meet the specified constraints
+      # @raise [ArgumentError] if no known numeric validator options are provided
       #
       # @example Range validation
-      #   Numeric.call(50, numeric: { within: 1..100 })
-      #   # => passes without error
+      #   Validators::Numeric.call(5, numeric: { within: 1..10 })
+      #   #=> nil (no error raised)
       #
-      # @example Failed range validation
-      #   Numeric.call(150, numeric: { within: 1..100 })
-      #   # => raises ValidationError: "must be within 1 and 100"
+      # @example Range exclusion
+      #   Validators::Numeric.call(5, numeric: { not_within: 1..10 })
+      #   # raises ValidationError: "must not be within 1 and 10"
       #
-      # @example Minimum value validation
-      #   Numeric.call(25, numeric: { min: 18 })
-      #   # => passes without error
+      # @example Min/max validation
+      #   Validators::Numeric.call(15, numeric: { min: 10, max: 20 })
+      #   #=> nil (no error raised)
       #
-      # @example Combined min/max validation
-      #   Numeric.call(3.5, numeric: { min: 1.0, max: 5.0 })
-      #   # => passes without error
+      # @example Minimum value validation
+      #   Validators::Numeric.call(5, numeric: { min: 10 })
+      #   # raises ValidationError: "must be at least 10"
       #
       # @example Exact value validation
-      #   Numeric.call(42, numeric: { is: 42 })
-      #   # => passes without error
+      #   Validators::Numeric.call(42, numeric: { is: 42 })
+      #   #=> nil (no error raised)
       #
-      # @example Float validation
-      #   Numeric.call(19.99, numeric: { max: 20.0 })
-      #   # => passes without error
+      # @example Custom error message
+      #   Validators::Numeric.call(5, numeric: { min: 10, message: "Age must be at least %{min}" })
+      #   # raises ValidationError: "Age must be at least 10"
       def call(value, options = {})
-        case options[:numeric]
+        case options
         in { within: within }
           raise_within_validation_error!(within.begin, within.end, options) unless within.cover?(value)
         in { not_within: not_within }
@@ -129,16 +88,21 @@ module CMDx
 
       private
 
-      # Raises validation error for range-based numeric violations.
+      # Raises a validation error for within/range validation.
       #
-      # @param min [Numeric] Range minimum value
-      # @param max [Numeric] Range maximum value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @param min [Numeric] the minimum value of the range
+      # @param max [Numeric] the maximum value of the range
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_within_validation_error!(1, 10, {})
+      #   # raises ValidationError: "must be within 1 and 10"
       def raise_within_validation_error!(min, max, options)
-        message = options.dig(:numeric, :within_message) ||
-                  options.dig(:numeric, :in_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:within_message] || options[:in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -149,16 +113,21 @@ module CMDx
         )
       end
 
-      # Raises validation error for forbidden range violations.
+      # Raises a validation error for not_within/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
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param min [Numeric] Range minimum value
-      # @param max [Numeric] Range maximum value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_not_within_validation_error!(1, 10, {})
+      #   # raises ValidationError: "must not be within 1 and 10"
       def raise_not_within_validation_error!(min, max, options)
-        message = options.dig(:numeric, :not_within_message) ||
-                  options.dig(:numeric, :not_in_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:not_within_message] || options[:not_in_message] || options[:message]
         message %= { min:, max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -169,14 +138,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for minimum value violations.
+      # Raises a validation error for minimum value validation.
+      #
+      # @param min [Numeric] the minimum allowed value
+      # @param options [Hash] validation options
+      #
+      # @return [void]
       #
-      # @param min [Numeric] Minimum required value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_min_validation_error!(10, {})
+      #   # raises ValidationError: "must be at least 10"
       def raise_min_validation_error!(min, options)
-        message = options.dig(:numeric, :min_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:min_message] || options[:message]
         message %= { min: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -186,14 +161,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for maximum value violations.
+      # Raises a validation error for maximum value validation.
+      #
+      # @param max [Numeric] the maximum allowed value
+      # @param options [Hash] validation options
+      #
+      # @return [void]
       #
-      # @param max [Numeric] Maximum allowed value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @raise [ValidationError] always raised with appropriate message
+      #
+      # @example
+      #   raise_max_validation_error!(100, {})
+      #   # raises ValidationError: "must be at most 100"
       def raise_max_validation_error!(max, options)
-        message = options.dig(:numeric, :max_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:max_message] || options[:message]
         message %= { max: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -203,14 +184,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for exact value violations.
+      # Raises a validation error for exact value validation.
+      #
+      # @param is [Numeric] the exact value required
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param is [Numeric] Required exact value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_is_validation_error!(42, {})
+      #   # raises ValidationError: "must be 42"
       def raise_is_validation_error!(is, options)
-        message = options.dig(:numeric, :is_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:is_message] || options[:message]
         message %= { is: } unless message.nil?
 
         raise ValidationError, message || I18n.t(
@@ -220,14 +207,20 @@ module CMDx
         )
       end
 
-      # Raises validation error for forbidden exact value violations.
+      # Raises a validation error for exact value exclusion validation.
+      #
+      # @param is_not [Numeric] the exact value that is not allowed
+      # @param options [Hash] validation options
+      #
+      # @return [void]
+      #
+      # @raise [ValidationError] always raised with appropriate message
       #
-      # @param is_not [Numeric] Forbidden exact value
-      # @param options [Hash] Validation options containing error messages
-      # @raise [ValidationError] With formatted error message
+      # @example
+      #   raise_is_not_validation_error!(0, {})
+      #   # raises ValidationError: "must not be 0"
       def raise_is_not_validation_error!(is_not, options)
-        message = options.dig(:numeric, :is_not_message) ||
-                  options.dig(:numeric, :message)
+        message = options[:is_not_message] || options[:message]
         message %= { is_not: } unless message.nil?
 
         raise ValidationError, message || I18n.t(