hash_validator 2.0.0 → 2.0.1

data/spec/hash_validator_spec.rb

@@ -1,296 +1,315 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator do
-  describe 'Adding validators' do
-    let(:new_validator1) { HashValidator::Validator::SimpleValidator.new('my_type1', lambda { |v| true }) }
-    let(:new_validator2) { HashValidator::Validator::SimpleValidator.new('my_type2', lambda { |v| true }) }
+  describe "Adding validators" do
+    let(:new_validator1) { HashValidator::Validator::SimpleValidator.new("my_type1", lambda { |v| true }) }
+    let(:new_validator2) { HashValidator::Validator::SimpleValidator.new("my_type2", lambda { |v| true }) }
 
-    it 'allows validators with unique names' do
+    it "allows validators with unique names" do
       expect {
         HashValidator.add_validator(new_validator1)
       }.to_not raise_error
     end
 
-    it 'does not allow validators with conflicting names' do
+    it "does not allow validators with conflicting names" do
       expect {
         HashValidator.add_validator(new_validator2)
         HashValidator.add_validator(new_validator2)
-      }.to raise_error(StandardError, 'validators need to have unique names')
+      }.to raise_error(StandardError, "validators need to have unique names")
+    end
+
+    it "does not allow validators that do not inherit from the base validator class" do
+      expect {
+        HashValidator.add_validator("Not a validator")
+      }.to raise_error(StandardError, "validators need to inherit from HashValidator::Validator::Base")
     end
 
-    it 'does not allow validators that do not inherit from the base validator class' do
+    it "raises ArgumentError when options hash is missing :pattern or :func key" do
       expect {
-        HashValidator.add_validator('Not a validator')
-      }.to raise_error(StandardError, 'validators need to inherit from HashValidator::Validator::Base')
+        HashValidator.add_validator("test_validator", { invalid_key: "value" })
+      }.to raise_error(ArgumentError, "Options hash must contain either :pattern or :func key")
+    end
+
+    it "raises ArgumentError when second argument is not a hash" do
+      expect {
+        HashValidator.add_validator("test_validator", "not_a_hash")
+      }.to raise_error(ArgumentError, "Second argument must be an options hash with :pattern or :func key")
+    end
+
+    it "raises ArgumentError when wrong number of arguments are provided" do
+      expect {
+        HashValidator.add_validator("test", "arg2", "arg3")
+      }.to raise_error(ArgumentError, "add_validator expects 1 argument (validator instance) or 2 arguments (name, options)")
     end
   end
 
-  describe '#validate' do
-    describe 'individual type validations' do
-      it 'should validate hash' do
+  describe "#validate" do
+    describe "individual type validations" do
+      it "should validate hash" do
         expect(validate({ v: {} }, { v: {} }).valid?).to eq true
 
-        expect(validate({ v: '' }, { v: {} }).valid?).to eq false
-        expect(validate({ v: '' }, { v: {} }).errors).to eq({ v: 'hash required' })
+        expect(validate({ v: "" }, { v: {} }).valid?).to eq false
+        expect(validate({ v: "" }, { v: {} }).errors).to eq({ v: "hash required" })
       end
 
-      it 'should validate presence' do
-        expect(validate({ v: 'test' }, { v: 'required' }).valid?).to eq true
-        expect(validate({ v: 1234   }, { v: 'required' }).valid?).to eq true
+      it "should validate presence" do
+        expect(validate({ v: "test" }, { v: "required" }).valid?).to eq true
+        expect(validate({ v: 1234   }, { v: "required" }).valid?).to eq true
 
-        expect(validate({ v: nil    }, { v: 'required' }).valid?).to eq false
-        expect(validate({ v: nil    }, { v: 'required' }).errors).to eq({ v: 'is required' })
+        expect(validate({ v: nil    }, { v: "required" }).valid?).to eq false
+        expect(validate({ v: nil    }, { v: "required" }).errors).to eq({ v: "is required" })
 
-        expect(validate({ x: 'test' }, { v: 'required' }).valid?).to eq false
-        expect(validate({ x: 'test' }, { v: 'required' }).errors).to eq({ v: 'is required' })
+        expect(validate({ x: "test" }, { v: "required" }).valid?).to eq false
+        expect(validate({ x: "test" }, { v: "required" }).errors).to eq({ v: "is required" })
 
