hash_validator 1.2.0 → 2.0.1

data/lib/hash_validator/validators/lambda_validator.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::LambdaValidator < HashValidator::Validator::Base
   def initialize
-    super('_lambda')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+    super("_lambda")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
   end
 
   def should_validate?(rhs)
@@ -15,21 +17,18 @@ class HashValidator::Validator::LambdaValidator < HashValidator::Validator::Base
     end
   end
 
-  def presence_error_message
-    'is not valid'
+  def error_message
+    "is not valid"
   end
 
-  def validate(key, value, lambda, errors)
-    unless lambda.call(value)
-      errors[key] = presence_error_message
-    end
-
+  def valid?(value, lambda)
+    lambda.call(value)
   rescue
-    errors[key] = presence_error_message
+    false
   end
 end
 
 class HashValidator::Validator::LambdaValidator::InvalidArgumentCount < StandardError
 end
 
-HashValidator.append_validator(HashValidator::Validator::LambdaValidator.new)
+HashValidator.add_validator(HashValidator::Validator::LambdaValidator.new)

data/lib/hash_validator/validators/many_validator.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module HashValidator
   module Validator
     class ManyValidator < Base
       def initialize
-        super('_many')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+        super("_many")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
       end
 
       def should_validate?(validation)
         validation.is_a?(Validations::Many)
       end
 
-      def presence_error_message
+      def error_message
         "enumerable required"
       end
 
       def validate(key, value, validations, errors)
         unless value.is_a?(Enumerable)
-          errors[key] = presence_error_message
+          errors[key] = error_message
           return
         end
 
@@ -37,4 +39,4 @@ module HashValidator
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::ManyValidator.new)
+HashValidator.add_validator(HashValidator::Validator::ManyValidator.new)

data/lib/hash_validator/validators/multiple_validator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module HashValidator
   module Validator
     class MultipleValidator < Base
       def initialize
-        super('_multiple')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+        super("_multiple")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
       end
 
       def should_validate?(validation)
@@ -18,10 +20,10 @@ module HashValidator
           multiple_errors << validation_error[key] if validation_error[key]
         end
 
-        errors[key] = multiple_errors.join(', ') if multiple_errors.any?
+        errors[key] = multiple_errors.join(", ") if multiple_errors.any?
       end
     end
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::MultipleValidator.new)
+HashValidator.add_validator(HashValidator::Validator::MultipleValidator.new)

data/lib/hash_validator/validators/optional_validator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module HashValidator
   module Validator
     class OptionalValidator < Base
       def initialize
-        super('_optional')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+        super("_optional")  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
       end
 
       def should_validate?(validation)
@@ -19,4 +21,4 @@ module HashValidator
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::OptionalValidator.new)
+HashValidator.add_validator(HashValidator::Validator::OptionalValidator.new)

data/lib/hash_validator/validators/presence_validator.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::PresenceValidator < HashValidator::Validator::Base
   def initialize
-    super('required')
+    super("required")
   end
 
-  def presence_error_message
-    'is required'
+  def error_message
+    "is required"
   end
 
-  def validate(key, value, _validations, errors)
-    if value.nil?
-      errors[key] = presence_error_message
-    end
+  def valid?(value)
+    !value.nil?
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::PresenceValidator.new)
+HashValidator.add_validator(HashValidator::Validator::PresenceValidator.new)

data/lib/hash_validator/validators/regex_validator.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::RegexpValidator < HashValidator::Validator::Base
   def initialize
-    super('_regex')  # The name of the validator, underscored as it won't usually be directly invoked (invoked through use of validator)
+    super("_regex")  # 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?(Regexp)
   end
 
-  def presence_error_message
-    'does not match regular expression'
+  def error_message
+    "does not match regular expression"
   end
 
-  def validate(key, value, regexp, errors)
-    unless regexp.match(value.to_s)
-      errors[key] = presence_error_message
-    end
+  def valid?(value, regexp)
+    regexp.match(value.to_s)
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::RegexpValidator.new)
+HashValidator.add_validator(HashValidator::Validator::RegexpValidator.new)

