hash_validator 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30fa62bd65cac6823fc1de4b4039397e3926d9a141d758523db6cec2c6837042
-  data.tar.gz: 444275199c9e1a25cc7966ea32776923b2d988d1a881dcfb1f2d7bebea62641c
+  metadata.gz: 01246137fa6612aec48d3ebabfb97fa856482f73d0827c520765ad636690cc85
+  data.tar.gz: 4e20f8ad39a7a5f1b4f978d5f832ae30a6896687dc3373d7885c41e637efbad4
 SHA512:
-  metadata.gz: 937942a775e75724c7e04eeecabd15ce1fb796ce25838de469508120e0fc78d7890d3bb3210f4bfa7c2ee74a528cb7a1b501e02b587a5b35a565b510b9d1072b
-  data.tar.gz: 1a894031114c6a2a72bc6ca4f03e33190e6466355b053a08b0728a28d89ceda98ceb65c77d948a148bef99bf55cbf8025a554d90a1cc3e691d24417a8c176301
+  metadata.gz: a6503553a0ec7c997006ac24dc183ddfbda551c2a94daaefff08d40733fbf474f2e99d181feccde06faa2312b9bb0d6d7c5eaac810a5d776dd928b8f21946253
+  data.tar.gz: 7710ce2712a4e67f0e164bd8ca648c4233ecab28e73542fe93b9dbc52cda2a77c1ebb5eee2e22608ca52a398cba0c9c21c99ec744dc155c512a08f751d404d31

data/README.md

@@ -55,7 +55,7 @@ validator.errors  # => {}
 
 ### Failed Validation
 ```ruby
-validations = { 
+validations = {
   user: {
     first_name: 'string',
     age: 'integer',
@@ -63,7 +63,7 @@ validations = {
   }
 }
 
-hash = { 
+hash = {
   user: {
     first_name: 'James',
     age: 'thirty',  # Should be integer
@@ -92,9 +92,9 @@ class UsersController < ApplicationController
         }
       }
     }
-    
+
     validator = HashValidator.validate(params, validations)
-    
+
     if validator.valid?
       user = User.create(params[:user])
       render json: { user: user }, status: :created
@@ -109,7 +109,7 @@ end
 # {
 #   "user": {
 #     "name": "John Doe",
-#     "email": "john@example.com", 
+#     "email": "john@example.com",
 #     "age": 30,
 #     "website": "https://johndoe.com",
 #     "preferences": {
@@ -137,6 +137,9 @@ Define a validation hash which will be used to validate. This hash can be nested
 | `float` | `{ price: 'float' }` | `{ price: 19.99 }` |
 | `hex_color` | `{ color: 'hex_color' }` | `{ color: '#ff0000' }` |
 | `integer` | `{ age: 'integer' }` | `{ age: 25 }` |
+| `ip` | `{ address: 'ip' }` | `{ address: '192.168.1.1' }` |
+| `ipv4` | `{ address: 'ipv4' }` | `{ address: '10.0.0.1' }` |
+| `ipv6` | `{ address: 'ipv6' }` | `{ address: '2001:db8::1' }` |
 | `json` | `{ config: 'json' }` | `{ config: '{"theme": "dark"}' }` |
 | `numeric` | `{ score: 'numeric' }` | `{ score: 95.5 }` |
 | `range` | `{ priority: 1..10 }` | `{ priority: 5 }` |
@@ -202,7 +205,11 @@ This is particularly useful when combining built-in validators with custom valid
 
 ## Custom Validations
 
-Allows custom defined validations (must inherit from `HashValidator::Validator::Base`). Example:
+Allows custom defined validations (must inherit from `HashValidator::Validator::Base`).
+
+### Simple Example (using `valid?`)
+
+For simple boolean validations, implement the `valid?` method:
 
 ```ruby
 # Define our custom validator
@@ -211,22 +218,176 @@ class HashValidator::Validator::OddValidator < HashValidator::Validator::Base
     super('odd')  # The name of the validator
   end
 
-  def validate(key, value, validations, errors)
-    unless value.is_a?(Integer) && value.odd?
-      errors[key] = presence_error_message
-    end
+  def error_message
+    'must be an odd number'
+  end
+
+  def valid?(value)
+    value.is_a?(Integer) && value.odd?
   end
 end
 
 # Add the validator
