hash_validator 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1db341e997808db63ae406e44a49d51b1ca45287
-  data.tar.gz: b1d8af971d7c0fcdcdfb839bab7aec52092a4fc2
+  metadata.gz: fcfb909853b164442c3070897b294b05aad88a35
+  data.tar.gz: 6168c0b13dac5c47959bd9d8b98edaa82710857a
 SHA512:
-  metadata.gz: 949b8a43860f1ec57f5fd3c23d0f18bb41dabf4615a215f636d6af7cbeb22cf69c78e20646bf6d4836ab38da28aaefe0e1fcd690e0df8867a3215a0b65b6e5a7
-  data.tar.gz: 61e7ca533f2b11c352218104382a8d2b04a1db4ac62f11cd4eefe8daab9c95b4bcf2b8eca5f559a54d7d8d7445ca40b8f632fd6625e4938beb0e8d29360c4fea
+  metadata.gz: ee681f842e79645713cc7775eaf2e4d57cda92a90b52052e34d8a1b92717328a227b09f5c272d633753f3363e47f3cad899c24ffb9751836caf6cda75bdbb99c
+  data.tar.gz: e053babc5e9091973d04680c5a64e5aa11365701cfe1fc3e164a174341f3079bb48e6b9965009e2c58d988fdbb491c674a4f2b5ea28f6b09bf9ba15c0ccb669d

data/README.md

@@ -1,9 +1,9 @@
 # Hash Validator
 