data/lib/hash_validator/validators/simple_type_validators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 [
   Array,
   Complex,
@@ -12,6 +14,6 @@
   Symbol,
   Time
 ].each do |type|
-  name = type.to_s.gsub(/(.)([A-Z])/,'\1_\2').downcase  # ActiveSupport/Inflector#underscore behaviour
-  HashValidator.append_validator(HashValidator::Validator::SimpleValidator.new(name, lambda { |v| v.is_a?(type) }))
+  name = type.to_s.gsub(/(.)([A-Z])/, '\1_\2').downcase  # ActiveSupport/Inflector#underscore behaviour
+  HashValidator.add_validator(HashValidator::Validator::SimpleValidator.new(name, lambda { |v| v.is_a?(type) }))
 end

data/lib/hash_validator/validators/simple_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class HashValidator::Validator::SimpleValidator < HashValidator::Validator::Base
   attr_accessor :lambda
 
@@ -12,9 +14,7 @@ class HashValidator::Validator::SimpleValidator < HashValidator::Validator::Base
     self.lambda = lambda
   end
 
-  def validate(key, value, _validations, errors)
-    unless lambda.call(value)
-      errors[key] = presence_error_message
-    end
+  def valid?(value)
+    lambda.call(value)
   end
 end

data/lib/hash_validator/validators/url_validator.rb

@@ -1,23 +1,18 @@
-require 'uri'
+# frozen_string_literal: true
+
+require "uri"
 
 class HashValidator::Validator::UrlValidator < HashValidator::Validator::Base
   def initialize
-    super('url')  # The name of the validator
-  end
-
-  def presence_error_message
-    'is not a valid URL'
+    super("url")  # The name of the validator
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_url?(value)
-      errors[key] = presence_error_message
-    end
+  def error_message
+    "is not a valid URL"
   end
 
-  private
-
-  def valid_url?(value)
+  def valid?(value)
+    return false unless value.is_a?(String)
     uri = URI.parse(value)
     %w[http https ftp].include?(uri.scheme)
   rescue URI::InvalidURIError
@@ -25,4 +20,4 @@ class HashValidator::Validator::UrlValidator < HashValidator::Validator::Base
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::UrlValidator.new)
+HashValidator.add_validator(HashValidator::Validator::UrlValidator.new)

data/lib/hash_validator/validators.rb

@@ -1,14 +1,47 @@
+# frozen_string_literal: true
+
 module HashValidator
   @@validators = []
 
 
-  def self.append_validator(validator)
-    unless validator.is_a?(HashValidator::Validator::Base)
-      raise StandardError.new('validators need to inherit from HashValidator::Validator::Base')
+  def self.remove_validator(name)
+    name = name.to_s
+    @@validators.reject! { |v| v.name == name }
+  end
+
+  def self.add_validator(*args)
+    validator = case args.length
+    when 1
+      # Instance-based validator (existing behavior)
+      validator_instance = args[0]
+      unless validator_instance.is_a?(HashValidator::Validator::Base)
+        raise StandardError.new("validators need to inherit from HashValidator::Validator::Base")
+      end
+      validator_instance
+    when 2
+      # Dynamic validator with options
+      name = args[0]
+      options = args[1]
+
+      if options.is_a?(Hash)
+        if options[:pattern]
+          # Pattern-based validator
+          HashValidator::Validator::DynamicPatternValidator.new(name, options[:pattern], options[:error_message])
+        elsif options[:func]
+          # Function-based validator
+          HashValidator::Validator::DynamicFuncValidator.new(name, options[:func], options[:error_message])
+        else
+          raise ArgumentError, "Options hash must contain either :pattern or :func key"
+        end
+      else
+        raise ArgumentError, "Second argument must be an options hash with :pattern or :func key"
+      end
+    else
+      raise ArgumentError, "add_validator expects 1 argument (validator instance) or 2 arguments (name, options)"
     end
 
     if @@validators.detect { |v| v.name == validator.name }
-      raise StandardError.new('validators need to have unique names')
+      raise StandardError.new("validators need to have unique names")
     end
 
     @@validators << validator
@@ -23,24 +56,29 @@ module HashValidator
 end
 
 # Load validators
