hash_validator 1.2.0 → 2.0.1

data/lib/hash_validator/validations/multiple.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HashValidator::Validations
   class Multiple
     attr_reader :validations

data/lib/hash_validator/validations/optional.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HashValidator::Validations
   class Optional
     attr_reader :validation

data/lib/hash_validator/validations.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module HashValidator
   module Validations
   end
 end
 
 # Load validators
-require 'hash_validator/validations/optional'
-require 'hash_validator/validations/many'
-require 'hash_validator/validations/multiple'
+require "hash_validator/validations/optional"
+require "hash_validator/validations/many"
+require "hash_validator/validations/multiple"

data/lib/hash_validator/validators/alpha_validator.rb

@@ -1,23 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::AlphaValidator < HashValidator::Validator::Base
   def initialize
-    super('alpha')  # The name of the validator
-  end
-
-  def presence_error_message
-    'must contain only letters'
+    super("alpha")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_alpha?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "must contain only letters"
   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

@@ -1,23 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::AlphanumericValidator < HashValidator::Validator::Base
   def initialize
-    super('alphanumeric')  # The name of the validator
-  end
-
-  def presence_error_message
-    'must contain only letters and numbers'
+    super("alphanumeric")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_alphanumeric?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "must contain only letters and numbers"
   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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::ArrayValidator < HashValidator::Validator::Base
   def initialize
-    super('__array__')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+    super("__array__")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
   end
 
   def should_validate?(rhs)
@@ -8,73 +10,67 @@ class HashValidator::Validator::ArrayValidator < HashValidator::Validator::Base
     return false unless rhs.size > 0
     return false unless rhs[0] == :array
 
-    return true
+    true
   end
 
   def validate(key, value, specification, errors)
-    # the first item in specification is always ":array"
-    unless specification[0] == :array
+    # Validate specification format
+    if specification[0] != :array
       errors[key] = "Wrong array specification. The #{:array} is expected as first item."
-      return
-    end
-
-    if specification.size > 2
+    elsif specification.size > 2
       errors[key] = "Wrong size of array specification. Allowed is one or two items."
-      return
-    end
-
-    unless value.is_a?(Array)
+    elsif !value.is_a?(Array)
       errors[key] = "#{Array} required"
-      return
+    elsif specification.size >= 2 && !specification[1].nil?
+      validate_array_specification(key, value, specification[1], errors)
     end
+  end
 
-    # second item is optional
-    return if specification.size < 2
+  private
+    def validate_array_specification(key, value, array_spec, errors)
+      # Convert numeric specification to hash format
+      array_spec = { size: array_spec } if array_spec.is_a?(Numeric)
 
-    array_spec = specification[1]
-    return if array_spec.nil? # array specification is optional
+      unless array_spec.is_a?(Hash)
+        errors[key] = "Second item of array specification must be #{Hash} or #{Numeric}."
+        return
+      end
 
-    if array_spec.is_a?(Numeric)
-      array_spec = { size: array_spec }
-    end
+      return if array_spec.empty?
 
-    unless array_spec.is_a?(Hash)
-      errors[key] = "Second item of array specification must be #{Hash} or #{Numeric}."
-      return
+      validate_size_specification(key, value, array_spec, errors) if errors.empty?
+      validate_allowed_keys(key, array_spec, errors) if errors.empty?
     end
 
-    return if array_spec.empty?
-
-    size_spec = array_spec[:size]
-
-    size_spec_present = case size_spec
-      when String
-        !object.strip.empty?
-      when NilClass
-        false
-      when Numeric
-        true
-      when Array, Hash
-        !object.empty?
-      else
-        !!object
+    def validate_size_specification(key, value, array_spec, errors)
+      size_spec = array_spec[:size]
+
+      size_spec_present = case size_spec
+        when String
+          !size_spec.strip.empty?
+        when NilClass
+          false
+        when Numeric
+          true
+        when Array, Hash
+          !size_spec.empty?
+        else
+          !!size_spec
       end
 
-    if size_spec_present
-      unless value.size == size_spec
+      if size_spec_present && value.size != size_spec
         errors[key] = "The required size of array is #{size_spec} but is #{value.size}."
-        return
       end
     end
 
