hash_validator 2.0.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

@@ -1,88 +1,90 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::DynamicFuncValidator do
-  describe 'Function-based validator' do
+  describe "Function-based validator" do
     let(:odd_func_validator) do
       HashValidator::Validator::DynamicFuncValidator.new(
-        'odd_func',
+        "odd_func",
         ->(n) { n.is_a?(Integer) && n.odd? },
-        'is not an odd integer'
+        "is not an odd integer"
       )
     end
 
     let(:range_validator) do
       HashValidator::Validator::DynamicFuncValidator.new(
-        'in_range',
+        "in_range",
         ->(n) { n.is_a?(Numeric) && n >= 18 && n <= 65 },
-        'must be between 18 and 65'
+        "must be between 18 and 65"
       )
     end
 
     let(:custom_validator) do
       HashValidator::Validator::DynamicFuncValidator.new(
-        'custom',
+        "custom",
         proc { |v| v.to_s.length > 5 },
-        'must be longer than 5 characters'
+        "must be longer than 5 characters"
       )
     end
 
     let(:errors) { Hash.new }
 
-    describe '#initialize' do
-      it 'requires a callable object' do
+    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)')
+          HashValidator::Validator::DynamicFuncValidator.new("test", "not_callable")
+        }.to raise_error(ArgumentError, "Function must be callable (proc or lambda)")
       end
 
-      it 'accepts a lambda' do
+      it "accepts a lambda" do
         validator = HashValidator::Validator::DynamicFuncValidator.new(
-          'test',
+          "test",
           ->(v) { true }
         )
         expect(validator.func).to respond_to(:call)
       end
 
-      it 'accepts a proc' do
+      it "accepts a proc" do
         validator = HashValidator::Validator::DynamicFuncValidator.new(
-          'test',
+          "test",
           proc { |v| true }
         )
         expect(validator.func).to respond_to(:call)
       end
 
-      it 'accepts a custom error message' do
+      it "accepts a custom error message" do
         validator = HashValidator::Validator::DynamicFuncValidator.new(
-          'test',
+          "test",
           ->(v) { true },
-          'custom error'
+          "custom error"
         )
-        expect(validator.error_message).to eq('custom error')
+        expect(validator.error_message).to eq("custom error")
       end
 
-      it 'uses default error message when none provided' do
+      it "uses default error message when none provided" do
         validator = HashValidator::Validator::DynamicFuncValidator.new(
-          'test',
+          "test",
           ->(v) { true }
         )
-        expect(validator.error_message).to eq('test required')
+        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
+    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
+      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
+    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
 
@@ -95,27 +97,27 @@ describe HashValidator::Validator::DynamicFuncValidator do
           expect(errors).to be_empty
         end
 
-        it 'rejects even integers' do
+        it "rejects even integers" do
           odd_func_validator.validate(:key, 2, {}, errors)
-          expect(errors).to eq({ key: 'is not an odd integer' })
+          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' })
+          expect(errors).to eq({ key: "is not an odd integer" })
         end
 
-        it 'rejects non-integers' do
+        it "rejects non-integers" do
           odd_func_validator.validate(:key, 1.5, {}, errors)
-          expect(errors).to eq({ key: 'is not an odd integer' })
+          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' })
+          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
+      context "with range validator" do
+        it "validates numbers in range" do
           range_validator.validate(:key, 18, {}, errors)
           expect(errors).to be_empty
 
@@ -132,121 +134,121 @@ describe HashValidator::Validator::DynamicFuncValidator do
           expect(errors).to be_empty
         end
 
-        it 'rejects numbers outside range' do
+        it "rejects numbers outside range" do
           range_validator.validate(:key, 17, {}, errors)
-          expect(errors).to eq({ key: 'must be between 18 and 65' })
+          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' })
+          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' })
+          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' })
+        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)
+      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)
+          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' })
+        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' })
+          custom_validator.validate(:key, "hi", {}, errors)
+          expect(errors).to eq({ key: "must be longer than 5 characters" })
         end
 
-        it 'converts values to strings' do
+        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' })
+          expect(errors).to eq({ key: "must be longer than 5 characters" })
         end
       end
 
-      context 'with function that raises errors' do
+      context "with function that raises errors" do
         let(:error_func_validator) do
           HashValidator::Validator::DynamicFuncValidator.new(
-            'error_func',
-            ->(v) { raise 'intentional error' },
-            'validation failed'
+            "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' })
+        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
+    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',
+        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')
+          error_message: "must be a palindrome")
       end
 
       after do
-        HashValidator.remove_validator('adult_age')
-        HashValidator.remove_validator('palindrome')
+        HashValidator.remove_validator("adult_age")
+        HashValidator.remove_validator("palindrome")
       end
 
-      it 'can register lambda-based validators' do
+      it "can register lambda-based validators" do
         validator = HashValidator.validate(
           { age: 25 },
-          { age: 'adult_age' }
+          { age: "adult_age" }
         )
         expect(validator.valid?).to eq true
         expect(validator.errors).to be_empty
       end
 
-      it 'returns errors for invalid lambda validations' do
+      it "returns errors for invalid lambda validations" do
         validator = HashValidator.validate(
           { age: 16 },
-          { age: 'adult_age' }
+          { age: "adult_age" }
         )
         expect(validator.valid?).to eq false
-        expect(validator.errors).to eq({ age: 'must be 18 or older' })
+        expect(validator.errors).to eq({ age: "must be 18 or older" })
       end
 
-      it 'can register proc-based validators' do
+      it "can register proc-based validators" do
         validator = HashValidator.validate(
-          { word: 'racecar' },
-          { word: 'palindrome' }
+          { 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
+      it "returns errors for invalid proc validations" do
         validator = HashValidator.validate(
-          { word: 'hello' },
-          { word: 'palindrome' }
+          { word: "hello" },
+          { word: "palindrome" }
         )
         expect(validator.valid?).to eq false
-        expect(validator.errors).to eq({ word: 'must be a palindrome' })
+        expect(validator.errors).to eq({ word: "must be a palindrome" })
       end
     end
   end
-end
+end