hash_validator 2.0.0 → 2.0.1

data/spec/validators/json_validator_spec.rb

@@ -1,88 +1,90 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::JsonValidator do
   let(:validator) { HashValidator::Validator::JsonValidator.new }
 
-  context 'valid JSON' do
-    it 'validates simple JSON objects' do
+  context "valid JSON" do
+    it "validates simple JSON objects" do
       errors = {}
-      validator.validate('key', '{"name": "test"}', {}, errors)
+      validator.validate("key", '{"name": "test"}', {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates JSON arrays' do
+    it "validates JSON arrays" do
       errors = {}
-      validator.validate('key', '[1, 2, 3]', {}, errors)
+      validator.validate("key", "[1, 2, 3]", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates JSON strings' do
+    it "validates JSON strings" do
       errors = {}
-      validator.validate('key', '"hello world"', {}, errors)
+      validator.validate("key", '"hello world"', {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates JSON numbers' do
+    it "validates JSON numbers" do
       errors = {}
-      validator.validate('key', '42', {}, errors)
+      validator.validate("key", "42", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates JSON booleans' do
+    it "validates JSON booleans" do
       errors = {}
-      validator.validate('key', 'true', {}, errors)
+      validator.validate("key", "true", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates JSON null' do
+    it "validates JSON null" do
       errors = {}
-      validator.validate('key', 'null', {}, errors)
+      validator.validate("key", "null", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates complex nested JSON' do
+    it "validates complex nested JSON" do
       errors = {}
       json_string = '{"users": [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]}'
-      validator.validate('key', json_string, {}, errors)
+      validator.validate("key", json_string, {}, errors)
       expect(errors).to be_empty
     end
   end
 
-  context 'invalid JSON' do
-    it 'rejects non-string values' do
+  context "invalid JSON" do
+    it "rejects non-string values" do
       errors = {}
-      validator.validate('key', 123, {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
 
-    it 'rejects nil values' do
+    it "rejects nil values" do
       errors = {}
-      validator.validate('key', nil, {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
 
-    it 'rejects malformed JSON' do
+    it "rejects malformed JSON" do
       errors = {}
-      validator.validate('key', '{"name": "test"', {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", '{"name": "test"', {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
 
-    it 'rejects invalid JSON syntax' do
+    it "rejects invalid JSON syntax" do
       errors = {}
-      validator.validate('key', '{name: "test"}', {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", '{name: "test"}', {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
 
-    it 'rejects empty strings' do
+    it "rejects empty strings" do
       errors = {}
-      validator.validate('key', '', {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
 
-    it 'rejects plain text' do
+    it "rejects plain text" do
       errors = {}
-      validator.validate('key', 'hello world', {}, errors)
-      expect(errors['key']).to eq('is not valid JSON')
+      validator.validate("key", "hello world", {}, errors)
+      expect(errors["key"]).to eq("is not valid JSON")
     end
   end
-end
+end

data/spec/validators/lambda_spec.rb

@@ -1,47 +1,49 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Functional validator' do
-  describe 'Accepting Lambdas in validations' do
-    it 'should accept a lambda' do
+require "spec_helper"
+
+describe "Functional validator" do
+  describe "Accepting Lambdas in validations" do
+    it "should accept a lambda" do
       validate({}, { foo: lambda { |arg| } })
     end
 
-    it 'should accept a proc' do
+    it "should accept a proc" do
       validate({}, { foo: Proc.new { |arg| } })
     end
   end
 
-  describe 'Correct number of arguments for lambads in validations' do
-    it 'should accept a lambda with one argument' do
+  describe "Correct number of arguments for lambads in validations" do
+    it "should accept a lambda with one argument" do
       expect { validate({}, { foo: lambda { |a| } }) }.to_not raise_error
     end
 
-    it 'should not accept a lambda with no arguments' do
+    it "should not accept a lambda with no arguments" do
       expect { validate({}, { foo: lambda { } }) }.to raise_error(HashValidator::Validator::LambdaValidator::InvalidArgumentCount)
     end
 
-    it 'should not accept a lambda with two arguments' do
-      expect { validate({}, { foo: lambda { |a,b| } }) }.to raise_error(HashValidator::Validator::LambdaValidator::InvalidArgumentCount)
+    it "should not accept a lambda with two arguments" do
+      expect { validate({}, { foo: lambda { |a, b| } }) }.to raise_error(HashValidator::Validator::LambdaValidator::InvalidArgumentCount)
     end
   end
 
-  describe '#validate' do
-    let(:validations) {{ number: lambda { |n| n.odd? } }}
+  describe "#validate" do
+    let(:validations) { { number: lambda { |n| n.odd? } } }
 
-    it 'should validate true when the number is odd' do
+    it "should validate true when the number is odd" do
       expect(validate({ number: 1 }, validations).valid?).to eq true
     end
 
-    it 'should validate false when the number is even' do
+    it "should validate false when the number is even" do
       expect(validate({ number: 2 }, validations).valid?).to eq false
     end
   end
 
-  describe 'Thrown exceptions from within the lambda' do
-    let(:validations) {{ number: lambda { |n| n.odd? } }}
+  describe "Thrown exceptions from within the lambda" do
+    let(:validations) { { number: lambda { |n| n.odd? } } }
 
-    it 'should validate false when an exception occurs within the lambda' do
-      expect(validate({ number: '2' }, validations).valid?).to eq false
+    it "should validate false when an exception occurs within the lambda" do
+      expect(validate({ number: "2" }, validations).valid?).to eq false
     end
   end
 end

data/spec/validators/many_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
   let(:validator)  { HashValidator::Validator::ManyValidator.new }
@@ -8,53 +10,53 @@ describe HashValidator::Validator::Base do
     HashValidator::Validations::Many.new(validation)
   end
 
-  describe '#should_validate?' do
-    it 'should validate an Many validation' do
-      expect(validator.should_validate?(many('string'))).to eq true
+  describe "#should_validate?" do
+    it "should validate an Many validation" do
+      expect(validator.should_validate?(many("string"))).to eq true
     end
 
-    it 'should not validate other things' do
-      expect(validator.should_validate?('string')).to eq false
-      expect(validator.should_validate?('array')).to eq false
+    it "should not validate other things" 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 accept an empty array' do
-      validator.validate(:key, [], many('string'), errors)
+  describe "#validate" do
+    it "should accept an empty array" do
+      validator.validate(:key, [], many("string"), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should accept an array of matching elements' do
-      validator.validate(:key, ['a', 'b'], many('string'), errors)
+    it "should accept an array of matching elements" do
+      validator.validate(:key, ["a", "b"], many("string"), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should not accept an array including a non-matching element' do
-      validator.validate(:key, ['a', 2], many('string'), errors)
+    it "should not accept an array including a non-matching element" do
+      validator.validate(:key, ["a", 2], many("string"), errors)
 
-      expect(errors).to eq({ key: [nil, 'string required'] })
+      expect(errors).to eq({ key: [nil, "string required"] })
     end
 
-    it 'should accept an array of matching hashes' do
-      validator.validate(:key, [{v: 'a'}, {v: 'b'}], many({v: 'string'}), errors)
+    it "should accept an array of matching hashes" do
+      validator.validate(:key, [{ v: "a" }, { v: "b" }], many({ v: "string" }), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should not accept an array including a non-matching element' do
-      validator.validate(:key, [{v: 'a'}, {v: 2}], many({v: 'string'}), errors)
+    it "should not accept an array including a non-matching element" do
+      validator.validate(:key, [{ v: "a" }, { v: 2 }], many({ v: "string" }), errors)
 
-      expect(errors).to eq({ key: [nil, {v: 'string required'}] })
+      expect(errors).to eq({ key: [nil, { v: "string required" }] })
     end
 
-    it 'should not accept a non-enumerable' do
-      validator.validate(:key, 'a', many({v: 'string'}), errors)
+    it "should not accept a non-enumerable" do
+      validator.validate(:key, "a", many({ v: "string" }), errors)
 
-      expect(errors).to eq({ key: 'enumerable required' })
+      expect(errors).to eq({ key: "enumerable required" })
     end
   end
 end

data/spec/validators/multiple_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
   let(:validator)  { HashValidator::Validator::MultipleValidator.new }
@@ -8,27 +10,27 @@ describe HashValidator::Validator::Base do
     HashValidator::Validations::Multiple.new(validations)
   end
 
-  describe '#should_validate?' do
-    it 'should validate an Multiple validation' do
-      expect(validator.should_validate?(multiple('numeric', 1..10))).to eq true
+  describe "#should_validate?" do
+    it "should validate an Multiple validation" do
+      expect(validator.should_validate?(multiple("numeric", 1..10))).to eq true
     end
 
-    it 'should not validate other things' do
-      expect(validator.should_validate?('string')).to eq false
-      expect(validator.should_validate?('array')).to eq false
+    it "should not validate other things" 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 accept an empty collection of validators' do
+  describe "#validate" do
+    it "should accept an empty collection of validators" do
       validator.validate(:key, 73, multiple(), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should accept an collection of validators' do
-      validator.validate(:key, 73, multiple('numeric', 1..100), errors)
+    it "should accept an collection of validators" do
+      validator.validate(:key, 73, multiple("numeric", 1..100), errors)
 
       expect(errors).to be_empty
     end

data/spec/validators/optional_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::Base do
   let(:validator)  { HashValidator::Validator::OptionalValidator.new }
@@ -8,49 +10,49 @@ describe HashValidator::Validator::Base do
     HashValidator::Validations::Optional.new(validation)
   end
 
-  describe '#should_validate?' do
-    it 'should validate an Optional validation' do
-      expect(validator.should_validate?(optional('string'))).to eq true
+  describe "#should_validate?" do
+    it "should validate an Optional validation" do
+      expect(validator.should_validate?(optional("string"))).to eq true
     end
 
-    it 'should not validate other things' do
-      expect(validator.should_validate?('string')).to eq false
-      expect(validator.should_validate?('array')).to eq false
+    it "should not validate other things" 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 accept a missing value' do
-      validator.validate(:key, nil, optional('string'), errors)
+  describe "#validate" do
+    it "should accept a missing value" do
+      validator.validate(:key, nil, optional("string"), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should accept a present, matching value' do
-      validator.validate(:key, 'foo', optional('string'), errors)
+    it "should accept a present, matching value" do
+      validator.validate(:key, "foo", optional("string"), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should reject a present, non-matching value' do
-      validator.validate(:key, 123, optional('string'), errors)
+    it "should reject a present, non-matching value" do
+      validator.validate(:key, 123, optional("string"), errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: 'string required' })
+      expect(errors).to eq({ key: "string required" })
     end
 
-    it 'should accept a present, matching hash' do
-      validator.validate(:key, {v: 'foo'}, optional({v: 'string'}), errors)
+    it "should accept a present, matching hash" do
+      validator.validate(:key, { v: "foo" }, optional({ v: "string" }), errors)
 
       expect(errors).to be_empty
     end
 
-    it 'should reject a present, non-matching hash' do
-      validator.validate(:key, {}, optional({v: 'string'}), errors)
+    it "should reject a present, non-matching hash" do
+      validator.validate(:key, {}, optional({ v: "string" }), errors)
 
       expect(errors).not_to be_empty
-      expect(errors).to eq({ key: {v: 'string required'} })
+      expect(errors).to eq({ key: { v: "string required" } })
     end
   end
 end

data/spec/validators/presence_spec.rb

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

data/spec/validators/regexp_spec.rb

@@ -1,23 +1,25 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Regular expression validator' do
-  describe 'Accepting RegExps in validations' do
-    it 'should accept a regexp' do
+require "spec_helper"
+
+describe "Regular expression validator" do
+  describe "Accepting RegExps in validations" do
+    it "should accept a regexp" do
       validate({}, { foo: // })
     end
   end
 
-  describe '#validate' do
-    let(:validations) {{ string: /^foo$/ }}
+  describe "#validate" do
+    let(:validations) { { string: /^foo$/ } }
 
-    it 'should validate true when the value is foo' do
-      expect(validate({ string: 'foo' }, validations).valid?).to eq true
+    it "should validate true when the value is foo" do
+      expect(validate({ string: "foo" }, validations).valid?).to eq true
     end
 
-    it 'should validate false when the value is not foo' do
-      expect(validate({ string: 'bar' }, validations).valid?).to eq false
-      expect(validate({ string: ' foo' }, validations).valid?).to eq false
-      expect(validate({ string: 'foo ' }, validations).valid?).to eq false
+    it "should validate false when the value is not foo" do
+      expect(validate({ string: "bar" }, validations).valid?).to eq false
+      expect(validate({ string: " foo" }, validations).valid?).to eq false
+      expect(validate({ string: "foo " }, validations).valid?).to eq false
       expect(validate({ string: nil }, validations).valid?).to eq false
       expect(validate({ string: 0 }, validations).valid?).to eq false
       expect(validate({ string: true }, validations).valid?).to eq false

data/spec/validators/simple_spec.rb

@@ -1,33 +1,35 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe HashValidator::Validator::SimpleValidator do
-  describe '#initialize' do
-    it 'accepts blocks with one argument' do
+  describe "#initialize" do
+    it "accepts blocks with one argument" do
       expect {
-        HashValidator::Validator::SimpleValidator.new('name', lambda { |a| true })
+        HashValidator::Validator::SimpleValidator.new("name", lambda { |a| true })
       }.to_not raise_error
     end
 
-    it 'does not accept blocks with no arguments' do
+    it "does not accept blocks with no arguments" do
       expect {
-        HashValidator::Validator::SimpleValidator.new('name', lambda { true })
-      }.to raise_error(StandardError, 'lambda should take only one argument - passed lambda takes 0')
+        HashValidator::Validator::SimpleValidator.new("name", lambda { true })
+      }.to raise_error(StandardError, "lambda should take only one argument - passed lambda takes 0")
     end
 
-    it 'does not accept blocks with two arguments' do
+    it "does not accept blocks with two arguments" do
       expect {
-        HashValidator::Validator::SimpleValidator.new('name', lambda { |a,b| true })
-      }.to raise_error(StandardError, 'lambda should take only one argument - passed lambda takes 2')
+        HashValidator::Validator::SimpleValidator.new("name", lambda { |a, b| true })
+      }.to raise_error(StandardError, "lambda should take only one argument - passed lambda takes 2")
     end
   end
 
-  describe '#validate' do
+  describe "#validate" do
     # Lambda that accepts strings that are 4 characters or shorter
     let(:short_string_lambda)    { lambda { |v| v.is_a?(String) && v.size < 5 } }
-    let(:short_string_validator) { HashValidator::Validator::SimpleValidator.new('short_string', short_string_lambda) }
+    let(:short_string_validator) { HashValidator::Validator::SimpleValidator.new("short_string", short_string_lambda) }
     let(:errors)                 { Hash.new }
 
-    [ '', '1', '12', '123', '1234' ].each do |value|
+    [ "", "1", "12", "123", "1234" ].each do |value|
       it "validates the string '#{value}'" do
         short_string_validator.validate(:key, value, {}, errors)
 
@@ -35,11 +37,11 @@ describe HashValidator::Validator::SimpleValidator do
       end
     end
 
-    [ nil, '12345', '123456', 123, 123456, Time.now, (1..5) ].each do |value|
+    [ nil, "12345", "123456", 123, 123456, Time.now, (1..5) ].each do |value|
       it "does not validate bad value '#{value}'" do
         short_string_validator.validate(:key, value, {}, errors)
 
-        expect(errors).to eq({ key: 'short_string required' })
+        expect(errors).to eq({ key: "short_string required" })
       end
     end
   end