-        expect(validate({ x: 1234   }, { v: 'required' }).valid?).to eq false
-        expect(validate({ x: 1234   }, { v: 'required' }).errors).to eq({ v: 'is required' })
+        expect(validate({ x: 1234   }, { v: "required" }).valid?).to eq false
+        expect(validate({ x: 1234   }, { v: "required" }).errors).to eq({ v: "is required" })
       end
 
-      it 'should validate string' do
-        expect(validate({ v: 'test' }, { v: 'string' }).valid?).to eq true
+      it "should validate string" do
+        expect(validate({ v: "test" }, { v: "string" }).valid?).to eq true
 
-        expect(validate({ v: 123456 }, { v: 'string' }).valid?).to eq false
-        expect(validate({ v: 123456 }, { v: 'string' }).errors).to eq({ v: 'string required' })
+        expect(validate({ v: 123456 }, { v: "string" }).valid?).to eq false
+        expect(validate({ v: 123456 }, { v: "string" }).errors).to eq({ v: "string required" })
       end
 
-      it 'should validate numeric' do
-        expect(validate({ v: 1234 }, { v: 'numeric' }).valid?).to eq true
-        expect(validate({ v: '12' }, { v: 'numeric' }).valid?).to eq false
+      it "should validate numeric" do
+        expect(validate({ v: 1234 }, { v: "numeric" }).valid?).to eq true
+        expect(validate({ v: "12" }, { v: "numeric" }).valid?).to eq false
       end
 
-      it 'should validate array' do
-        expect(validate({ v: [ 1,2,3 ] }, { v: 'array' }).valid?).to eq true
-        expect(validate({ v: ' 1,2,3 ' }, { v: 'array' }).valid?).to eq false
+      it "should validate array" do
+        expect(validate({ v: [ 1, 2, 3 ] }, { v: "array" }).valid?).to eq true
+        expect(validate({ v: " 1,2,3 " }, { v: "array" }).valid?).to eq false
       end
 
-      it 'should validate time' do
-        expect(validate({ v: Time.now                    }, { v: 'time' }).valid?).to eq true
-        expect(validate({ v: '2013-04-12 13:18:05 +0930' }, { v: 'time' }).valid?).to eq false
+      it "should validate time" do
+        expect(validate({ v: Time.now                    }, { v: "time" }).valid?).to eq true
+        expect(validate({ v: "2013-04-12 13:18:05 +0930" }, { v: "time" }).valid?).to eq false
       end
     end
 
-    describe 'validator syntax' do
-      it 'should allow strings as validator names' do
-        expect(validate({ v: 'test' }, { v: 'string' }).valid?).to eq true
+    describe "validator syntax" do
+      it "should allow strings as validator names" do
+        expect(validate({ v: "test" }, { v: "string" }).valid?).to eq true
       end
 
-      it 'should allow symbols as validator names' do
-        expect(validate({ v: 'test' }, { v: :string }).valid?).to eq true
+      it "should allow symbols as validator names" do
+        expect(validate({ v: "test" }, { v: :string }).valid?).to eq true
       end
     end
 
-    describe 'full validations' do
-      let(:empty_hash) {{}}
+    describe "full validations" do
+      let(:empty_hash) { {} }
 