-require 'hash_validator/validators/base'
-require 'hash_validator/validators/simple_validator'
-require 'hash_validator/validators/class_validator'
-require 'hash_validator/validators/hash_validator'
-require 'hash_validator/validators/presence_validator'
-require 'hash_validator/validators/simple_type_validators'
-require 'hash_validator/validators/boolean_validator'
-require 'hash_validator/validators/email_validator'
-require 'hash_validator/validators/enumerable_validator'
-require 'hash_validator/validators/regex_validator'
-require 'hash_validator/validators/lambda_validator'
-require 'hash_validator/validators/optional_validator'
-require 'hash_validator/validators/many_validator'
-require 'hash_validator/validators/multiple_validator'
-require 'hash_validator/validators/array_validator'
-require 'hash_validator/validators/url_validator'
-require 'hash_validator/validators/json_validator'
-require 'hash_validator/validators/hex_color_validator'
-require 'hash_validator/validators/alphanumeric_validator'
-require 'hash_validator/validators/alpha_validator'
-require 'hash_validator/validators/digits_validator'
+require "hash_validator/validators/base"
+require "hash_validator/validators/dynamic_pattern_validator"
+require "hash_validator/validators/dynamic_func_validator"
+require "hash_validator/validators/simple_validator"
+require "hash_validator/validators/class_validator"
+require "hash_validator/validators/hash_validator"
+require "hash_validator/validators/presence_validator"
+require "hash_validator/validators/simple_type_validators"
+require "hash_validator/validators/boolean_validator"
+require "hash_validator/validators/email_validator"
+require "hash_validator/validators/enumerable_validator"
+require "hash_validator/validators/regex_validator"
+require "hash_validator/validators/lambda_validator"
+require "hash_validator/validators/optional_validator"
+require "hash_validator/validators/many_validator"
+require "hash_validator/validators/multiple_validator"
+require "hash_validator/validators/array_validator"
+require "hash_validator/validators/url_validator"
+require "hash_validator/validators/json_validator"
+require "hash_validator/validators/hex_color_validator"
+require "hash_validator/validators/alphanumeric_validator"
+require "hash_validator/validators/alpha_validator"
+require "hash_validator/validators/digits_validator"
+require "hash_validator/validators/ipv4_validator"
+require "hash_validator/validators/ipv6_validator"
+require "hash_validator/validators/ip_validator"

data/lib/hash_validator/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HashValidator
-  VERSION = '1.2.0'
+  VERSION = "2.0.1"
 end

data/lib/hash_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HashValidator
   def self.validate(*args)
     Base.validate(*args)
@@ -16,7 +18,8 @@ module HashValidator
   end
 end
 
-require 'hash_validator/base'
-require 'hash_validator/version'
-require 'hash_validator/validators'
-require 'hash_validator/validations'
+require "hash_validator/base"
+require "hash_validator/version"
+require "hash_validator/validators"
+require "hash_validator/validations"
+require "hash_validator/configuration"

