hash_validator 1.2.0 → 2.0.1

data/spec/validators/digits_validator_spec.rb

@@ -1,99 +1,101 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::DigitsValidator do
   let(:validator) { HashValidator::Validator::DigitsValidator.new }
 
-  context 'valid digit strings' do
-    it 'validates single digit' do
+  context "valid digit strings" do
+    it "validates single digit" do
       errors = {}
-      validator.validate('key', '1', {}, errors)
+      validator.validate("key", "1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates multiple digits' do
+    it "validates multiple digits" do
       errors = {}
-      validator.validate('key', '123', {}, errors)
+      validator.validate("key", "123", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates zero' do
+    it "validates zero" do
       errors = {}
-      validator.validate('key', '0', {}, errors)
+      validator.validate("key", "0", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates long number strings' do
+    it "validates long number strings" do
       errors = {}
-      validator.validate('key', '1234567890', {}, errors)
+      validator.validate("key", "1234567890", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates leading zeros' do
+    it "validates leading zeros" do
       errors = {}
-      validator.validate('key', '0123', {}, errors)
+      validator.validate("key", "0123", {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid digit strings' do
-    it 'rejects non-string values' do
+  context "invalid digit strings" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects nil values' do
+    it "rejects nil values" do
       errors = {}
-      validator.validate('key', nil, {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects strings with letters' do
+    it "rejects strings with letters" do
       errors = {}
-      validator.validate('key', '123abc', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "123abc", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects strings with spaces' do
+    it "rejects strings with spaces" do
       errors = {}
-      validator.validate('key', '123 456', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "123 456", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects strings with special characters' do
+    it "rejects strings with special characters" do
       errors = {}
-      validator.validate('key', '123!', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "123!", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects strings with hyphens' do
+    it "rejects strings with hyphens" do
       errors = {}
-      validator.validate('key', '123-456', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "123-456", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects strings with periods' do
+    it "rejects strings with periods" do
       errors = {}
-      validator.validate('key', '123.456', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "123.456", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects empty strings' do
+    it "rejects empty strings" do
       errors = {}
-      validator.validate('key', '', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects negative signs' do
+    it "rejects negative signs" do
       errors = {}
-      validator.validate('key', '-123', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "-123", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
 
-    it 'rejects positive signs' do
+    it "rejects positive signs" do
       errors = {}
-      validator.validate('key', '+123', {}, errors)
-      expect(errors['key']).to eq('must contain only digits')
+      validator.validate("key", "+123", {}, errors)
+      expect(errors["key"]).to eq("must contain only digits")
     end
   end
-end
+end

data/spec/validators/dynamic_func_validator_spec.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe HashValidator::Validator::DynamicFuncValidator do
+  describe "Function-based validator" do
+    let(:odd_func_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        "odd_func",
+        ->(n) { n.is_a?(Integer) && n.odd? },
+        "is not an odd integer"
+      )
+    end
+
+    let(:range_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        "in_range",
+        ->(n) { n.is_a?(Numeric) && n >= 18 && n <= 65 },
+        "must be between 18 and 65"
+      )
+    end
+
+    let(:custom_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        "custom",
+        proc { |v| v.to_s.length > 5 },
+        "must be longer than 5 characters"
+      )
+    end
+
+    let(:errors) { Hash.new }
+
+    describe "#initialize" do
+      it "requires a callable object" do
+        expect {
+          HashValidator::Validator::DynamicFuncValidator.new("test", "not_callable")
+        }.to raise_error(ArgumentError, "Function must be callable (proc or lambda)")
+      end
+
+      it "accepts a lambda" do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          "test",
+          ->(v) { true }
+        )
+        expect(validator.func).to respond_to(:call)
+      end
+
+      it "accepts a proc" do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          "test",
+          proc { |v| true }
+        )
+        expect(validator.func).to respond_to(:call)
+      end
+
+      it "accepts a custom error message" do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          "test",
+          ->(v) { true },
+          "custom error"
+        )
+        expect(validator.error_message).to eq("custom error")
+      end
+
+      it "uses default error message when none provided" do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          "test",
+          ->(v) { true }
+        )
+        expect(validator.error_message).to eq("test required")
+      end
+    end
+
+    describe "#should_validate?" do
+      it "validates the correct name" do
+        expect(odd_func_validator.should_validate?("odd_func")).to eq true
+      end
+
+      it "does not validate other names" do
+        expect(odd_func_validator.should_validate?("even_func")).to eq false
+        expect(odd_func_validator.should_validate?("string")).to eq false
+      end
+    end
+
+    describe "#validate" do
+      context "with odd number function" do
+        it "validates odd integers correctly" do
+          odd_func_validator.validate(:key, 1, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_func_validator.validate(:key, 13, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_func_validator.validate(:key, -7, {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it "rejects even integers" do
+          odd_func_validator.validate(:key, 2, {}, errors)
+          expect(errors).to eq({ key: "is not an odd integer" })
+
+          errors.clear
+          odd_func_validator.validate(:key, 100, {}, errors)
+          expect(errors).to eq({ key: "is not an odd integer" })
+        end
+
+        it "rejects non-integers" do
+          odd_func_validator.validate(:key, 1.5, {}, errors)
+          expect(errors).to eq({ key: "is not an odd integer" })
+
+          errors.clear
+          odd_func_validator.validate(:key, "1", {}, errors)
+          expect(errors).to eq({ key: "is not an odd integer" })
+        end
+      end
+
+      context "with range validator" do
+        it "validates numbers in range" do
+          range_validator.validate(:key, 18, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 30, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 65, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 25.5, {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it "rejects numbers outside range" do
+          range_validator.validate(:key, 17, {}, errors)
+          expect(errors).to eq({ key: "must be between 18 and 65" })
+
+          errors.clear
+          range_validator.validate(:key, 66, {}, errors)
+          expect(errors).to eq({ key: "must be between 18 and 65" })
+
+          errors.clear
+          range_validator.validate(:key, -5, {}, errors)
+          expect(errors).to eq({ key: "must be between 18 and 65" })
+        end
+
+        it "rejects non-numeric values" do
+          range_validator.validate(:key, "twenty", {}, errors)
+          expect(errors).to eq({ key: "must be between 18 and 65" })
+        end
+      end
+
+      context "with custom validator using proc" do
+        it "validates strings longer than 5 chars" do
+          custom_validator.validate(:key, "hello world", {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          custom_validator.validate(:key, "testing", {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it "rejects strings 5 chars or shorter" do
+          custom_validator.validate(:key, "hello", {}, errors)
+          expect(errors).to eq({ key: "must be longer than 5 characters" })
+
+          errors.clear
+          custom_validator.validate(:key, "hi", {}, errors)
+          expect(errors).to eq({ key: "must be longer than 5 characters" })
+        end
+
+        it "converts values to strings" do
+          custom_validator.validate(:key, 123456, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          custom_validator.validate(:key, 12345, {}, errors)
+          expect(errors).to eq({ key: "must be longer than 5 characters" })
+        end
+      end
+
+      context "with function that raises errors" do
+        let(:error_func_validator) do
+          HashValidator::Validator::DynamicFuncValidator.new(
+            "error_func",
+            ->(v) { raise "intentional error" },
+            "validation failed"
+          )
+        end
+
+        it "treats exceptions as validation failures" do
+          error_func_validator.validate(:key, "any value", {}, errors)
+          expect(errors).to eq({ key: "validation failed" })
+        end
+      end
+    end
+
+    describe "Integration with HashValidator.add_validator" do
+      before do
+        HashValidator.add_validator("adult_age",
+          func: ->(age) { age.is_a?(Integer) && age >= 18 },
+          error_message: "must be 18 or older")
+
+        HashValidator.add_validator("palindrome",
+          func: proc { |s| s.to_s == s.to_s.reverse },
+          error_message: "must be a palindrome")
+      end
+
+      after do
+        HashValidator.remove_validator("adult_age")
+        HashValidator.remove_validator("palindrome")
+      end
+
+      it "can register lambda-based validators" do
+        validator = HashValidator.validate(
+          { age: 25 },
+          { age: "adult_age" }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it "returns errors for invalid lambda validations" do
+        validator = HashValidator.validate(
+          { age: 16 },
+          { age: "adult_age" }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ age: "must be 18 or older" })
+      end
+
+      it "can register proc-based validators" do
+        validator = HashValidator.validate(
+          { word: "racecar" },
+          { word: "palindrome" }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it "returns errors for invalid proc validations" do
+        validator = HashValidator.validate(
+          { word: "hello" },
+          { word: "palindrome" }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ word: "must be a palindrome" })
+      end
+    end
+  end
+end

data/spec/validators/dynamic_pattern_validator_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe HashValidator::Validator::DynamicPatternValidator do
+  describe "Pattern-based validator" do
+    let(:odd_pattern_validator) do
+      HashValidator::Validator::DynamicPatternValidator.new(
+        "odd_pattern",
+        /\A\d*[13579]\z/,
+        "is not an odd number"
+      )
+    end
+
+    let(:postal_code_validator) do
+      HashValidator::Validator::DynamicPatternValidator.new(
+        "us_postal",
+        /\A\d{5}(-\d{4})?\z/,
+        "is not a valid US postal code"
+      )
+    end
+
+    let(:errors) { Hash.new }
+
+    describe "#initialize" do
+      it "requires a valid regular expression" do
+        expect {
+          HashValidator::Validator::DynamicPatternValidator.new("test", "not_a_regex")
+        }.to raise_error(ArgumentError, "Pattern must be a regular expression")
+      end
+
+      it "accepts a custom error message" do
+        validator = HashValidator::Validator::DynamicPatternValidator.new(
+          "test",
+          /test/,
+          "custom error"
+        )
+        expect(validator.error_message).to eq("custom error")
+      end
+
+      it "uses default error message when none provided" do
+        validator = HashValidator::Validator::DynamicPatternValidator.new("test", /test/)
+        expect(validator.error_message).to eq("test required")
+      end
+    end
+
+    describe "#should_validate?" do
+      it "validates the correct name" do
+        expect(odd_pattern_validator.should_validate?("odd_pattern")).to eq true
+      end
+
+      it "does not validate other names" do
+        expect(odd_pattern_validator.should_validate?("even_pattern")).to eq false
+        expect(odd_pattern_validator.should_validate?("string")).to eq false
+      end
+    end
+
+    describe "#validate" do
+      context "with odd number pattern" do
+        it "validates odd numbers correctly" do
+          odd_pattern_validator.validate(:key, "1", {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, "13", {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, "999", {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it "rejects even numbers" do
+          odd_pattern_validator.validate(:key, "2", {}, errors)
+          expect(errors).to eq({ key: "is not an odd number" })
+
+          errors.clear
+          odd_pattern_validator.validate(:key, "100", {}, errors)
+          expect(errors).to eq({ key: "is not an odd number" })
+        end
+
+        it "rejects non-numeric strings" do
+          odd_pattern_validator.validate(:key, "abc", {}, errors)
+          expect(errors).to eq({ key: "is not an odd number" })
+        end
+
+        it "converts non-string values to strings" do
+          odd_pattern_validator.validate(:key, 13, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, 14, {}, errors)
+          expect(errors).to eq({ key: "is not an odd number" })
+        end
+      end
+
+      context "with postal code pattern" do
+        it "validates correct postal codes" do
+          postal_code_validator.validate(:key, "12345", {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          postal_code_validator.validate(:key, "12345-6789", {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it "rejects invalid postal codes" do
+          postal_code_validator.validate(:key, "1234", {}, errors)
+          expect(errors).to eq({ key: "is not a valid US postal code" })
+
+          errors.clear
+          postal_code_validator.validate(:key, "12345-678", {}, errors)
+          expect(errors).to eq({ key: "is not a valid US postal code" })
+
+          errors.clear
+          postal_code_validator.validate(:key, "ABCDE", {}, errors)
+          expect(errors).to eq({ key: "is not a valid US postal code" })
+        end
+      end
+    end
+
+    describe "Integration with HashValidator.add_validator" do
+      before do
+        HashValidator.add_validator("phone_number",
+          pattern: /\A\d{3}-\d{3}-\d{4}\z/,
+          error_message: "is not a valid phone number")
+      end
+
+      after do
+        HashValidator.remove_validator("phone_number")
+      end
+
+      it "can be registered and used via add_validator" do
+        validator = HashValidator.validate(
+          { phone: "555-123-4567" },
+          { phone: "phone_number" }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it "returns errors for invalid values" do
+        validator = HashValidator.validate(
+          { phone: "5551234567" },
+          { phone: "phone_number" }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ phone: "is not a valid phone number" })
+      end
+    end
+  end
+end

data/spec/validators/email_spec.rb

@@ -1,40 +1,42 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
   let(:validator) { HashValidator::Validator::EmailValidator.new }
   let(:errors)    { Hash.new }
 
-  describe '#should_validate?' do
+  describe "#should_validate?" do
     it 'should validate the name "email"' do
-      expect(validator.should_validate?('email')).to eq true
+      expect(validator.should_validate?("email")).to eq true
     end
 
-    it 'should not validate other names' do
-      expect(validator.should_validate?('string')).to eq false
-      expect(validator.should_validate?('array')).to eq false
+    it "should not validate other names" do
+      expect(validator.should_validate?("string")).to eq false
+      expect(validator.should_validate?("array")).to eq false
       expect(validator.should_validate?(nil)).to eq false
     end
   end
 
-  describe '#validate' do
-    it 'should validate an email with true' do
+  describe "#validate" do
+    it "should validate an email with true" do
       validator.validate(:key, "johndoe@gmail.com", {}, errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate a string without an @ symbol with false' do
-      validator.validate(:key, 'test', {}, errors)
+    it "should validate a string without an @ symbol with false" do
+      validator.validate(:key, "test", {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'is not a valid email' })
+      expect(errors).to eq({ key: "is not a valid email" })
     end
 
-    it 'should validate a number with false' do
+    it "should validate a number with false" do
       validator.validate(:key, 123, {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'is not a valid email' })
+      expect(errors).to eq({ key: "is not a valid email" })
     end
   end
 end