hash_validator 2.0.0 → 2.0.1

data/spec/validators/simple_types_spec.rb

@@ -1,57 +1,59 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Simple validator types' do
+require "spec_helper"
+
+describe "Simple validator types" do
   let(:errors) { Hash.new }
 
   # Simple types
   {
     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) ]
     },
     enumerable: {
       valid:   [ [], [ 1, 2, 3 ], 1..Float::INFINITY ],
-      invalid: [ nil, '', 123, '123', Time.now, Float::INFINITY ]
+      invalid: [ nil, "", 123, "123", Time.now, Float::INFINITY ]
     },
     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

data/spec/validators/url_validator_spec.rb

@@ -1,75 +1,77 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::UrlValidator do
   let(:validator) { HashValidator::Validator::UrlValidator.new }
 
-  context 'valid URLs' do
-    it 'validates http URLs' do
+  context "valid URLs" do
+    it "validates http URLs" do
       errors = {}
-      validator.validate('key', 'http://example.com', {}, errors)
+      validator.validate("key", "http://example.com", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates https URLs' do
+    it "validates https URLs" do
       errors = {}
-      validator.validate('key', 'https://example.com', {}, errors)
+      validator.validate("key", "https://example.com", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates ftp URLs' do
+    it "validates ftp URLs" do
       errors = {}
-      validator.validate('key', 'ftp://ftp.example.com', {}, errors)
+      validator.validate("key", "ftp://ftp.example.com", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates URLs with paths' do
+    it "validates URLs with paths" do
       errors = {}
-      validator.validate('key', 'https://example.com/path/to/resource', {}, errors)
+      validator.validate("key", "https://example.com/path/to/resource", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates URLs with query parameters' do
+    it "validates URLs with query parameters" do
       errors = {}
-      validator.validate('key', 'https://example.com/search?q=test&page=1', {}, errors)
+      validator.validate("key", "https://example.com/search?q=test&page=1", {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid URLs' do
-    it 'rejects non-string values' do
+  context "invalid URLs" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('is not a valid URL')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     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 URL')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     end
 
-    it 'rejects malformed URLs' do
+    it "rejects malformed URLs" do
       errors = {}
-      validator.validate('key', 'not a url', {}, errors)
-      expect(errors['key']).to eq('is not a valid URL')
+      validator.validate("key", "not a url", {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     end
 
-    it 'rejects URLs without schemes' do
+    it "rejects URLs without schemes" do
       errors = {}
-      validator.validate('key', 'example.com', {}, errors)
-      expect(errors['key']).to eq('is not a valid URL')
+      validator.validate("key", "example.com", {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     end
 
-    it 'rejects unsupported schemes' do
+    it "rejects unsupported schemes" do
       errors = {}
-      validator.validate('key', 'mailto:test@example.com', {}, errors)
-      expect(errors['key']).to eq('is not a valid URL')
+      validator.validate("key", "mailto:test@example.com", {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     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 URL')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not a valid URL")
     end
   end
-end
+end

data/spec/validators/user_defined_spec.rb

@@ -1,12 +1,14 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'User-defined validator' do
+require "spec_helper"
+
+describe "User-defined validator" do
   let(:validator) do
     unless defined?(HashValidator::Validator::OddValidator)
       # Define our custom validator
       class HashValidator::Validator::OddValidator < HashValidator::Validator::Base
         def initialize
-          super('odd')
+          super("odd")
         end
 
         def validate(key, value, validations, errors)
@@ -23,73 +25,73 @@ describe 'User-defined validator' do
   let(:errors) { Hash.new }
 
 
-  describe '#should_validate?' do
+  describe "#should_validate?" do
     it 'validates the name "odd"' do
-      expect(validator.should_validate?('odd')).to eq true
+      expect(validator.should_validate?("odd")).to eq true
     end
 
-    it 'does not validate other names' do
-      expect(validator.should_validate?('string')).to eq false
-      expect(validator.should_validate?('array')).to eq false
+    it "does 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 'validates odd integers with true' do
+  describe "#validate" do
+    it "validates odd integers with true" do
       validator.validate(:key, 1, {}, errors)
 
       expect(errors).to be_empty
     end
 
-    it 'validates even integers with errrors' do
+    it "validates even integers with errrors" do
       validator.validate(:key, 2, {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'odd required' })
+      expect(errors).to eq({ key: "odd required" })
     end
 
-    it 'validates even floats with errrors' do
+    it "validates even floats with errrors" do
       validator.validate(:key, 2.0, {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'odd required' })
+      expect(errors).to eq({ key: "odd required" })
     end
 
-    it 'validates odd floats with errrors' do
+    it "validates odd floats with errrors" do
       validator.validate(:key, 1.0, {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'odd required' })
+      expect(errors).to eq({ key: "odd required" })
     end
 
-    it 'validates an odd integer string with errrors' do
-      validator.validate(:key, '1', {}, errors)
+    it "validates an odd integer string with errrors" do
+      validator.validate(:key, "1", {}, errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'odd required' })
+      expect(errors).to eq({ key: "odd required" })
     end
   end
 
-  describe 'Integrating with the entire validation system' do
+  describe "Integrating with the entire validation system" do
     before { HashValidator.add_validator(validator) rescue nil }  # rescue to prevent: validators need to have unique names
 
-    it 'can be looked up using #validator_for' do
-      expect(HashValidator.validator_for('odd')).to be_a_kind_of(HashValidator::Validator::OddValidator)
+    it "can be looked up using #validator_for" do
+      expect(HashValidator.validator_for("odd")).to be_a_kind_of(HashValidator::Validator::OddValidator)
     end
 
-    it 'can be used in validations - test 1' do
-      validator = HashValidator.validate({ age: 27 }, { age: 'odd' })
+    it "can be used in validations - test 1" do
+      validator = HashValidator.validate({ age: 27 }, { age: "odd" })
 
       expect(validator.valid?).to eq true
       expect(validator.errors).to be_empty
     end
 
-    it 'can be used in validations - test 2' do
-      validator = HashValidator.validate({ age: 40 }, { age: 'odd' })
+    it "can be used in validations - test 2" do
+      validator = HashValidator.validate({ age: 40 }, { age: "odd" })
 
       expect(validator.valid?).to eq false
-      expect(validator.errors).to eq({ age: 'odd required' })
+      expect(validator.errors).to eq({ age: "odd required" })
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_validator
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - James Brooks
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-22 00:00:00.000000000 Z
+date: 2025-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
 description: Ruby library to validate hashes (Hash) against user-defined requirements
 email:
 - james@gooddogdesign.com
@@ -62,6 +118,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
 - LICENSE.txt