data/spec/configuration_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "HashValidator.configure" do
+  describe "configuration DSL" do
+    after(:each) do
+      # Clean up any validators added during tests
+      HashValidator.remove_validator("test_pattern")
+      HashValidator.remove_validator("test_func")
+      HashValidator.remove_validator("bulk_odd")
+      HashValidator.remove_validator("bulk_even")
+      HashValidator.remove_validator("bulk_palindrome")
+      HashValidator.remove_validator("custom_configured")
+    end
+
+    it "allows adding instance-based validators" do
+      class HashValidator::Validator::CustomConfiguredValidator < HashValidator::Validator::Base
+        def initialize
+          super("custom_configured")
+        end
+
+        def valid?(value)
+          value == "configured"
+        end
+      end
+
+      HashValidator.configure do |config|
+        config.add_validator HashValidator::Validator::CustomConfiguredValidator.new
+      end
+
+      validator = HashValidator.validate(
+        { status: "configured" },
+        { status: "custom_configured" }
+      )
+      expect(validator.valid?).to eq true
+    end
+
+    it "allows adding pattern-based validators" do
+      HashValidator.configure do |config|
+        config.add_validator "test_pattern",
+          pattern: /\A[A-Z]{3}\z/,
+          error_message: "must be three uppercase letters"
+      end
+
+      validator = HashValidator.validate(
+        { code: "ABC" },
+        { code: "test_pattern" }
+      )
+      expect(validator.valid?).to eq true
+
+      validator = HashValidator.validate(
+        { code: "abc" },
+        { code: "test_pattern" }
+      )
+      expect(validator.valid?).to eq false
+      expect(validator.errors).to eq({ code: "must be three uppercase letters" })
+    end
+
+    it "allows adding function-based validators" do
+      HashValidator.configure do |config|
+        config.add_validator "test_func",
+          func: ->(v) { v.is_a?(Integer) && v > 100 },
+          error_message: "must be an integer greater than 100"
+      end
+
+      validator = HashValidator.validate(
+        { score: 150 },
+        { score: "test_func" }
+      )
+      expect(validator.valid?).to eq true
+
+      validator = HashValidator.validate(
+        { score: 50 },
+        { score: "test_func" }
+      )
+      expect(validator.valid?).to eq false
+      expect(validator.errors).to eq({ score: "must be an integer greater than 100" })
+    end
+
+    it "allows adding multiple validators in one configure block" do
+      HashValidator.configure do |config|
+        config.add_validator "bulk_odd",
+          pattern: /\A\d*[13579]\z/,
+          error_message: "must be odd"
+
+        config.add_validator "bulk_even",
+          pattern: /\A\d*[02468]\z/,
+          error_message: "must be even"
+
+        config.add_validator "bulk_palindrome",
+          func: proc { |s| s.to_s == s.to_s.reverse },
+          error_message: "must be a palindrome"
+      end
+
+      # Test odd validator
+      validator = HashValidator.validate(
+        { num: "13" },
+        { num: "bulk_odd" }
+      )
+      expect(validator.valid?).to eq true
+
+      # Test even validator
+      validator = HashValidator.validate(
+        { num: "24" },
+        { num: "bulk_even" }
+      )
+      expect(validator.valid?).to eq true
+
+      # Test palindrome validator
+      validator = HashValidator.validate(
+        { word: "level" },
+        { word: "bulk_palindrome" }
+      )
+      expect(validator.valid?).to eq true
+    end
+
+    it "allows removing validators within configure block" do
+      # First add a validator
+      HashValidator.add_validator "test_pattern",
+        pattern: /test/,
+        error_message: "test"
+
+      # Then remove it in configure
+      HashValidator.configure do |config|
+        config.remove_validator "test_pattern"
+      end
+
+      # Should raise error as validator no longer exists
+      expect {
+        HashValidator.validate({ value: "test" }, { value: "test_pattern" })
+      }.to raise_error(StandardError, /Could not find valid validator/)
+    end
+
+    it "works without a block" do
+      expect {
+        HashValidator.configure
+      }.not_to raise_error
+    end
+
+    it "yields a Configuration instance" do
+      HashValidator.configure do |config|
+        expect(config).to be_a(HashValidator::Configuration)
+      end
+    end
+  end
+
+  describe "Rails-style initializer example" do
+    after(:each) do
+      HashValidator.remove_validator("phone")
+      HashValidator.remove_validator("postal_code")
+      HashValidator.remove_validator("age_range")
+    end
+
+    it "can be used like a Rails initializer" do
+      # This would typically be in config/initializers/hash_validator.rb
+      HashValidator.configure do |config|
+        # Add pattern 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 validator
+        config.add_validator "age_range",
+          func: ->(age) { age.is_a?(Integer) && age.between?(0, 120) },
+          error_message: "must be between 0 and 120"
+      end
+
+      # Use the configured validators
+      validator = HashValidator.validate(
+        {
+          phone: "+14155551234",
+          postal_code: "SW1A1AA",
+          age: 30
+        },
+        {
+          phone: "phone",
+          postal_code: "postal_code",
+          age: "age_range"
+        }
+      )
+
+      expect(validator.valid?).to eq true
+      expect(validator.errors).to be_empty
+    end
+  end
+end