-[![Build Status](https://travis-ci.org/JamesBrooks/hash_validator.png)](https://travis-ci.org/JamesBrooks/hash_validator)
-[![Code Climate](https://codeclimate.com/github/JamesBrooks/hash_validator.png)](https://codeclimate.com/github/JamesBrooks/hash_validator)
 [![Gem Version](https://badge.fury.io/rb/hash_validator.png)](http://badge.fury.io/rb/hash_validator)
+[![Build Status](https://travis-ci.org/JamesBrooks/hash_validator.png)](https://travis-ci.org/JamesBrooks/hash_validator)
 [![Coverage Status](https://coveralls.io/repos/JamesBrooks/hash_validator/badge.png?branch=master)](https://coveralls.io/r/JamesBrooks/hash_validator)
+[![Code Climate](https://codeclimate.com/github/JamesBrooks/hash_validator.png)](https://codeclimate.com/github/JamesBrooks/hash_validator)
 [![Dependency Status](https://gemnasium.com/JamesBrooks/hash_validator.png)](https://gemnasium.com/JamesBrooks/hash_validator)
 
 Ruby library to validate hashes (Hash) against user-defined requirements
@@ -53,7 +53,7 @@ validator.valid?
 validator.errors
   # {
       :user => {
-          :last_name => "should be string",
+          :last_name => "string required",
                 :age => "numeric required",
               :likes => "array required"
       }
@@ -71,8 +71,39 @@ Define a validation hash which will be used to validate. This has can be nested
 * `required`: just requires any value to be present for the designated key.
 * hashes are validates by nesting validations, or if just the presence of a hash is required `{}` can be used.
 
+Additional validations exist to validate beyond simple typing, such as:
+
+* `email`: email address validation (string + email address)
+
 Example use-cases include Ruby APIs (I'm currently using it in a Rails API that I'm building for better error responses to developers).
 
+## Custom validations
+
+Allows custom defined validations (must inherit from `HashValidator::Validator::Base`). Example:
+
+```ruby
+# Define our custom validator
+class HashValidator::Validator::OddValidator < HashValidator::Validator::Base
+  def initialize
+    super('odd')  # The name of the validator
+  end
+
+  def validate(key, value, validations, errors)
+    unless value.is_a?(Integer) && value.odd?
+      errors[key] = presence_error_message
+    end
+  end
+end
+
+# Add the validator
+HashValidator.append_validator(HashValidator::Validator::OddValidator.new)
+
+# Now the validator can be used! e.g.
+validator = HashValidator.validate({ age: 27 }, { age: 'odd' })
+validator.valid?  # => true
+validator.errors  # => {}
+```
+
 ## Contributing
 
 1. Fork it

data/lib/hash_validator/validators.rb

@@ -3,6 +3,14 @@ module HashValidator
 
 
   def self.append_validator(validator)
+    unless validator.is_a?(HashValidator::Validator::Base)
+      raise StandardError.new('validators need to inherit from HashValidator::Validator::Base')
+    end
+
+    if @@validators.detect { |v| v.name == validator.name }
+      raise StandardError.new('validators need to have unique names')
+    end
+
     @@validators << validator
   end
 
@@ -16,6 +24,8 @@ end
 
 # Load validators
 require 'hash_validator/validators/base'
+require 'hash_validator/validators/simple_validator'
 require 'hash_validator/validators/hash_validator'
 require 'hash_validator/validators/presence_validator'
-require 'hash_validator/validators/simple_type_validator'
+require 'hash_validator/validators/simple_type_validators'
+require 'hash_validator/validators/email_validator'

data/lib/hash_validator/validators/base.rb

@@ -1,6 +1,21 @@
 class HashValidator::Validator::Base
+  attr_accessor :name
+
+
+  def initialize(name)
+    unless name.is_a?(String) && name.size > 0
+      raise StandardError.new('Validator must be initialized with a valid name (string with length greater than zero)')
+    end
+
+    self.name = name
+  end
+
   def should_validate?(name)
-    raise StandardError.new('should_validate? should not be called directly on BaseValidator')
+    self.name == name
+  end
+
+  def presence_error_message
+    "#{self.name} required"
   end
 
   def validate(key, value, validations, errors)

data/lib/hash_validator/validators/email_validator.rb

@@ -0,0 +1,17 @@
+class HashValidator::Validator::EmailValidator < HashValidator::Validator::Base
+  def initialize
+    super('email')  # The name of the validator
+  end
+
+  def presence_error_message
+    'is not a valid email'
+  end
+
+  def validate(key, value, validations, errors)
+    unless value.is_a?(String) && value.include?("@")
+      errors[key] = presence_error_message
+    end
+  end
+end
+
+HashValidator.append_validator(HashValidator::Validator::EmailValidator.new)

data/lib/hash_validator/validators/hash_validator.rb

@@ -1,10 +1,6 @@
 class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
-  def name
-    'hash'
-  end
-
-  def presence_error_message
-    "#{name} required"
+  def initialize
+    super('hash')
   end
 
   def should_validate?(rhs)

data/lib/hash_validator/validators/presence_validator.rb

@@ -1,16 +1,12 @@
 class HashValidator::Validator::PresenceValidator < HashValidator::Validator::Base
-  def name
-    'required'
+  def initialize
+    super('required')
   end
 
   def presence_error_message
     'is required'
   end
 
-  def should_validate?(rhs)
-    rhs == name
-  end
-
   def validate(key, value, validations, errors)
     unless value
       errors[key] = presence_error_message
@@ -18,5 +14,4 @@ class HashValidator::Validator::PresenceValidator < HashValidator::Validator::Ba
   end
 end
 
-
 HashValidator.append_validator(HashValidator::Validator::PresenceValidator.new)

data/lib/hash_validator/validators/simple_type_validators.rb

@@ -0,0 +1,8 @@
+[
+  [ 'array',   Array   ],
+  [ 'numeric', Numeric ],
+  [ 'string',  String  ],
+  [ 'time',    Time    ]
+].each do |name, klass|
+  HashValidator.append_validator(HashValidator::Validator::SimpleValidator.new(name, lambda { |v| v.is_a?(klass) }))
+end

data/lib/hash_validator/validators/simple_validator.rb

@@ -0,0 +1,20 @@
+class HashValidator::Validator::SimpleValidator < HashValidator::Validator::Base
+  attr_accessor :lambda
+
+
+  def initialize(name, lambda)
+    # lambda must accept one argument (the value)
+    if lambda.arity != 1
+      raise StandardError.new("lambda should take only one argument - passed lambda takes #{lambda.arity}")
+    end
+
+    super(name)
+    self.lambda = lambda
+  end
+
+  def validate(key, value, validations, errors)
+    unless lambda.call(value)
+      errors[key] = presence_error_message
+    end
+  end
+end

data/lib/hash_validator/version.rb

@@ -1,3 +1,3 @@
 module HashValidator
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

data/spec/hash_validator_spec.rb

@@ -1,166 +1,192 @@
 require 'spec_helper'
 
 describe HashValidator do
-  describe 'individual type validations' do
-    it 'should validate hash' do
-      validate({ v: {} }, { v: {} }).valid?.should be_true
-
-      validate({ v: '' }, { v: {} }).valid?.should be_false
-      validate({ v: '' }, { v: {} }).errors.should eq({ v: 'hash required' })
+  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
+      expect {
+        HashValidator.append_validator(new_validator1)
+      }.to_not raise_error
     end
 
-    it 'should validate presence' do
-      validate({ v: 'test' }, { v: 'required' }).valid?.should be_true
-      validate({ v: 1234   }, { v: 'required' }).valid?.should be_true
-
-      validate({ v: nil    }, { v: 'required' }).valid?.should be_false
-      validate({ v: nil    }, { v: 'required' }).errors.should eq({ v: 'is required' })
-
-      validate({ x: 'test' }, { v: 'required' }).valid?.should be_false
-      validate({ x: 'test' }, { v: 'required' }).errors.should eq({ v: 'is required' })
-
-      validate({ x: 1234   }, { v: 'required' }).valid?.should be_false
-      validate({ x: 1234   }, { v: 'required' }).errors.should eq({ v: 'is required' })
+    it 'does not allow validators with conflicting names' do
+      expect {
+        HashValidator.append_validator(new_validator2)
+        HashValidator.append_validator(new_validator2)
+      }.to raise_error(StandardError, 'validators need to have unique names')
     end
 
-    it 'should validate string' do
-      validate({ v: 'test' }, { v: 'string' }).valid?.should be_true
-
-      validate({ v: 123456 }, { v: 'string' }).valid?.should be_false
-      validate({ v: 123456 }, { v: 'string' }).errors.should eq({ v: 'string required' })
+    it 'does not allow validators that do not inherit from the base validator class' do
+      expect {
+        HashValidator.append_validator('Not a validator')
+      }.to raise_error(StandardError, 'validators need to inherit from HashValidator::Validator::Base')
     end
+  end
 
-    it 'should validate numeric' do
-      validate({ v: 1234 }, { v: 'numeric' }).valid?.should be_true
-      validate({ v: '12' }, { v: 'numeric' }).valid?.should be_false
-    end
+  describe '#validate' do
+    describe 'individual type validations' do
+      it 'should validate hash' do
+        validate({ v: {} }, { v: {} }).valid?.should be_true
 
-    it 'should validate array' do
-      validate({ v: [ 1,2,3 ] }, { v: 'array' }).valid?.should be_true
-      validate({ v: ' 1,2,3 ' }, { v: 'array' }).valid?.should be_false
-    end
+        validate({ v: '' }, { v: {} }).valid?.should be_false
+        validate({ v: '' }, { v: {} }).errors.should eq({ v: 'hash required' })
+      end
 
-    it 'should validate time' do
-      validate({ v: Time.now                    }, { v: 'time' }).valid?.should be_true
-      validate({ v: '2013-04-12 13:18:05 +0930' }, { v: 'time' }).valid?.should be_false
-    end
-  end
+      it 'should validate presence' do
+        validate({ v: 'test' }, { v: 'required' }).valid?.should be_true
+        validate({ v: 1234   }, { v: 'required' }).valid?.should be_true
 
-  describe 'full validations' do
-    let(:empty_hash) {{}}
-
-    let(:simple_hash) {{
-      foo: 1,
-      bar: 'baz'
-    }}
-
-    let(:invalid_simple_hash) {{
-      foo: 1,
-      bar: 2
-    }}
-
-    let(:complex_hash) {{
-      foo: 1,
-      bar: 'baz',
-      user: {
-        first_name: 'James',
-        last_name:  'Brooks',
-        age:        27,
-        likes:      [ 'Ruby', 'Kendo', 'Board Games' ]
-      }
-    }}
-
-    let(:invalid_complex_hash) {{
-      foo: 1,
-      bar: 2,
-      user: {
-        first_name: 'James',
-        last_name:  'Brooks',
-        likes:      'Ruby, Kendo, Board Games'
-      }
-    }}
-
-    describe 'no validations' do
-      let(:validations) {{}}
-
-      it 'should validate an empty hash' do
-        v = validate(empty_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
-      end
+        validate({ v: nil    }, { v: 'required' }).valid?.should be_false
+        validate({ v: nil    }, { v: 'required' }).errors.should eq({ v: 'is required' })
 
-      it 'should validate a simple hash' do
-        v = validate(simple_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
-      end
+        validate({ x: 'test' }, { v: 'required' }).valid?.should be_false
+        validate({ x: 'test' }, { v: 'required' }).errors.should eq({ v: 'is required' })
 
-      it 'should validate a simple hash 2' do
-        v = validate(invalid_simple_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
+        validate({ x: 1234   }, { v: 'required' }).valid?.should be_false
+        validate({ x: 1234   }, { v: 'required' }).errors.should eq({ v: 'is required' })
       end
 
-      it 'should validate a complex hash' do
-        v = validate(complex_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
-      end
+      it 'should validate string' do
+        validate({ v: 'test' }, { v: 'string' }).valid?.should be_true
 
-      it 'should validate a complex hash 2' do
-        v = validate(invalid_complex_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
+        validate({ v: 123456 }, { v: 'string' }).valid?.should be_false
+        validate({ v: 123456 }, { v: 'string' }).errors.should eq({ v: 'string required' })
       end
-    end
 
-    describe 'simple validations' do
-      let(:validations) {{ foo: 'numeric', bar: 'string' }}
-
-      it 'should not validate an empty hash (stating missing with required)' do
-        v = validate(empty_hash, validations)
-        v.valid?.should be_false
-        v.errors.should eq({ foo: 'numeric required', bar: 'string required' })
+      it 'should validate numeric' do
+        validate({ v: 1234 }, { v: 'numeric' }).valid?.should be_true
+        validate({ v: '12' }, { v: 'numeric' }).valid?.should be_false
       end
 
-      it 'should validate a simple hash' do
-        v = validate(simple_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
+      it 'should validate array' do
+        validate({ v: [ 1,2,3 ] }, { v: 'array' }).valid?.should be_true
+        validate({ v: ' 1,2,3 ' }, { v: 'array' }).valid?.should be_false
       end
 
-      it 'should not validate a simple hash 2' do
-        v = validate(invalid_simple_hash, validations)
-        v.valid?.should be_false
-        v.errors.should eq({ bar: 'string required' })
+      it 'should validate time' do
+        validate({ v: Time.now                    }, { v: 'time' }).valid?.should be_true
+        validate({ v: '2013-04-12 13:18:05 +0930' }, { v: 'time' }).valid?.should be_false
       end
+    end
 
-      it 'should validate a complex hash' do
-        v = validate(complex_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
+    describe 'full validations' do
+      let(:empty_hash) {{}}
+
+      let(:simple_hash) {{
+        foo: 1,
+        bar: 'baz'
+      }}
+
+      let(:invalid_simple_hash) {{
+        foo: 1,
+        bar: 2
+      }}
+
+      let(:complex_hash) {{
+        foo: 1,
+        bar: 'baz',
+        user: {
+          first_name: 'James',
+          last_name:  'Brooks',
+          age:        27,
+          likes:      [ 'Ruby', 'Kendo', 'Board Games' ]
+        }
+      }}
+
+      let(:invalid_complex_hash) {{
+        foo: 1,
+        bar: 2,
+        user: {
+          first_name: 'James',
+          last_name:  'Brooks',
+          likes:      'Ruby, Kendo, Board Games'
+        }
+      }}
+
+      describe 'no validations' do
+        let(:validations) {{}}
+
+        it 'should validate an empty hash' do
+          v = validate(empty_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should validate a simple hash' do
+          v = validate(simple_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should validate a simple hash 2' do
+          v = validate(invalid_simple_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should validate a complex hash' do
+          v = validate(complex_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should validate a complex hash 2' do
+          v = validate(invalid_complex_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
       end
 
-      it 'should not validate a complex hash 2' do
-        v = validate(invalid_complex_hash, validations)
-        v.valid?.should be_false
-        v.errors.should eq({ bar: 'string required' })
+      describe 'simple validations' do
+        let(:validations) {{ foo: 'numeric', bar: 'string' }}
+
+        it 'should not validate an empty hash (stating missing with required)' do
+          v = validate(empty_hash, validations)
+          v.valid?.should be_false
+          v.errors.should eq({ foo: 'numeric required', bar: 'string required' })
+        end
+
+        it 'should validate a simple hash' do
+          v = validate(simple_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should not validate a simple hash 2' do
+          v = validate(invalid_simple_hash, validations)
+          v.valid?.should be_false
+          v.errors.should eq({ bar: 'string required' })
+        end
+
+        it 'should validate a complex hash' do
+          v = validate(complex_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
+
+        it 'should not validate a complex hash 2' do
+          v = validate(invalid_complex_hash, validations)
+          v.valid?.should be_false
+          v.errors.should eq({ bar: 'string required' })
+        end
       end
-    end
 
-    describe 'nested validations' do
-      let(:validations) {{ foo: 'numeric', bar: 'string', user: { first_name: 'string', age: 'required', likes: 'array' } }}
+      describe 'nested validations' do
+        let(:validations) {{ foo: 'numeric', bar: 'string', user: { first_name: 'string', age: 'required', likes: 'array' } }}
 
-      it 'should validate a complex hash' do
-        v = validate(complex_hash, validations)
-        v.valid?.should be_true
-        v.errors.should be_empty
-      end
+        it 'should validate a complex hash' do
+          v = validate(complex_hash, validations)
+          v.valid?.should be_true
+          v.errors.should be_empty
+        end
 
-      it 'should not validate a complex hash 2' do
-        v = validate(invalid_complex_hash, validations)
-        v.valid?.should be_false
-        v.errors.should eq({ bar: 'string required', user: { age: 'is required', likes: 'array required' } })
+        it 'should not validate a complex hash 2' do
+          v = validate(invalid_complex_hash, validations)
+          v.valid?.should be_false
+          v.errors.should eq({ bar: 'string required', user: { age: 'is required', likes: 'array required' } })
+        end
       end
     end
   end

data/spec/validators/base_spec.rb

@@ -1,16 +1,23 @@
 require 'spec_helper'
 
 describe HashValidator::Validator::Base do
-  let(:validator) { HashValidator::Validator::Base.new }
+  let(:name) { 'my_validator' }
 
-  describe '#should_validate?' do
-    it 'throws an exception' do
-      expect { validator.should_validate?('name') }.to raise_error(StandardError, 'should_validate? should not be called directly on BaseValidator')
-    end
+
+  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 (string with length greater than zero)')
+    expect { HashValidator::Validator::Base.new(123) }.to raise_error(StandardError, 'Validator must be initialized with a valid name (string with length greater than zero)')
+    expect { HashValidator::Validator::Base.new('')  }.to raise_error(StandardError, 'Validator must be initialized with a valid name (string with length greater than zero)')
   end
 
   describe '#validate' do
-    it 'throws an exception' do
+    let(:validator) { HashValidator::Validator::Base.new('test') }
+
+    it 'throws an exception as base validators cant actually validate' do
       expect { validator.validate('key', 'value', {}, {}) }.to raise_error(StandardError, 'validate should not be called directly on BaseValidator')
     end
   end

data/spec/validators/email_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::Base do
+  let(:validator) { HashValidator::Validator::EmailValidator.new }
+  let(:errors)    { Hash.new }
+
+  describe '#should_validate?' do
+    it 'should validate the name "email"' do
+      validator.should_validate?('email').should be_true
+    end
+
+    it 'should not validate other names' do
+      validator.should_validate?('string').should be_false
+      validator.should_validate?('array').should  be_false
+      validator.should_validate?(nil).should      be_false
+    end
+  end
+
+  describe '#validate' do
+    it 'should validate an email with true' do
+      validator.validate(:key, "johndoe@gmail.com", {}, errors)
+
+      errors.should be_empty
+    end
+
+    it 'should validate a string without an @ symbol with false' do
+      validator.validate(:key, 'test', {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'is not a valid email' })
+    end
+
+    it 'should validate a number with false' do
+      validator.validate(:key, 123, {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'is not a valid email' })
+    end
+  end
+end

data/spec/validators/simple_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::SimpleValidator do
+  describe '#initialize' do
+    it 'accepts blocks with one argument' do
+      expect {
+        HashValidator::Validator::SimpleValidator.new('name', lambda { |a| true })
+      }.to_not raise_error
+    end
+
+    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')
+    end
+
+    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')
+    end
+  end
+
+  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(:errors)                 { Hash.new }
+
+    [ '', '1', '12', '123', '1234' ].each do |value|
+      it "validates the string '#{value}'" do
+        short_string_validator.validate(:key, value, {}, errors)
+
+        errors.should be_empty
+      end
+    end
+
+    [ 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)
+
+        errors.should eq({ key: 'short_string required' })
+      end
+    end
+  end
+end

data/spec/validators/simple_types_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'Simple validator types' do
+  let(:errors) { Hash.new }
+
+  # Simple types
+  {
+    string: {
+      valid:   [ '', 'Hello World', '12345' ],
+      invalid: [ nil, 12345, Time.now ]
+    },
+    numeric: {
+      valid:   [ 0, 123, 123.45 ],
+      invalid: [ nil, '', '123', Time.now ]
+    },
+    array: {
+      valid:   [ [], [1], ['foo'], [1,['foo'],Time.now] ],
+      invalid: [ nil, '', 123, '123', Time.now, '[1]' ]
+    },
+    time: {
+      valid:   [ Time.now ],
+      invalid: [ nil, '', 123, '123', "#{Time.now}" ]
+    }
+  }.each do |type, data|
+    describe type do
+      data[:valid].each do |value|
+        it "validates '#{value}' successful" do
+          validator = HashValidator.validate({ v: value }, { v: type.to_s })
+
+          validator.valid?.should be_true
+          validator.errors.should be_empty
+        end
+      end
+
+      data[:invalid].each do |value|
+        it "validates '#{value}' with failure" do
+          validator = HashValidator.validate({ v: value }, { v: type.to_s })
+
+          validator.valid?.should be_false
+          validator.errors.should eq({ v: "#{type} required" })
+        end
+      end
+    end
+  end
+end

data/spec/validators/user_defined_spec.rb

@@ -0,0 +1,95 @@
+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')
+        end
+
+        def validate(key, value, validations, errors)
+          unless value.is_a?(Integer) && value.odd?
+            errors[key] = presence_error_message
+          end
+        end
+      end
+    end
+
+    HashValidator::Validator::OddValidator.new
+  end
+
+  let(:errors) { Hash.new }
+
+
+  describe '#should_validate?' do
+    it 'validates the name "odd"' do
+      validator.should_validate?('odd').should be_true
+    end
+
+    it 'does not validate other names' do
+      validator.should_validate?('string').should be_false
+      validator.should_validate?('array').should  be_false
+      validator.should_validate?(nil).should      be_false
+    end
+  end
+
+  describe '#validate' do
+    it 'validates odd integers with true' do
+      validator.validate(:key, 1, {}, errors)
+
+      errors.should be_empty
+    end
+
+    it 'validates even integers with errrors' do
+      validator.validate(:key, 2, {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'odd required' })
+    end
+
+    it 'validates even floats with errrors' do
+      validator.validate(:key, 2.0, {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'odd required' })
+    end
+
+    it 'validates odd floats with errrors' do
+      validator.validate(:key, 1.0, {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'odd required' })
+    end
+
+    it 'validates an odd integer string with errrors' do
+      validator.validate(:key, '1', {}, errors)
+
+      errors.should_not be_empty
+      errors.should eq({ key: 'odd required' })
+    end
+  end
+
+  describe 'Integrating with the entire validation system' do
+    before { HashValidator.append_validator(validator) rescue nil }  # rescue to prevent: validators need to have unique names
+
+    it 'can be looked up using #validator_for' do
+      HashValidator.validator_for('odd').should be_a_kind_of(HashValidator::Validator::OddValidator)
+    end
+
+    it 'can be used in validations - test 1' do
+      validator = HashValidator.validate({ age: 27 }, { age: 'odd' })
+
+      validator.valid?.should be_true
+      validator.errors.should be_empty
+    end
+
+    it 'can be used in validations - test 2' do
+      validator = HashValidator.validate({ age: 40 }, { age: 'odd' })
+
+      validator.valid?.should be_false
+      validator.errors.should 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: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - James Brooks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-17 00:00:00.000000000 Z
+date: 2013-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,16 +85,21 @@ files:
 - lib/hash_validator/base.rb
 - lib/hash_validator/validators.rb
 - lib/hash_validator/validators/base.rb
+- lib/hash_validator/validators/email_validator.rb
 - lib/hash_validator/validators/hash_validator.rb
 - lib/hash_validator/validators/presence_validator.rb
-- lib/hash_validator/validators/simple_type_validator.rb
+- lib/hash_validator/validators/simple_type_validators.rb
+- lib/hash_validator/validators/simple_validator.rb
 - lib/hash_validator/version.rb
 - spec/hash_validator_spec.rb
 - spec/hash_validator_spec_helper.rb
 - spec/spec_helper.rb
 - spec/validators/base_spec.rb
+- spec/validators/email_spec.rb
 - spec/validators/presence_spec.rb
-- spec/validators/simple_type_spec.rb
+- spec/validators/simple_spec.rb
+- spec/validators/simple_types_spec.rb
+- spec/validators/user_defined_spec.rb
 homepage: https://github.com/JamesBrooks/hash_validator
 licenses:
 - MIT
@@ -124,5 +129,8 @@ test_files:
 - spec/hash_validator_spec_helper.rb
 - spec/spec_helper.rb
 - spec/validators/base_spec.rb
+- spec/validators/email_spec.rb
 - spec/validators/presence_spec.rb
-- spec/validators/simple_type_spec.rb
+- spec/validators/simple_spec.rb
+- spec/validators/simple_types_spec.rb
+- spec/validators/user_defined_spec.rb

data/lib/hash_validator/validators/simple_type_validator.rb

@@ -1,32 +0,0 @@
-class HashValidator::Validator::SimpleTypeValidator < HashValidator::Validator::Base
-  attr_accessor :name, :klass
-
-
-  def initialize(name, klass)
-    self.name  = name
-    self.klass = klass
-  end
-
-  def presence_error_message
-    "#{name} required"
-  end
-
-  def should_validate?(rhs)
-    rhs == self.name
-  end
-
-  def validate(key, value, validations, errors)
-    unless value.is_a?(klass)
-      errors[key] = presence_error_message
-    end
-  end
-end
-
-
-# Create simple type validators
-[
-  [ 'array',   Array   ],
-  [ 'numeric', Numeric ],
-  [ 'string',  String  ],
-  [ 'time',    Time    ]
-].each { |name, klass| HashValidator.append_validator(HashValidator::Validator::SimpleTypeValidator.new(name, klass)) }

data/spec/validators/simple_type_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe HashValidator::Validator::Base do
-  let(:my_class)  { Class.new }
-  let(:validator) { HashValidator::Validator::SimpleTypeValidator.new('my_class', my_class) }
-  let(:errors)    { Hash.new }
-
-  describe '#should_validate?' do
-    it 'should validate the name "my_class"' do
-      validator.should_validate?('my_class').should be_true
-    end
-
-    it 'should not validate other names' do
-      validator.should_validate?('string').should be_false
-      validator.should_validate?('array').should  be_false
-      validator.should_validate?(nil).should      be_false
-    end
-  end
-
-  describe '#validate' do
-    it 'should validate the my_class class with true' do
-      validator.validate(:key, my_class.new, {}, errors)
-
-      errors.should be_empty
-    end
-
-    it 'should validate other classes with errrors' do
-      validator.validate(:key, "foo bar", {}, errors)
-
-      errors.should_not be_empty
-      errors.should eq({ key: 'my_class required' })
-    end
-  end
-end