hash_validator 2.0.0 → 2.0.1

data/spec/validators/alphanumeric_validator_spec.rb

@@ -1,99 +1,101 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::AlphanumericValidator do
   let(:validator) { HashValidator::Validator::AlphanumericValidator.new }
 
-  context 'valid alphanumeric strings' do
-    it 'validates letters only' do
+  context "valid alphanumeric strings" do
+    it "validates letters only" do
       errors = {}
-      validator.validate('key', 'abc', {}, errors)
+      validator.validate("key", "abc", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates numbers only' do
+    it "validates numbers only" do
       errors = {}
-      validator.validate('key', '123', {}, errors)
+      validator.validate("key", "123", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates mixed letters and numbers' do
+    it "validates mixed letters and numbers" do
       errors = {}
-      validator.validate('key', 'abc123', {}, errors)
+      validator.validate("key", "abc123", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates uppercase letters' do
+    it "validates uppercase letters" do
       errors = {}
-      validator.validate('key', 'ABC', {}, errors)
+      validator.validate("key", "ABC", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates mixed case letters' do
+    it "validates mixed case letters" do
       errors = {}
-      validator.validate('key', 'AbC123', {}, errors)
+      validator.validate("key", "AbC123", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates single character' do
+    it "validates single character" do
       errors = {}
-      validator.validate('key', 'a', {}, errors)
+      validator.validate("key", "a", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates single digit' do
+    it "validates single digit" do
       errors = {}
-      validator.validate('key', '1', {}, errors)
+      validator.validate("key", "1", {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid alphanumeric strings' do
-    it 'rejects non-string values' do
+  context "invalid alphanumeric strings" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     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 letters and numbers')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects strings with spaces' do
+    it "rejects strings with spaces" do
       errors = {}
-      validator.validate('key', 'abc 123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "abc 123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects strings with special characters' do
+    it "rejects strings with special characters" do
       errors = {}
-      validator.validate('key', 'abc!123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "abc!123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects strings with hyphens' do
+    it "rejects strings with hyphens" do
       errors = {}
-      validator.validate('key', 'abc-123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "abc-123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects strings with underscores' do
+    it "rejects strings with underscores" do
       errors = {}
-      validator.validate('key', 'abc_123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "abc_123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects empty strings' do
+    it "rejects empty strings" do
       errors = {}
-      validator.validate('key', '', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
 
-    it 'rejects strings with periods' do
+    it "rejects strings with periods" do
       errors = {}
-      validator.validate('key', 'abc.123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters and numbers')
+      validator.validate("key", "abc.123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters and numbers")
     end
   end
-end
+end

data/spec/validators/array_spec.rb

@@ -1,181 +1,236 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Array validator' do
+require "spec_helper"
+
+describe "Array validator" do
   let(:validator) { HashValidator::Validator::ArrayValidator.new }
   let(:errors)    { Hash.new }
 
-  describe '#should_validate?' do
+  describe "#should_validate?" do
     it 'should validate the array with first item ":array"' do
       expect(validator.should_validate?([:array])).to eq true
     end
 
-    it 'should validate the array with empty specification' do
-      expect(validator.should_validate?([:array, { }])).to eq true
+    it "should validate the array with empty specification" do
+      expect(validator.should_validate?([:array, {}])).to eq true
     end
 
-    it 'should validate the array with size specified to nil' do
+    it "should validate the array with size specified to nil" do
       expect(validator.should_validate?([:array, { size: nil }])).to eq true
     end
 
-    it 'should validate the array with non-sense specification' do
+    it "should validate the array with non-sense specification" do
       expect(validator.should_validate?([:array, { blah_blah_blah: false }])).to eq true
     end
 
-    it 'should not validate the empty array' do
+    it "should not validate the empty array" do
       expect(validator.should_validate?([])).to eq false
     end
 
-    it 'should not validate the array with nil item' do
+    it "should not validate the array with nil item" do
       expect(validator.should_validate?([nil])).to eq false
     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 empty array with true' do
+  describe "#validate" do
+    it "should validate an empty array with true" do
       validator.validate(:key, [], [:array], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with nil spec' do
+    it "should validate an empty array with nil spec" do
       validator.validate(:key, [], [:array, nil], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with empty spec' do
-      validator.validate(:key, [], [:array, { }], errors)
+    it "should validate an empty array with empty spec" do
+      validator.validate(:key, [], [:array, {}], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with size spec = nil' do
+    it "should validate an empty array with size spec = nil" do
       validator.validate(:key, [], [:array, { size: nil }], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with size spec = 0' do
+    it "should validate an empty array with size spec = 0" do
       validator.validate(:key, [], [:array, { size: 0 }], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with spec = 0' do
+    it "should validate an empty array with spec = 0" do
       validator.validate(:key, [], [:array, 0], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an empty array with spec = 0.0' do
+    it "should validate an empty array with spec = 0.0" do
       validator.validate(:key, [], [:array, 0.0], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an array of one item with spec = 1' do
+    it "should validate an array of one item with spec = 1" do
       validator.validate(:key, [nil], [:array, 1], errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate an array of five items with {size: 5.0}' do
-      my_array = ["one", 2, nil, ["f", "o", "u", "r"], {five: 5}]
-      validator.validate(:key, my_array, [:array, {size: 5.0}], errors)
+    it "should validate an array of five items with {size: 5.0}" do
+      my_array = ["one", 2, nil, ["f", "o", "u", "r"], { five: 5 }]
+      validator.validate(:key, my_array, [:array, { size: 5.0 }], errors)
 
       expect(errors).to be_empty
     end
 
     # >>> NOT >>>
 
-    it 'should not validate non array value' do
+    it "should not validate non array value" do
       validator.validate(:key, "I'm not array", [:array], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Array required' })
+      expect(errors).to eq({ key: "Array required" })
     end
 
-    it 'should not validate an empty array with size spec = 1' do
+    it "should not validate an empty array with size spec = 1" do
       validator.validate(:key, [], [:array, { size: 1 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'The required size of array is 1 but is 0.' })
+      expect(errors).to eq({ key: "The required size of array is 1 but is 0." })
     end
 
-    it 'should not validate an empty array with size spec = 1' do
+    it "should not validate an empty array with size spec = 1" do
       validator.validate(:key, [], [:array, { size: 1 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'The required size of array is 1 but is 0.' })
+      expect(errors).to eq({ key: "The required size of array is 1 but is 0." })
     end
 
-    it 'should not validate an empty array with spec = 1' do
+    it "should not validate an empty array with spec = 1" do
       validator.validate(:key, [], [:array, 1], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'The required size of array is 1 but is 0.' })
+      expect(errors).to eq({ key: "The required size of array is 1 but is 0." })
     end
 
     it 'should not validate an empty array with spec = "0" (string)' do
       validator.validate(:key, [], [:array, "0"], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Second item of array specification must be Hash or Numeric.' })
+      expect(errors).to eq({ key: "Second item of array specification must be Hash or Numeric." })
     end
 
     it 'should not validate an empty array with spec = "1" (string)' do
       validator.validate(:key, [], [:array, "1"], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Second item of array specification must be Hash or Numeric.' })
+      expect(errors).to eq({ key: "Second item of array specification must be Hash or Numeric." })
     end
 
-    it 'should not validate an empty array with {min_size: 0} spec' do
+    it "should not validate an empty array with {min_size: 0} spec" do
       validator.validate(:key, [], [:array, { min_size: 0 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Not supported specification for array: min_size.' })
+      expect(errors).to eq({ key: "Not supported specification for array: min_size." })
     end
 
-    it 'should not validate an empty array with {min_size: 0, max_size: 2} spec' do
+    it "should not validate an empty array with {min_size: 0, max_size: 2} spec" do
       validator.validate(:key, [], [:array, { min_size: 0, max_size: 2 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Not supported specification for array: max_size, min_size.' })
+      expect(errors).to eq({ key: "Not supported specification for array: max_size, min_size." })
     end
 
-    it 'should not validate an array of four items with {size: 3} spec' do
+    it "should not validate an array of four items with {size: 3} spec" do
       validator.validate(:key, [0, 1, 2, 3], [:array, { size: 3 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'The required size of array is 3 but is 4.' })
+      expect(errors).to eq({ key: "The required size of array is 3 but is 4." })
     end
 
-    it 'should not validate an array of four items with {size: 5} spec' do
+    it "should not validate an array of four items with {size: 5} spec" do
       validator.validate(:key, [0, 1, 2, 3], [:array, { size: 5 }], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'The required size of array is 5 but is 4.' })
+      expect(errors).to eq({ key: "The required size of array is 5 but is 4." })
     end
 
-    it 'should not validate an empty array with invalid specification' do
+    it "should not validate an empty array with invalid specification" do
       validator.validate(:key, [], [:blah], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Wrong array specification. The array is expected as first item.' })
+      expect(errors).to eq({ key: "Wrong array specification. The array is expected as first item." })
     end
 
-    it 'should not validate an empty array with to large specification' do
+    it "should not validate an empty array with to large specification" do
       validator.validate(:key, [], [:array, 0, "overlaping item"], errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'Wrong size of array specification. Allowed is one or two items.' })
+      expect(errors).to eq({ key: "Wrong size of array specification. Allowed is one or two items." })
+    end
+
+    # Edge cases that would trigger the original 'object' variable bug
+    it "should handle String size specification (non-empty)" do
+      validator.validate(:key, ["item"], [:array, { size: "non-empty" }], errors)
+
+      expect(errors).not_to be_empty
+      expect(errors).to eq({ key: "The required size of array is non-empty but is 1." })
+    end
+
+    it "should handle empty String size specification" do
+      validator.validate(:key, [], [:array, { size: "" }], errors)
+
+      expect(errors).to be_empty
+    end
+
+    it "should handle whitespace-only String size specification" do
+      validator.validate(:key, [], [:array, { size: "   " }], errors)
+
+      expect(errors).to be_empty
+    end
+
+    it "should handle Array size specification (non-empty)" do
+      validator.validate(:key, ["item"], [:array, { size: [1, 2, 3] }], errors)
+
+      expect(errors).not_to be_empty
+      expect(errors).to eq({ key: "The required size of array is [1, 2, 3] but is 1." })
+    end
+
+    it "should handle empty Array size specification" do
+      validator.validate(:key, [], [:array, { size: [] }], errors)
+
+      expect(errors).to be_empty
+    end
+
+    it "should handle Hash size specification (non-empty)" do
+      validator.validate(:key, ["item"], [:array, { size: { a: 1 } }], errors)
+
+      expect(errors).not_to be_empty
+      expect(errors).to eq({ key: "The required size of array is {:a=>1} but is 1." })
+    end
+
+    it "should handle empty Hash size specification" do
+      validator.validate(:key, [], [:array, { size: {} }], errors)
+
+      expect(errors).to be_empty
+    end
+
+    it "should handle Symbol size specification using boolean coercion" do
+      validator.validate(:key, ["item"], [:array, { size: :symbol }], errors)
+
+      expect(errors).not_to be_empty
+      expect(errors).to eq({ key: "The required size of array is symbol but is 1." })
     end
   end
 end

data/spec/validators/base_spec.rb

@@ -1,23 +1,38 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
-  let(:name) { 'my_validator' }
+  let(:name) { "my_validator" }
 
 
-  it 'allows a validator to be created with a valid name' do
+  it "allows a validator to be created with a valid name" do
     expect { HashValidator::Validator::Base.new(name) }.to_not raise_error
   end
 
-  it 'does not allow a validator to be created with an invalid name' do
-    expect { HashValidator::Validator::Base.new(nil) }.to raise_error(StandardError, 'Validator must be initialized with a valid name (length greater than zero)')
-    expect { HashValidator::Validator::Base.new('')  }.to raise_error(StandardError, 'Validator must be initialized with a valid name (length greater than zero)')
+  it "does not allow a validator to be created with an invalid name" do
+    expect { HashValidator::Validator::Base.new(nil) }.to raise_error(StandardError, "Validator must be initialized with a valid name (length greater than zero)")
+    expect { HashValidator::Validator::Base.new("")  }.to raise_error(StandardError, "Validator must be initialized with a valid name (length greater than zero)")
   end
 
-  describe '#validate' do
-    let(:validator) { HashValidator::Validator::Base.new('test') }
+  describe "#validate" do
+    let(:validator) { HashValidator::Validator::Base.new("test") }
+
+    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
+
+    it "throws an exception when valid? method has invalid arity" do
+      # Create a validator with a valid? method that accepts an invalid number of arguments (3)
+      invalid_arity_validator = Class.new(HashValidator::Validator::Base) do
+        def valid?(value, validations, extra_param)
+          true
+        end
+      end.new("invalid_arity")
 
-    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')
+      expect {
+        invalid_arity_validator.validate("key", "value", {}, {})
+      }.to raise_error(StandardError, "valid? method must accept either 1 argument (value) or 2 arguments (value, validations)")
     end
   end
 end

data/spec/validators/boolean_spec.rb

@@ -1,46 +1,48 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
   let(:validator) { HashValidator::Validator::BooleanValidator.new }
   let(:errors)    { Hash.new }
 
-  describe '#should_validate?' do
+  describe "#should_validate?" do
     it 'should validate the name "boolean"' do
-      expect(validator.should_validate?('boolean')).to eq true
+      expect(validator.should_validate?("boolean")).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 a true boolean with true' do
+  describe "#validate" do
+    it "should validate a true boolean with true" do
       validator.validate(:key, true, {}, errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate a false boolean with true' do
+    it "should validate a false boolean with true" do
       validator.validate(:key, false, {}, errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should validate a nil with false' do
+    it "should validate a nil with false" do
       validator.validate(:key, nil, {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'boolean required' })
+      expect(errors).to eq({ key: "boolean required" })
     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: 'boolean required' })
+      expect(errors).to eq({ key: "boolean required" })
     end
   end
 end

data/spec/validators/class_spec.rb

@@ -1,52 +1,54 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Class validator' do
+require "spec_helper"
+
+describe "Class validator" do
   let(:errors) { Hash.new }
 
   {
     Array => {
-      valid:   [ [], [1], ['foo'], [1,['foo'],Time.now] ],
-      invalid: [ nil, '', 123, '123', Time.now, '[1]' ]
+      valid:   [ [], [1], ["foo"], [1, ["foo"], Time.now] ],
+      invalid: [ nil, "", 123, "123", Time.now, "[1]" ]
     },
     Complex => {
-      valid:   [ Complex(1), Complex(2, 3), Complex('2/3+3/4i'), 0.3.to_c ],
-      invalid: [ nil, '', 123, '123', Time.now, '[1]', [1], '2/3+3/4i', Rational(2, 3) ]
+      valid:   [ Complex(1), Complex(2, 3), Complex("2/3+3/4i"), 0.3.to_c ],
+      invalid: [ nil, "", 123, "123", Time.now, "[1]", [1], "2/3+3/4i", Rational(2, 3) ]
     },
     Float => {
       valid:   [ 0.0, 1.1, 1.23, Float::INFINITY, Float::EPSILON ],
-      invalid: [ nil, '', 0, 123, '123', Time.now, '[1]', '2013-03-04' ]
+      invalid: [ nil, "", 0, 123, "123", Time.now, "[1]", "2013-03-04" ]
     },
     Integer => {
       valid:   [ 0, -1000000, 1000000 ],
-      invalid: [ nil, '', 1.1, '123', Time.now, '[1]', '2013-03-04' ]
+      invalid: [ nil, "", 1.1, "123", Time.now, "[1]", "2013-03-04" ]
     },
     Numeric => {
       valid:   [ 0, 123, 123.45 ],
-      invalid: [ nil, '', '123', Time.now ]
+      invalid: [ nil, "", "123", Time.now ]
     },
     Range => {
-      valid:   [ 0..10, 'a'..'z', 5..0 ],
-      invalid: [ nil, '', '123', Time.now ]
+      valid:   [ 0..10, "a".."z", 5..0 ],
+      invalid: [ nil, "", "123", Time.now ]
     },
     Rational => {
       valid:   [ Rational(1), Rational(2, 3), 3.to_r ],
-      invalid: [ nil, '', 123, '123', Time.now, '[1]', [1], Complex(2, 3) ]
+      invalid: [ nil, "", 123, "123", Time.now, "[1]", [1], Complex(2, 3) ]
     },
     Regexp => {
-      valid:   [ /[a-z]+/, //, //i, Regexp.new('.*') ],
-      invalid: [ nil, '', 123, '123', Time.now, '.*' ]
+      valid:   [ /[a-z]+/, //, //i, Regexp.new(".*") ],
+      invalid: [ nil, "", 123, "123", Time.now, ".*" ]
     },
     String => {
-      valid:   [ '', 'Hello World', '12345' ],
+      valid:   [ "", "Hello World", "12345" ],
       invalid: [ nil, 12345, Time.now ]
     },
     Symbol => {
-      valid:   [ :foo, :'', 'bar'.to_sym ],
-      invalid: [ nil, '', 1.1, '123', Time.now, '[1]', '2013-03-04' ]
+      valid:   [ :foo, :'', "bar".to_sym ],
+      invalid: [ nil, "", 1.1, "123", Time.now, "[1]", "2013-03-04" ]
     },
     Time => {
       valid:   [ Time.now ],
-      invalid: [ nil, '', 123, '123', "#{Time.now}" ]
+      invalid: [ nil, "", 123, "123", "#{Time.now}" ]
     }
   }.each do |type, data|
     describe type do