-    allowed_keys = [:size]
-    wrong_keys = array_spec.keys - allowed_keys
+    def validate_allowed_keys(key, array_spec, errors)
+      allowed_keys = [:size]
+      wrong_keys = array_spec.keys - allowed_keys
 
-    return if wrong_keys.size < 1
-
-    errors[key] = "Not supported specification for array: #{wrong_keys.sort.join(", ")}."
-    return
-  end
+      if wrong_keys.any?
+        errors[key] = "Not supported specification for array: #{wrong_keys.sort.join(", ")}."
+      end
+    end
 end
 
-HashValidator.append_validator(HashValidator::Validator::ArrayValidator.new)
+HashValidator.add_validator(HashValidator::Validator::ArrayValidator.new)

data/lib/hash_validator/validators/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::Base
   attr_accessor :name
 
@@ -6,7 +8,7 @@ class HashValidator::Validator::Base
     self.name = name.to_s
 
     unless self.name.size > 0
-      raise StandardError.new('Validator must be initialized with a valid name (length greater than zero)')
+      raise StandardError.new("Validator must be initialized with a valid name (length greater than zero)")
     end
   end
 
@@ -14,11 +16,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

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::BooleanValidator < HashValidator::Validator::Base
   def initialize
-    super('boolean')  # The name of the validator
+    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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::ClassValidator < HashValidator::Validator::Base
   def initialize
-    super('_class')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+    super("_class")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
   end
 
   def should_validate?(rhs)
@@ -14,4 +16,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

@@ -1,23 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::DigitsValidator < HashValidator::Validator::Base
   def initialize
-    super('digits')  # The name of the validator
-  end
-
-  def presence_error_message
-    'must contain only digits'
+    super("digits")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_digits?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "must contain only digits"
   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 @@
+# frozen_string_literal: true
+
+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)
+    !!@func.call(value)
+  rescue
+    false
+  end
+end

data/lib/hash_validator/validators/dynamic_pattern_validator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::EmailValidator < HashValidator::Validator::Base
   def initialize
-    super('email')  # The name of the validator
+    super("email")  # The name of the validator
   end
 
-  def presence_error_message
-    'is not a valid email'
+  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

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::EnumerableValidator < HashValidator::Validator::Base
   def initialize
-    super('_enumerable')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+    super("_enumerable")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
   end
 
   def should_validate?(rhs)
     rhs.is_a?(Enumerable)
   end
 
-  def presence_error_message
-    'value from list required'
+  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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
   def initialize
-    super('hash')
+    super("hash")
   end
 
   def should_validate?(rhs)
@@ -15,7 +17,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
 
@@ -28,14 +30,14 @@ class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
 
     if HashValidator::Base.strict?
       value.keys.each do |k|
-        errors[k] = 'key not expected' unless validations[k]
+        errors[k] = "key not expected" unless validations[k]
       end
     end
 
     # Cleanup errors (remove any empty nested errors)
-    errors.delete_if { |_,v| v.empty? }
+    errors.delete_if { |_, v| v.empty? }
   end
 end
 
 
-HashValidator.append_validator(HashValidator::Validator::HashValidator.new)
+HashValidator.add_validator(HashValidator::Validator::HashValidator.new)

data/lib/hash_validator/validators/hex_color_validator.rb

@@ -1,23 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::HexColorValidator < HashValidator::Validator::Base
   def initialize
-    super('hex_color')  # The name of the validator
-  end
-
-  def presence_error_message
-    'is not a valid hex color'
+    super("hex_color")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_hex_color?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "is not a valid hex color"
   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,24 @@
+# frozen_string_literal: true
+
+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,20 @@
+# frozen_string_literal: true
+
+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,24 @@
+# frozen_string_literal: true
+
+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

@@ -1,23 +1,18 @@
-require 'json'
+# frozen_string_literal: true
+
+require "json"
 
 class HashValidator::Validator::JsonValidator < HashValidator::Validator::Base
   def initialize
-    super('json')  # The name of the validator
-  end
-
-  def presence_error_message
-    'is not valid JSON'
+    super("json")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_json?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "is not valid JSON"
   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 +20,4 @@ class HashValidator::Validator::JsonValidator < HashValidator::Validator::Base
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::JsonValidator.new)
+HashValidator.add_validator(HashValidator::Validator::JsonValidator.new)