hash_validator 2.0.0 → 2.0.1

data/spec/validators/dynamic_pattern_validator_spec.rb

@@ -1,150 +1,152 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::DynamicPatternValidator do
-  describe 'Pattern-based validator' do
+  describe "Pattern-based validator" do
     let(:odd_pattern_validator) do
       HashValidator::Validator::DynamicPatternValidator.new(
-        'odd_pattern',
+        "odd_pattern",
         /\A\d*[13579]\z/,
-        'is not an odd number'
+        "is not an odd number"
       )
     end
 
     let(:postal_code_validator) do
       HashValidator::Validator::DynamicPatternValidator.new(
-        'us_postal',
+        "us_postal",
         /\A\d{5}(-\d{4})?\z/,
-        'is not a valid US postal code'
+        "is not a valid US postal code"
       )
     end
 
     let(:errors) { Hash.new }
 
-    describe '#initialize' do
-      it 'requires a valid regular expression' do
+    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')
+          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
+      it "accepts a custom error message" do
         validator = HashValidator::Validator::DynamicPatternValidator.new(
-          'test',
+          "test",
           /test/,
-          '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
-        validator = HashValidator::Validator::DynamicPatternValidator.new('test', /test/)
-        expect(validator.error_message).to eq('test required')
+      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
+    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
+      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)
+    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)
+          odd_pattern_validator.validate(:key, "13", {}, errors)
           expect(errors).to be_empty
 
           errors.clear
-          odd_pattern_validator.validate(:key, '999', {}, errors)
+          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' })
+        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' })
+          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' })
+        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
+        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' })
+          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)
+      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)
+          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' })
+        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' })
+          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' })
+          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
+    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')
+        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')
+        HashValidator.remove_validator("phone_number")
       end
 
