hash_validator 1.2.0 → 2.0.0

data/lib/hash_validator/validators/lambda_validator.rb

@@ -15,21 +15,18 @@ class HashValidator::Validator::LambdaValidator < HashValidator::Validator::Base
     end
   end
 
-  def presence_error_message
+  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

@@ -9,13 +9,13 @@ module HashValidator
         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 +37,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

@@ -24,4 +24,4 @@ module HashValidator
   end
 end
 
-HashValidator.append_validator(HashValidator::Validator::MultipleValidator.new)
+HashValidator.add_validator(HashValidator::Validator::MultipleValidator.new)

data/lib/hash_validator/validators/optional_validator.rb

@@ -19,4 +19,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

@@ -3,15 +3,13 @@ class HashValidator::Validator::PresenceValidator < HashValidator::Validator::Ba
     super('required')
   end
 
-  def presence_error_message
+  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

@@ -7,15 +7,13 @@ class HashValidator::Validator::RegexpValidator < HashValidator::Validator::Base
     rhs.is_a?(Regexp)
   end
 
-  def presence_error_message
+  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

@@ -13,5 +13,5 @@
   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) }))
+  HashValidator.add_validator(HashValidator::Validator::SimpleValidator.new(name, lambda { |v| v.is_a?(type) }))
 end

data/lib/hash_validator/validators/simple_validator.rb

@@ -12,9 +12,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

@@ -5,19 +5,12 @@ class HashValidator::Validator::UrlValidator < HashValidator::Validator::Base
     super('url')  # The name of the validator
   end
 
-  def presence_error_message
+  def error_message
     'is not a valid URL'
   end
 
-  def validate(key, value, _validations, errors)
-    unless value.is_a?(String) && valid_url?(value)
-      errors[key] = presence_error_message
-    end
-  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 +18,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

@@ -2,9 +2,40 @@ 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 }
@@ -24,6 +55,8 @@ end
 
 # Load validators
 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'
@@ -43,4 +76,7 @@ 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/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,3 @@
 module HashValidator
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/lib/hash_validator.rb

@@ -20,3 +20,4 @@ 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,189 @@
+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

data/spec/hash_validator_spec.rb

@@ -7,20 +7,20 @@ describe HashValidator do
 
     it 'allows validators with unique names' do
       expect {
-        HashValidator.append_validator(new_validator1)
+        HashValidator.add_validator(new_validator1)
       }.to_not raise_error
     end
 
     it 'does not allow validators with conflicting names' do
       expect {
-        HashValidator.append_validator(new_validator2)
-        HashValidator.append_validator(new_validator2)
+        HashValidator.add_validator(new_validator2)
+        HashValidator.add_validator(new_validator2)
       }.to raise_error(StandardError, 'validators need to have unique names')
     end
 
     it 'does not allow validators that do not inherit from the base validator class' do
       expect {
-        HashValidator.append_validator('Not a validator')
+        HashValidator.add_validator('Not a validator')
       }.to raise_error(StandardError, 'validators need to inherit from HashValidator::Validator::Base')
     end
   end

data/spec/validators/base_spec.rb

@@ -16,8 +16,8 @@ describe HashValidator::Validator::Base do
   describe '#validate' do
     let(:validator) { HashValidator::Validator::Base.new('test') }
 
-    it 'throws an exception as base validators cant actually validate' do
-      expect { validator.validate('key', 'value', {}, {}) }.to raise_error(StandardError, 'validate should not be called directly on BaseValidator')
+    it 'throws an exception as base validators must implement valid? or override validate' do
+      expect { validator.validate('key', 'value', {}, {}) }.to raise_error(StandardError, 'Validator must implement either valid? or override validate method')
     end
   end
 end