-HashValidator.append_validator(HashValidator::Validator::OddValidator.new)
+HashValidator.add_validator(HashValidator::Validator::OddValidator.new)
 
-# Now the validator can be used! e.g.
+# Now the validator can be used!
 validator = HashValidator.validate({ age: 27 }, { age: 'odd' })
 validator.valid?  # => true
 validator.errors  # => {}
+
+validator = HashValidator.validate({ age: 26 }, { age: 'odd' })
+validator.valid?  # => false
+validator.errors  # => { age: 'must be an odd number' }
 ```
 
+### Complex Example (using `validate`)
+
+For more complex validations that need access to the validation parameters or custom error handling, override the `validate` method:
+
+```ruby
+# Define a validator that checks if a number is within a range
+class HashValidator::Validator::RangeValidator < HashValidator::Validator::Base
+  def initialize
+    super('_range')  # Underscore prefix as it's invoked through the validation parameter
+  end
+
+  def should_validate?(validation)
+    validation.is_a?(Range)
+  end
+
+  def error_message
+    'is out of range'
+  end
+
+  def validate(key, value, range, errors)
+    unless range.include?(value)
+      errors[key] = "must be between #{range.min} and #{range.max}"
+    end
+  end
+end
+
+# Add the validator
+HashValidator.add_validator(HashValidator::Validator::RangeValidator.new)
+
+# Now the validator can be used with Range objects!
+validator = HashValidator.validate({ age: 25 }, { age: 18..65 })
+validator.valid?  # => true
+validator.errors  # => {}
+
+validator = HashValidator.validate({ age: 10 }, { age: 18..65 })
+validator.valid?  # => false
+validator.errors  # => { age: 'must be between 18 and 65' }
+```
+
+## Simple Custom Validators
+
+For simpler use cases, you can define custom validators without creating a full class using pattern matching or custom functions.
+
+### Configuration DSL
+
+Use the configuration DSL to define multiple validators at once, similar to a Rails initializer:
+
+```ruby
+# In a Rails app, this would go in config/initializers/hash_validator.rb
+HashValidator.configure do |config|
+  # Add instance-based validators
+  config.add_validator HashValidator::Validator::CustomValidator.new
+
+  # Add pattern-based validators
+  config.add_validator 'phone',
+    pattern: /\A\+?[1-9]\d{1,14}\z/,
+    error_message: 'must be a valid international phone number'
+
+  config.add_validator 'postal_code',
+    pattern: /\A[A-Z0-9]{3,10}\z/i,
+    error_message: 'must be a valid postal code'
+
+  # Add function-based validators
+  config.add_validator 'adult',
+    func: ->(age) { age.is_a?(Integer) && age >= 18 },
+    error_message: 'must be 18 or older'
+
+  config.add_validator 'business_hours',
+    func: ->(hour) { hour.between?(9, 17) },
+    error_message: 'must be between 9 AM and 5 PM'
+end
+```
+
+### Pattern-Based Validators
+
+Use regular expressions to validate string formats:
+
+```ruby
+# Add a validator for odd numbers using a pattern
+HashValidator.add_validator('odd_string',
+  pattern: /\A\d*[13579]\z/,
+  error_message: 'must be an odd number string')
+
+# Add a validator for US phone numbers
+HashValidator.add_validator('us_phone',
+  pattern: /\A\d{3}-\d{3}-\d{4}\z/,
+  error_message: 'must be a valid US phone number (XXX-XXX-XXXX)')
+
+# Use the validators
+validator = HashValidator.validate(
+  { number: '27', phone: '555-123-4567' },
+  { number: 'odd_string', phone: 'us_phone' }
+)
+validator.valid?  # => true
+
+validator = HashValidator.validate(
+  { number: '26', phone: '5551234567' },
+  { number: 'odd_string', phone: 'us_phone' }
+)
+validator.valid?  # => false
+validator.errors  # => { number: 'must be an odd number string', phone: 'must be a valid US phone number (XXX-XXX-XXXX)' }
+```
+
+### Function-Based Validators
+
+Use lambdas or procs for custom validation logic:
+
+```ruby
+# Add a validator for adult age using a lambda
+HashValidator.add_validator('adult_age',
+  func: ->(age) { age.is_a?(Integer) && age >= 18 },
+  error_message: 'must be 18 or older')
+
+# Add a validator for palindromes using a proc
+HashValidator.add_validator('palindrome',
+  func: proc { |str| str.to_s == str.to_s.reverse },
+  error_message: 'must be a palindrome')
+
+# Use the validators
+validator = HashValidator.validate(
+  { age: 25, word: 'racecar' },
+  { age: 'adult_age', word: 'palindrome' }
+)
+validator.valid?  # => true
+
+validator = HashValidator.validate(
+  { age: 16, word: 'hello' },
+  { age: 'adult_age', word: 'palindrome' }
+)
+validator.valid?  # => false
+validator.errors  # => { age: 'must be 18 or older', word: 'must be a palindrome' }
+```
+
+### Removing Custom Validators
+
+You can remove custom validators when they're no longer needed:
+
+```ruby
+# Remove a specific validator
+HashValidator.remove_validator('adult_age')
+```
+
+These simple validators are ideal for:
+- Quick format validation without regex in your main code
+- Reusable validation logic across your application
+- Keeping validation definitions close to your configuration
+- Avoiding the overhead of creating full validator classes for simple rules
+
 ## Contributing
 
 1. Fork it

data/lib/hash_validator/configuration.rb

@@ -0,0 +1,16 @@
+module HashValidator
+  class Configuration
+    def add_validator(*args)
+      HashValidator.add_validator(*args)
+    end
+    
+    def remove_validator(name)
+      HashValidator.remove_validator(name)
+    end
+  end
+  
+  def self.configure
+    config = Configuration.new
+    yield(config) if block_given?
+  end
+end

data/lib/hash_validator/validators/alpha_validator.rb

@@ -3,21 +3,13 @@ class HashValidator::Validator::AlphaValidator < HashValidator::Validator::Base
     super('alpha')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'must contain only letters'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_alpha?(value)
-      errors[key] = presence_error_message
-    end
-  end
-
-  private
-
-  def valid_alpha?(value)
-    /\A[a-zA-Z]+\z/.match?(value)
+  def valid?(value)
+    value.is_a?(String) && /\A[a-zA-Z]+\z/.match?(value)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::AlphaValidator.new)
+HashValidator.add_validator(HashValidator::Validator::AlphaValidator.new)

data/lib/hash_validator/validators/alphanumeric_validator.rb

@@ -3,21 +3,13 @@ class HashValidator::Validator::AlphanumericValidator < HashValidator::Validator
     super('alphanumeric')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'must contain only letters and numbers'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_alphanumeric?(value)
-      errors[key] = presence_error_message
-    end
-  end
-
-  private
-
-  def valid_alphanumeric?(value)
-    /\A[a-zA-Z0-9]+\z/.match?(value)
+  def valid?(value)
+    value.is_a?(String) && /\A[a-zA-Z0-9]+\z/.match?(value)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::AlphanumericValidator.new)
+HashValidator.add_validator(HashValidator::Validator::AlphanumericValidator.new)

data/lib/hash_validator/validators/array_validator.rb

@@ -77,4 +77,4 @@ class HashValidator::Validator::ArrayValidator < HashValidator::Validator::Base
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::ArrayValidator.new)
+HashValidator.add_validator(HashValidator::Validator::ArrayValidator.new)

data/lib/hash_validator/validators/base.rb

@@ -14,11 +14,36 @@ class HashValidator::Validator::Base
     self.name == name.to_s
   end
 
-  def presence_error_message
+  def error_message
     "#{self.name} required"
   end
 
-  def validate(*)
-    raise StandardError.new('validate should not be called directly on BaseValidator')
+  def validate(key, value, validations, errors)
+    # If the subclass implements valid?, use that for simple boolean validation
+    if self.class.instance_methods(false).include?(:valid?)
+      # Check the arity of the valid? method to determine how many arguments to pass
+      valid_result = case method(:valid?).arity
+      when 1
+        valid?(value)
+      when 2
+        valid?(value, validations)
+      else
+        raise StandardError.new("valid? method must accept either 1 argument (value) or 2 arguments (value, validations)")
+      end
+      
+      unless valid_result
+        errors[key] = error_message
+      end
+    else
+      # Otherwise, subclass must override validate
+      raise StandardError.new('Validator must implement either valid? or override validate method')
+    end
   end
+  
+  # Subclasses can optionally implement this for simple boolean validation
+  # Return true if valid, false if invalid
+  # Either:
+  #   def valid?(value)           # For simple validations
+  #   def valid?(value, validations)  # When validation context is needed
+  # end
 end

data/lib/hash_validator/validators/boolean_validator.rb

@@ -3,11 +3,9 @@ class HashValidator::Validator::BooleanValidator < HashValidator::Validator::Bas
     super('boolean')  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless [TrueClass, FalseClass].include?(value.class)
-      errors[key] = presence_error_message
-    end
+  def valid?(value)
+    [TrueClass, FalseClass].include?(value.class)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::BooleanValidator.new)
+HashValidator.add_validator(HashValidator::Validator::BooleanValidator.new)

data/lib/hash_validator/validators/class_validator.rb

@@ -14,4 +14,4 @@ class HashValidator::Validator::ClassValidator < HashValidator::Validator::Base
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::ClassValidator.new)
+HashValidator.add_validator(HashValidator::Validator::ClassValidator.new)

data/lib/hash_validator/validators/digits_validator.rb

@@ -3,21 +3,13 @@ class HashValidator::Validator::DigitsValidator < HashValidator::Validator::Base
     super('digits')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'must contain only digits'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_digits?(value)
-      errors[key] = presence_error_message
-    end
-  end
-
-  private
-
-  def valid_digits?(value)
-    /\A\d+\z/.match?(value)
+  def valid?(value)
+    value.is_a?(String) && /\A\d+\z/.match?(value)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::DigitsValidator.new)
+HashValidator.add_validator(HashValidator::Validator::DigitsValidator.new)

data/lib/hash_validator/validators/dynamic_func_validator.rb

@@ -0,0 +1,26 @@
+class HashValidator::Validator::DynamicFuncValidator < HashValidator::Validator::Base
+  attr_accessor :func, :custom_error_message
+
+  def initialize(name, func, error_message = nil)
+    super(name)
+    
+    unless func.respond_to?(:call)
+      raise ArgumentError, "Function must be callable (proc or lambda)"
+    end
+    
+    @func = func
+    @custom_error_message = error_message
+  end
+
+  def error_message
+    @custom_error_message || super
+  end
+
+  def valid?(value)
+    begin
+      !!@func.call(value)
+    rescue => e
+      false
+    end
+  end
+end

data/lib/hash_validator/validators/dynamic_pattern_validator.rb

@@ -0,0 +1,23 @@
+class HashValidator::Validator::DynamicPatternValidator < HashValidator::Validator::Base
+  attr_accessor :pattern, :custom_error_message
+
+  def initialize(name, pattern, error_message = nil)
+    super(name)
+    
+    unless pattern.is_a?(Regexp)
+      raise ArgumentError, "Pattern must be a regular expression"
+    end
+    
+    @pattern = pattern
+    @custom_error_message = error_message
+  end
+
+  def error_message
+    @custom_error_message || super
+  end
+
+  def valid?(value)
+    return false unless value.respond_to?(:to_s)
+    @pattern.match?(value.to_s)
+  end
+end

data/lib/hash_validator/validators/email_validator.rb

@@ -3,15 +3,13 @@ class HashValidator::Validator::EmailValidator < HashValidator::Validator::Base
     super('email')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'is not a valid email'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && value.include?("@")
-      errors[key] = presence_error_message
-    end
+  def valid?(value)
+    value.is_a?(String) && value.include?("@")
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::EmailValidator.new)
+HashValidator.add_validator(HashValidator::Validator::EmailValidator.new)

data/lib/hash_validator/validators/enumerable_validator.rb

@@ -7,15 +7,13 @@ class HashValidator::Validator::EnumerableValidator < HashValidator::Validator::
     rhs.is_a?(Enumerable)
   end
 
-  def presence_error_message
+  def error_message
     'value from list required'
   end
 
-  def validate(key, value, validations, errors)
-    unless validations.include?(value)
-      errors[key] = presence_error_message
-    end
+  def valid?(value, validations)
+    validations.include?(value)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::EnumerableValidator.new)
+HashValidator.add_validator(HashValidator::Validator::EnumerableValidator.new)

data/lib/hash_validator/validators/hash_validator.rb

@@ -15,7 +15,7 @@ class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
 
     # Validate hash
     unless value.is_a?(Hash)
-      errors[key] = presence_error_message
+      errors[key] = error_message
       return
     end
 
@@ -38,4 +38,4 @@ class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
 end
 
 
-HashValidator.append_validator(HashValidator::Validator::HashValidator.new)
+HashValidator.add_validator(HashValidator::Validator::HashValidator.new)

data/lib/hash_validator/validators/hex_color_validator.rb

@@ -3,21 +3,13 @@ class HashValidator::Validator::HexColorValidator < HashValidator::Validator::Ba
     super('hex_color')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'is not a valid hex color'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_hex_color?(value)
-      errors[key] = presence_error_message
-    end
-  end
-
-  private
-
-  def valid_hex_color?(value)
-    /\A#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})\z/.match?(value)
+  def valid?(value)
+    value.is_a?(String) && /\A#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})\z/.match?(value)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::HexColorValidator.new)
+HashValidator.add_validator(HashValidator::Validator::HexColorValidator.new)

data/lib/hash_validator/validators/ip_validator.rb

@@ -0,0 +1,22 @@
+require 'ipaddr'
+
+class HashValidator::Validator::IpValidator < HashValidator::Validator::Base
+  def initialize
+    super('ip')  # The name of the validator
+  end
+
+  def error_message
+    'is not a valid IP address'
+  end
+
+  def valid?(value)
+    return false unless value.is_a?(String)
+    # Use IPAddr to validate both IPv4 and IPv6 addresses
+    IPAddr.new(value)
+    true
+  rescue IPAddr::Error, IPAddr::InvalidAddressError
+    false
+  end
+end
+
+HashValidator.add_validator(HashValidator::Validator::IpValidator.new)

data/lib/hash_validator/validators/ipv4_validator.rb

@@ -0,0 +1,18 @@
+class HashValidator::Validator::Ipv4Validator < HashValidator::Validator::Base
+  def initialize
+    super('ipv4')  # The name of the validator
+  end
+
+  def error_message
+    'is not a valid IPv4 address'
+  end
+
+  def valid?(value)
+    return false unless value.is_a?(String)
+    # IPv4 regex: 4 octets, each 0-255
+    ipv4_regex = /\A(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\z/
+    value.match?(ipv4_regex)
+  end
+end
+
+HashValidator.add_validator(HashValidator::Validator::Ipv4Validator.new)

data/lib/hash_validator/validators/ipv6_validator.rb

@@ -0,0 +1,22 @@
+require 'ipaddr'
+
+class HashValidator::Validator::Ipv6Validator < HashValidator::Validator::Base
+  def initialize
+    super('ipv6')  # The name of the validator
+  end
+
+  def error_message
+    'is not a valid IPv6 address'
+  end
+
+  def valid?(value)
+    return false unless value.is_a?(String)
+    # Use IPAddr to validate IPv6 addresses (handles standard and compressed notation)
+    addr = IPAddr.new(value)
+    addr.ipv6?
+  rescue IPAddr::Error, IPAddr::InvalidAddressError
+    false
+  end
+end
+
+HashValidator.add_validator(HashValidator::Validator::Ipv6Validator.new)

data/lib/hash_validator/validators/json_validator.rb

@@ -5,19 +5,12 @@ class HashValidator::Validator::JsonValidator < HashValidator::Validator::Base
     super('json')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'is not valid JSON'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_json?(value)
-      errors[key] = presence_error_message
-    end
-  end
-
-  private
-
-  def valid_json?(value)
+  def valid?(value)
+    return false unless value.is_a?(String)
     JSON.parse(value)
     true
   rescue JSON::ParserError
@@ -25,4 +18,4 @@ class HashValidator::Validator::JsonValidator < HashValidator::Validator::Base
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::JsonValidator.new)
+HashValidator.add_validator(HashValidator::Validator::JsonValidator.new)