-      it 'can be registered and used via add_validator' do
+      it "can be registered and used via add_validator" do
         validator = HashValidator.validate(
-          { phone: '555-123-4567' },
-          { phone: 'phone_number' }
+          { 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
+      it "returns errors for invalid values" do
         validator = HashValidator.validate(
-          { phone: '5551234567' },
-          { phone: 'phone_number' }
+          { phone: "5551234567" },
+          { phone: "phone_number" }
         )
         expect(validator.valid?).to eq false
-        expect(validator.errors).to eq({ phone: 'is not a valid phone number' })
+        expect(validator.errors).to eq({ phone: "is not a valid phone number" })
       end
     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

data/spec/validators/hash_validator_spec.rb

@@ -1,6 +1,8 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'ActionController::Parameters support' do
+require "spec_helper"
+
+describe "ActionController::Parameters support" do
   # Mock ActionController::Parameters for testing
   let(:mock_params_class) do
     Class.new do
@@ -23,12 +25,12 @@ describe 'ActionController::Parameters support' do
       end
 
       def is_a?(klass)
-        return true if klass.name == 'ActionController::Parameters'
+        return true if klass.name == "ActionController::Parameters"
         super
       end
 
       def class
-        OpenStruct.new(name: 'ActionController::Parameters')
+        Struct.new(:name).new("ActionController::Parameters")
       end
     end
   end
@@ -41,62 +43,62 @@ describe 'ActionController::Parameters support' do
     end
   end
 
-  it 'should validate ActionController::Parameters objects' do
-    params = ActionController::Parameters.new({ name: 'John', age: 30 })
-    validations = { name: 'string', age: 'integer' }
-    
+  it "should validate ActionController::Parameters objects" do
+    params = ActionController::Parameters.new({ name: "John", age: 30 })
+    validations = { name: "string", age: "integer" }
+
     validator = HashValidator.validate(params, validations)
-    
+
     expect(validator.valid?).to be true
     expect(validator.errors).to be_empty
   end
 
-  it 'should handle nested ActionController::Parameters' do
-    nested_params = ActionController::Parameters.new({ theme: 'dark' })
-    params = ActionController::Parameters.new({ 
-      name: 'John', 
+  it "should handle nested ActionController::Parameters" do
+    nested_params = ActionController::Parameters.new({ theme: "dark" })
+    params = ActionController::Parameters.new({
+      name: "John",
       preferences: nested_params
     })
-    
-    validations = { 
-      name: 'string',
-      preferences: { theme: 'string' }
+
+    validations = {
+      name: "string",
+      preferences: { theme: "string" }
     }
-    
+
     validator = HashValidator.validate(params, validations)
-    
+
     expect(validator.valid?).to be true
     expect(validator.errors).to be_empty
   end
 
-  it 'should validate ActionController::Parameters with our new validators' do
+  it "should validate ActionController::Parameters with our new validators" do
     params = ActionController::Parameters.new({
-      name: 'John',
-      email: 'john@example.com',
-      website: 'https://john.com',
-      zip_code: '12345'
+      name: "John",
+      email: "john@example.com",
+      website: "https://john.com",
+      zip_code: "12345"
     })
-    
+
     validations = {
-      name: 'alpha',
-      email: 'email',
-      website: 'url',
-      zip_code: 'digits'
+      name: "alpha",
+      email: "email",
+      website: "url",
+      zip_code: "digits"
     }
-    
+
     validator = HashValidator.validate(params, validations)
-    
+
     expect(validator.valid?).to be true
     expect(validator.errors).to be_empty
   end
 
-  it 'should still work with regular hashes' do
-    hash = { name: 'John', age: 30 }
-    validations = { name: 'string', age: 'integer' }
-    
+  it "should still work with regular hashes" do
+    hash = { name: "John", age: 30 }
+    validations = { name: "string", age: "integer" }
+
     validator = HashValidator.validate(hash, validations)
-    
+
     expect(validator.valid?).to be true
     expect(validator.errors).to be_empty
   end
-end
+end

data/spec/validators/hex_color_validator_spec.rb

@@ -1,111 +1,113 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::HexColorValidator do
   let(:validator) { HashValidator::Validator::HexColorValidator.new }
 
-  context 'valid hex colors' do
-    it 'validates 6-digit hex colors (lowercase)' do
+  context "valid hex colors" do
+    it "validates 6-digit hex colors (lowercase)" do
       errors = {}
-      validator.validate('key', '#ff0000', {}, errors)
+      validator.validate("key", "#ff0000", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates 6-digit hex colors (uppercase)' do
+    it "validates 6-digit hex colors (uppercase)" do
       errors = {}
-      validator.validate('key', '#FF0000', {}, errors)
+      validator.validate("key", "#FF0000", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates 6-digit hex colors (mixed case)' do
+    it "validates 6-digit hex colors (mixed case)" do
       errors = {}
-      validator.validate('key', '#Ff0000', {}, errors)
+      validator.validate("key", "#Ff0000", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates 3-digit hex colors (lowercase)' do
+    it "validates 3-digit hex colors (lowercase)" do
       errors = {}
-      validator.validate('key', '#f00', {}, errors)
+      validator.validate("key", "#f00", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates 3-digit hex colors (uppercase)' do
+    it "validates 3-digit hex colors (uppercase)" do
       errors = {}
-      validator.validate('key', '#F00', {}, errors)
+      validator.validate("key", "#F00", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates black color' do
+    it "validates black color" do
       errors = {}
-      validator.validate('key', '#000000', {}, errors)
+      validator.validate("key", "#000000", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates white color' do
+    it "validates white color" do
       errors = {}
-      validator.validate('key', '#ffffff', {}, errors)
+      validator.validate("key", "#ffffff", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates complex hex colors' do
+    it "validates complex hex colors" do
       errors = {}
-      validator.validate('key', '#3a7bd4', {}, errors)
+      validator.validate("key", "#3a7bd4", {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid hex colors' do
-    it 'rejects non-string values' do
+  context "invalid hex colors" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects nil values' do
+    it "rejects nil values" do
       errors = {}
-      validator.validate('key', nil, {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects hex colors without hash' do
+    it "rejects hex colors without hash" do
       errors = {}
-      validator.validate('key', 'ff0000', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "ff0000", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects invalid length (4 digits)' do
+    it "rejects invalid length (4 digits)" do
       errors = {}
-      validator.validate('key', '#ff00', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "#ff00", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects invalid length (5 digits)' do
+    it "rejects invalid length (5 digits)" do
       errors = {}
-      validator.validate('key', '#ff000', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "#ff000", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects invalid length (7 digits)' do
+    it "rejects invalid length (7 digits)" do
       errors = {}
-      validator.validate('key', '#ff00000', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "#ff00000", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects invalid characters' do
+    it "rejects invalid characters" do
       errors = {}
-      validator.validate('key', '#gg0000', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "#gg0000", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects empty strings' do
+    it "rejects empty strings" do
       errors = {}
-      validator.validate('key', '', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
 
-    it 'rejects just hash symbol' do
+    it "rejects just hash symbol" do
       errors = {}
-      validator.validate('key', '#', {}, errors)
-      expect(errors['key']).to eq('is not a valid hex color')
+      validator.validate("key", "#", {}, errors)
+      expect(errors["key"]).to eq("is not a valid hex color")
     end
   end
-end
+end