-      let(:simple_hash) {{
+      let(:simple_hash) { {
           foo: 1,
-          bar: 'baz'
+          bar: "baz"
         }}
 
-      let(:invalid_simple_hash) {{
+      let(:invalid_simple_hash) { {
           foo: 1,
           bar: 2
         }}
 
-      let(:complex_hash) {{
+      let(:complex_hash) { {
           foo: 1,
-          bar: 'baz',
+          bar: "baz",
           user: {
-            first_name: 'James',
-            last_name:  'Brooks',
+            first_name: "James",
+            last_name:  "Brooks",
             age:        27,
-            likes:      [ 'Ruby', 'Kendo', 'Board Games' ]
+            likes:      [ "Ruby", "Kendo", "Board Games" ]
           }
         }}
 
-      let(:invalid_complex_hash) {{
+      let(:invalid_complex_hash) { {
           foo: 1,
           bar: 2,
           user: {
-            first_name: 'James',
-            last_name:  'Brooks',
-            likes:      'Ruby, Kendo, Board Games'
+            first_name: "James",
+            last_name:  "Brooks",
+            likes:      "Ruby, Kendo, Board Games"
           }
         }}
 
-      describe 'no validations' do
-        let(:validations) {{}}
+      describe "no validations" do
+        let(:validations) { {} }
 
-        it 'should validate an empty hash' do
+        it "should validate an empty hash" do
           v = validate(empty_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should validate a simple hash' do
+        it "should validate a simple hash" do
           v = validate(simple_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should validate a simple hash 2' do
+        it "should validate a simple hash 2" do
           v = validate(invalid_simple_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should validate a complex hash 2' do
+        it "should validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
       end
 
-      describe 'simple validations' do
-        let(:validations) {{ foo: 'numeric', bar: 'string' }}
+      describe "simple validations" do
+        let(:validations) { { foo: "numeric", bar: "string" } }
 
-        it 'should not validate an empty hash (stating missing with required)' do
+        it "should not validate an empty hash (stating missing with required)" do
           v = validate(empty_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ foo: 'numeric required', bar: 'string required' })
+          expect(v.errors).to eq({ foo: "numeric required", bar: "string required" })
         end
 
-        it 'should validate a simple hash' do
+        it "should validate a simple hash" do
           v = validate(simple_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a simple hash 2' do
+        it "should not validate a simple hash 2" do
           v = validate(invalid_simple_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ bar: 'string required' })
+          expect(v.errors).to eq({ bar: "string required" })
         end
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a complex hash 2' do
+        it "should not validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ bar: 'string required' })
+          expect(v.errors).to eq({ bar: "string required" })
         end
       end
 
-      describe 'nested validations' do
-        let(:validations) {{
-          foo: 'numeric',
-          bar: 'string',
+      describe "nested validations" do
+        let(:validations) { {
+          foo: "numeric",
+          bar: "string",
           user: {
-            first_name: 'string',
+            first_name: "string",
             last_name:  /^(Brooks|Smith)$/,
-            age:        'required',
-            likes:      'array'
+            age:        "required",
+            likes:      "array"
           }
         }}
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a complex hash 2' do
+        it "should not validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ bar: 'string required', user: { age: 'is required', likes: 'array required' } })
+          expect(v.errors).to eq({ bar: "string required", user: { age: "is required", likes: "array required" } })
         end
       end
 
-      describe 'optional validations' do
-        let(:validations) {{ foo: 'numeric', bar: HashValidator.optional('string') }}
+      describe "optional validations" do
+        let(:validations) { { foo: "numeric", bar: HashValidator.optional("string") } }
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a complex hash 2' do
+        it "should not validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ bar: 'string required' })
+          expect(v.errors).to eq({ bar: "string required" })
         end
       end
 
-      describe 'many validations' do
-        let(:validations) {{ foo: 'numeric', bar: 'string', user: { first_name: 'string', likes: HashValidator.many('string') } }}
+      describe "many validations" do
+        let(:validations) { { foo: "numeric", bar: "string", user: { first_name: "string", likes: HashValidator.many("string") } } }
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a complex hash 2' do
+        it "should not validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ bar: 'string required', user: { likes: 'enumerable required' } })
+          expect(v.errors).to eq({ bar: "string required", user: { likes: "enumerable required" } })
         end
       end
 
-      describe 'multiple validations' do
-        let(:validations) {{ foo: 'numeric', user: { age: HashValidator.multiple('numeric', 1..100) } }}
+      describe "multiple validations" do
+        let(:validations) { { foo: "numeric", user: { age: HashValidator.multiple("numeric", 1..100) } } }
 
-        it 'should validate a complex hash' do
+        it "should validate a complex hash" do
           v = validate(complex_hash, validations)
           expect(v.valid?).to eq true
           expect(v.errors).to be_empty
         end
 
-        it 'should not validate a complex hash 2' do
+        it "should not validate a complex hash 2" do
           v = validate(invalid_complex_hash, validations)
           expect(v.valid?).to eq false
-          expect(v.errors).to eq({ user: { age: 'numeric required, value from list required' } })
+          expect(v.errors).to eq({ user: { age: "numeric required, value from list required" } })
         end
       end
     end
   end
 end
 
-describe 'Strict Validation' do
-  let(:simple_hash) { { foo: 'bar', bar: 'foo' } }
+describe "Strict Validation" do
+  let(:simple_hash) { { foo: "bar", bar: "foo" } }
 
-  let(:complex_hash) {{
+  let(:complex_hash) { {
       foo: 1,
       user: {
-        first_name: 'James',
-        last_name:  'Brooks',
+        first_name: "James",
+        last_name:  "Brooks",
         age:        27,
-        likes:      [ 'Ruby', 'Kendo', 'Board Games' ]
+        likes:      [ "Ruby", "Kendo", "Board Games" ]
       }
     }}
 
-  let(:validations) { { foo: 'string' } }
+  let(:validations) { { foo: "string" } }
 
-  let(:complex_validations) {{
-      foo: 'integer',
+  let(:complex_validations) { {
+      foo: "integer",
       user: {
-        first_name: 'string', age: 'integer'
+        first_name: "string", age: "integer"
       }
     }}
 
-  it 'reports which keys are not expected for a simple hash' do
+  it "reports which keys are not expected for a simple hash" do
     v = validate(simple_hash, validations, true)
     expect(v.valid?).to eq false
-    expect(v.errors).to eq({ bar: 'key not expected' })
+    expect(v.errors).to eq({ bar: "key not expected" })
   end
 
-  it 'reports which keys are not expected for a complex hash' do
+  it "reports which keys are not expected for a complex hash" do
     v = validate(complex_hash, complex_validations, true)
     expect(v.valid?).to eq false
-    expect(v.errors).to eq(user: { last_name: 'key not expected', likes: 'key not expected' })
+    expect(v.errors).to eq(user: { last_name: "key not expected", likes: "key not expected" })
   end
-
 end

data/spec/hash_validator_spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HashValidatorSpecHelper
   def validate(hash, validations, strict = false)
     HashValidator.validate(hash, validations, strict)

data/spec/spec_helper.rb

@@ -1,11 +1,21 @@
-require 'rubygems'
-require 'hash_validator'
-require 'hash_validator_spec_helper'
+# frozen_string_literal: true
+
+require "rubygems"
+require "simplecov"
+require "simplecov_json_formatter"
+
+SimpleCov.start do
+  formatter SimpleCov::Formatter::JSONFormatter
+  add_filter "/spec/"
+end
+
+require "hash_validator"
+require "hash_validator_spec_helper"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
-  config.order = 'random'
+  config.order = "random"
 
   config.include HashValidatorSpecHelper
 end

data/spec/validators/alpha_validator_spec.rb

@@ -1,93 +1,95 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::AlphaValidator do
   let(:validator) { HashValidator::Validator::AlphaValidator.new }
 
-  context 'valid alpha strings' do
-    it 'validates lowercase letters' do
+  context "valid alpha strings" do
+    it "validates lowercase letters" do
       errors = {}
-      validator.validate('key', 'abc', {}, errors)
+      validator.validate("key", "abc", {}, 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', 'AbC', {}, errors)
+      validator.validate("key", "AbC", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates single letter' do
+    it "validates single letter" do
       errors = {}
-      validator.validate('key', 'a', {}, errors)
+      validator.validate("key", "a", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates long strings' do
+    it "validates long strings" do
       errors = {}
-      validator.validate('key', 'HelloWorld', {}, errors)
+      validator.validate("key", "HelloWorld", {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid alpha strings' do
-    it 'rejects non-string values' do
+  context "invalid alpha strings" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     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')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with numbers' do
+    it "rejects strings with numbers" do
       errors = {}
-      validator.validate('key', 'abc123', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc123", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with spaces' do
+    it "rejects strings with spaces" do
       errors = {}
-      validator.validate('key', 'abc def', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc def", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with special characters' do
+    it "rejects strings with special characters" do
       errors = {}
-      validator.validate('key', 'abc!', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc!", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with hyphens' do
+    it "rejects strings with hyphens" do
       errors = {}
-      validator.validate('key', 'abc-def', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc-def", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with underscores' do
+    it "rejects strings with underscores" do
       errors = {}
-      validator.validate('key', 'abc_def', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc_def", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     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')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
 
-    it 'rejects strings with periods' do
+    it "rejects strings with periods" do
       errors = {}
-      validator.validate('key', 'abc.def', {}, errors)
-      expect(errors['key']).to eq('must contain only letters')
+      validator.validate("key", "abc.def", {}, errors)
+      expect(errors["key"]).to eq("must contain only letters")
     end
   end
-end
+end