hash_validator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e41604544ea1db1c1d88b8c49c59d7edcc96821
+  data.tar.gz: 5b5f86c50484ffdf9784534ce3e33ccf150fb0bb
+SHA512:
+  metadata.gz: 11f7746ceca1018580e21d7f05a6ceae369339c94cd1f28ad40303e8f68534b5b9355293f96c483dd59ef9bbb2c09aa2a6c97cc764828d73e0ec7150293662ad
+  data.tar.gz: 3d97b917af1eba349ca698cd823dd9e4c53bec687ea82c12315682d2d283ca10bdb53c2230915c645d552d95d65e3d7881ee74ea222b2bfa2392036073cd892c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hash_validator.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 James Brooks
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# 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/git-runner)
+[![Gem Version](https://badge.fury.io/rb/hash_validator.png)](http://badge.fury.io/rb/git-runner)
+[![Dependency Status](https://gemnasium.com/JamesBrooks/hash_validator.png)](https://gemnasium.com/JamesBrooks/git-runner)
+
+Ruby library to validate hashes (Hash) against user-defined requirements
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hash_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hash_validator
+
+## Example
+````
+# Validations hash
+validations = {
+  user: {
+    first_name: 'string',
+    last_name:  'string',
+    age:        'numeric',
+    likes:      'array'
+  }
+}
+
+# Hash to validate
+hash = {
+  foo: 1,
+  bar: 'baz',
+  user: {
+    first_name: 'James',
+    last_name:  12345
+  }
+}
+
+validator = HashValidator.validate(hash, validations)
+
+validator.valid?
+  # => false
+
+validator.errors
+  # {
+      :user => {
+          :last_name => "should be string",
+               :age => "numeric required",
+              :likes => "array required"
+      }
+    }
+````
+
+## Usage
+
+Define a validation hash which will be used to validate. This has can be nested as deeply as required using the following values to validate specific value types:
+
+* `string`
+* `numeric`
+* `array`
+* `time`
+* hashes are validates by nesting validations, or if just the presence of a hash is required `{}` can be used.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/hash_validator.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hash_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hash_validator"
+  spec.version       = HashValidator::VERSION
+  spec.authors       = ["James Brooks"]
+  spec.email         = ["james@gooddogdesign.com"]
+  spec.description   = "Ruby library to validate hashes (Hash) against user-defined requirements"
+  spec.summary       = "Ruby library to validate hashes (Hash) against user-defined requirements"
+  spec.homepage      = "https://github.com/JamesBrooks/hash_validator"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.13.0'
+end

data/lib/hash_validator.rb

@@ -0,0 +1,9 @@
+require 'hash_validator/base'
+require 'hash_validator/version'
+require 'hash_validator/validators'
+
+module HashValidator
+  def self.validate(*args)
+    Base.validate(*args)
+  end
+end

data/lib/hash_validator/base.rb

@@ -0,0 +1,27 @@
+class HashValidator::Base
+  attr_accessor :hash, :validations, :errors
+
+
+  def initialize(hash, validations)
+    self.errors      = {}
+    self.hash        = hash
+    self.validations = validations
+
+    validate
+  end
+
+  def valid?
+    errors.empty?
+  end
+
+  def self.validate(hash, validations)
+    new(hash, validations)
+  end
+
+
+private
+  def validate
+    HashValidator.validator_for(hash).validate(:base, self.hash, self.validations, self.errors)
+    self.errors = errors[:base]
+  end
+end

data/lib/hash_validator/validators.rb

@@ -0,0 +1,20 @@
+module HashValidator
+  @@validators = []
+
+
+  def self.append_validator(validator)
+    @@validators << validator
+  end
+
+  def self.validator_for(rhs)
+    @@validators.detect { |v| v.should_validate?(rhs) } || raise(StandardError.new("Could not find valid validator for: #{rhs}"))
+  end
+
+  module Validator
+  end
+end
+
+# Load validators
+require 'hash_validator/validators/base'
+require 'hash_validator/validators/hash_validator'
+require 'hash_validator/validators/simple_type_validator'

data/lib/hash_validator/validators/base.rb

@@ -0,0 +1,9 @@
+class HashValidator::Validator::Base
+  def should_validate?(name)
+    raise StandardError.new('should_validate? should not be called directly on BaseValidator')
+  end
+
+  def validate(key, value, validations, errors)
+    raise StandardError.new('validate should not be called directly on BaseValidator')
+  end
+end

data/lib/hash_validator/validators/hash_validator.rb

@@ -0,0 +1,38 @@
+class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
+  def name
+    'hash'
+  end
+
+  def should_validate?(rhs)
+    rhs.is_a?(Hash)
+  end
+
+  def validate(key, value, validations, errors)
+    # Validate hash
+    unless value.is_a?(Hash)
+      errors[name] = 'should be hash'
+      return
+    end
+
+    # Hashes can contain sub-elements, attempt to validator those
+    errors = (errors[key] = {})
+
+    validations.each do |v_key, v_value|
+      validator = HashValidator.validator_for(v_value)
+
+      # Key presence
+      unless value[v_key]
+        errors[v_key] = "#{validator.name} required"
+        next
+      end
+
+      validator.validate(v_key, value[v_key], v_value, errors)
+    end
+
+    # Cleanup errors (remove any empty nested errors)
+    errors.delete_if { |k,v| v.empty? }
+  end
+end
+
+
+HashValidator.append_validator(HashValidator::Validator::HashValidator.new)

data/lib/hash_validator/validators/simple_type_validator.rb

@@ -0,0 +1,28 @@
+class HashValidator::Validator::SimpleTypeValidator < HashValidator::Validator::Base
+  attr_accessor :name, :klass
+
+
+  def initialize(name, klass)
+    self.name  = name
+    self.klass = klass
+  end
+
+  def should_validate?(rhs)
+    rhs == self.name
+  end
+
+  def validate(key, value, validations, errors)
+    unless value.is_a?(klass)
+      errors[key] = "should be #{name}"
+    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/lib/hash_validator/version.rb

@@ -0,0 +1,3 @@
+module HashValidator
+  VERSION = '0.0.1'
+end

data/spec/hash_validator_spec.rb

@@ -0,0 +1,149 @@
+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
+    end
+
+    it 'should validate string' do
+      validate({ v: 'test' }, { v: 'string' }).valid?.should be_true
+      validate({ v: 123456 }, { v: 'string' }).valid?.should be_false
+    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
+
+    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 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
+
+  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
+
+    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: 'should be string' })
+      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: 'should be string' })
+      end
+    end
+
+    describe 'nested validations' do
+      let(:validations) {{ foo: 'numeric', bar: 'string', user: { first_name: 'string', age: 'numeric', 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 not validate a complex hash 2' do
+        v = validate(invalid_complex_hash, validations)
+        v.valid?.should be_false
+        v.errors.should eq({ bar: 'should be string', user: { age: 'numeric required', likes: 'should be array' } })
+      end
+    end
+  end
+end

data/spec/hash_validator_spec_helper.rb

@@ -0,0 +1,5 @@
+module HashValidatorSpecHelper
+  def validate(hash, validations)
+    HashValidator.validate(hash, validations)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'hash_validator'
+require 'hash_validator_spec_helper'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.include HashValidatorSpecHelper
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: hash_validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Brooks
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: Ruby library to validate hashes (Hash) against user-defined requirements
+email:
+- james@gooddogdesign.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hash_validator.gemspec
+- lib/hash_validator.rb
+- lib/hash_validator/base.rb
+- lib/hash_validator/validators.rb
+- lib/hash_validator/validators/base.rb
+- lib/hash_validator/validators/hash_validator.rb
+- lib/hash_validator/validators/simple_type_validator.rb
+- lib/hash_validator/version.rb
+- spec/hash_validator_spec.rb
+- spec/hash_validator_spec_helper.rb
+- spec/spec_helper.rb
+homepage: https://github.com/JamesBrooks/hash_validator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Ruby library to validate hashes (Hash) against user-defined requirements
+test_files:
+- spec/hash_validator_spec.rb
+- spec/hash_validator_spec_helper.rb
+- spec/spec_helper.rb