deeply_valid 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Starr Horne
+
+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.rdoc

@@ -0,0 +1,17 @@
+= deeply_valid
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Starr Horne. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "deeply_valid"
+    gem.summary = %Q{Validation for complex data structures}
+    gem.description = %Q{This gem lets you declaratively specify validations for complex data structures, like those returned from an api.}
+    gem.email = "starr@chromahq.com"
+    gem.homepage = "http://github.com/starrhorne/deeply_valid"
+    gem.authors = ["Starr Horne"]
+    gem.add_development_dependency "shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "deeply_valid #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/deeply_valid.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{deeply_valid}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Starr Horne"]
+  s.date = %q{2010-06-06}
+  s.description = %q{This gem lets you declaratively specify validations for complex data structures, like those returned from an api.}
+  s.email = %q{starr@chromahq.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "deeply_valid.gemspec",
+     "lib/deeply_valid.rb",
+     "lib/deeply_valid/base.rb",
+     "lib/deeply_valid/validation.rb",
+     "lib/deeply_valid/validation_helpers.rb",
+     "test/base_test.rb",
+     "test/helper.rb",
+     "test/validation_helpers_test.rb",
+     "test/validation_test.rb"
+  ]
+  s.homepage = %q{http://github.com/starrhorne/deeply_valid}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Validation for complex data structures}
+  s.test_files = [
+    "test/base_test.rb",
+     "test/helper.rb",
+     "test/validation_helpers_test.rb",
+     "test/validation_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+  end
+end
+

data/lib/deeply_valid/base.rb

@@ -0,0 +1,59 @@
+module DeeplyValid
+
+  #
+  # By subclassing the base class, you can easily create 
+  # groups of validations.
+  #
+  # == Example:
+  #
+  #   class Sample < DeeplyValid::Base
+  #     define :regexp,     /[a-z]+/
+  #     define :manual,     DeeplyValid::Validation.new { |d| d > 10 } 
+  #     define :literal,    "x"
+  #     define :structure,  { :key => "val" }
+  #   end
+  #
+  #   Sample[:literal].valid?("x") # will return true
+  #
+  # == Example using ValidationHelpers
+  #
+  #   class Sample < DeeplyValid::Base
+  #     define :name,       string(1..128)
+  #     define :age,        integer(1..70)
+  #     define :children,   hash( token => integer )
+  #     define :colors,     array(any(:red, green, :blue))  
+  #   end
+  #
+  class Base
+
+    include ValidationHelpers
+
+    class << self
+
+      #
+      # Add or create a validation object
+      #
+      # @param [Symbol] name A key that you'll use to retrieve the Validation
+      # @param rule Any validation rule accepted by `DeeplyValid::Validation.new`
+      #
+      def define(name, rule)
+        (@definitions ||= {})[name.to_sym] = rule.is_a?(Validation) ? rule : Validation.new(rule)
+      end
+
+      #
+      # Retrieve a validation object
+      #
+      # @param [Symbol] the key used in `define`
+      # @return [Validation] A validation object
+      #
+      def [](name)
+        (@definitions ||= {})[name.to_sym]
+      end
+
+      def structure(name)
+        Validation.new { |d| self[name.to_sym].valid?(d) }
+      end
+
+    end
+  end
+end

data/lib/deeply_valid/validation.rb

@@ -0,0 +1,101 @@
+module DeeplyValid
+
+  #
+  # The Validation lets us define validations using 
+  # several different kinds of rules.
+  #
+  class Validation
+
+    #
+    # The initializer defines the conditions that will
+    # satasfy this validation.
+    #
+    # @param [Regexp] rule    When `rule` is a `Regexp` we use `=~` to validate
+    # @param [Hash]   rule    When `rule` is a `Hash`, then `valid_structure?` does the validation 
+    # @param [Object] rule    When `rule` is any other non-nil object, use `==` to validate
+    # @param [Proc]   &block  An optional block, which will take one param and return true or false
+    #
+    def initialize(rule = nil, &block)
+
+      if !rule && !block_given?
+        raise "No validation rule specified"
+      end
+
+      @rule = rule
+      @block = block
+    end
+
+    #
+    # Validate data by regexp
+    #
+    # @param [String] String to be validated
+    #
+    def valid_pattern?(data)
+      !!(data =~ @rule)
+    end
+
+    #
+    # Recursively validate a complex data structure
+    # For now, only hashes are supported.
+    #
+    # == Example Rules:
+    #
+    #   { :key => /regexp/ }
+    #   { :key => Validation.new { |d| d > 20 } }
+    #   { :key => "literal" }
+    #   { :key => { :key2 => /regexp/ }, :key2 => "literal" }
+    #
+    # As you see, rules can be nested arbitrarily deep.
+    # The validaions work like you would expect.
+    #
+    #   { :key => /[a-z]+/ } will validate { :key => "a" } 
+    #   { :key => /[a-z]+/ } will NOT validate { :key => 123 } 
+    #
+    # @param [Hash] Hash fragment to be validated
+    # @param [Hash] Optional rules for validating hash fragment
+    # @return true if valid, false if invalid
+    #
+    def valid_structure?(data, fragment_rule = nil)
+      (fragment_rule || @rule).all? do |k, v|
+
+        if v.is_a?(Validation)
+          v.valid?(data[k])
+
+        elsif v.is_a?(Regexp)
+          !!(data[k] =~ v)
+
+        elsif v.is_a?(Hash)
+          valid_structure?(data[k], v)
+
+        else
+          data[k] == v
+        end
+      end
+    end
+
+    #
+    # Validate data of any rule type.
+    #
+    # @param [Object] data the data to be validated
+    # @return true if valid, false if invalid
+    #
+    def valid?(data)
+
+      if @rule.kind_of?(Regexp)
+        valid_pattern?(data)
+
+      elsif @rule.kind_of?(Hash)
+        valid_structure?(data)
+
+      elsif @block
+        @block.call(data)
+
+      else
+        data == @rule
+      end
+
+    end
+
+  end
+
+end

data/lib/deeply_valid/validation_helpers.rb

@@ -0,0 +1,162 @@
+require 'json'
+
+module DeeplyValid
+
+  # 
+  # The ValidationHelpers module provides a number of 'macros'
+  # for creating Validations
+  #
+
+  module ValidationHelpers
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      #
+      # Validates tokens, ie. strings with letters, numbers, and underscores
+      #
+      # @param [Integer, Range] size Optional size limitation
+      # @return [Validation] The validation
+      #
+      def token(size = nil)
+        s = size ? "{#{size.is_a?(Range) ? [size.first, size.last].uniq.join(",") : size}}" : nil 
+        /[0-9a-zA-Z_]#{ s }/
+      end
+
+      #
+      # Validates strings by size
+      #
+      # @param [Integer, Range] size Optional size limitation
+      # @return [Validation] The validation
+      #
+      def string(size = nil)
+        Validation.new { |d| d.is_a?(String) && in_range?(d.size, size) }
+      end
+
+      #
+      # Validates integer with optional limit
+      #
+      # @param [Integer, Range] limit 
+      # @return [Validation] The validation
+      #
+      def integer(limit = nil)
+        Validation.new { |d| d.is_a?(Integer) && in_range?(d, limit) }
+      end
+
+      #
+      # Validate by class
+      #
+      # @param [Class] klass The class
+      # @return [Validation] The validation
+      #
+      def instance_of(klass)
+        Validation.new { |d| d.kind_of?(klass) }
+      end
+
+      #
+      # Validate that a string is valid JSON
+      #
+      # @return [Validation] The validation
+      #
+      def json
+        Validation.new do |d| 
+          begin
+            JSON.parse(d)
+          rescue
+            false
+          else
+            true
+          end
+        end
+      end
+
+      #
+      # Check that any of the specified Validations are met
+      # 
+      # @param [Validation] options One or more Validation instances
+      # @return [Validation] The validation
+      #
+      def any(*options)
+        if options.all? { |v| v.is_a?(Validation) }
+          Validation.new do |d| 
+            options.any? { |v| v.valid?(d) }
+          end
+        else
+          Validation.new do |d| 
+            options.include?(d)
+          end
+        end
+      end
+
+      #
+      # Check that all of the specified Validations are met
+      # 
+      # @param [Validation] options One or more Validation instances
+      # @return [Validation] The validation
+      #
+      def all(*options)
+        Validation.new do |d| 
+          options.all? { |v| v.valid?(d) }
+        end
+      end
+
+      #
+      # Validate all keys / values in a hash
+      #
+      # == Example
+      #
+      # To make sure that all keys are 32 char long tokens,
+      # and all values have a size from 1 to 128 chars, 
+      # do this:
+      #
+      #   hash( token(32) => string(1..128) )
+      # 
+      # @param [Hash] example The desired hash format
+      # @return [Validation] The validation
+      #
+      def hash(example = nil)
+        return instance_of(Hash) unless example
+
+        k_rule, v_rule = example.to_a.first
+
+        k_validation = k_rule.is_a?(Validation) ? k_rule : Validation.new(k_rule)
+        v_validation = v_rule.is_a?(Validation) ? v_rule : Validation.new(v_rule)
+
+        Validation.new do |d| 
+          d.is_a?(Hash) && d.all? { |k, v| k_validation.valid?(k) && v_validation.valid?(v) }
+        end
+      end
+
+      #
+      # Validate all values in an array
+      #
+      # @param [Validation] rule The validation rule
+      # @return [Validation] The validation
+      #
+      def array(rule)
+        return instance_of(Array) unless rule
+
+        validation = rule.is_a?(Validation) ? rule : Validation.new(rule)
+
+        Validation.new do |d| 
+          d.is_a?(Array) && d.all? { |v| validation.valid?(v) }
+        end
+      end
+
+      protected
+
+        #
+        # Determine if a val is included in a range. Handles
+        # range==int and range==nil correctly
+        #
+        def in_range?(val, range)
+          return true unless range
+          range = [range] unless range.respond_to?(:include?)
+          range.include?(val)
+        end
+    end
+  end
+end

data/lib/deeply_valid.rb

@@ -0,0 +1,3 @@
+require "deeply_valid/validation"
+require "deeply_valid/validation_helpers"
+require "deeply_valid/base"

data/test/base_test.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+class BaseTest < Test::Unit::TestCase
+
+  include DeeplyValid
+
+  context "a subclass of Base" do
+    setup do
+      class Sample < DeeplyValid::Base
+        define :self_reference, structure(:regexp)
+        define :regexp, /[a-z]+/
+        define :manual, DeeplyValid::Validation.new { |d| d > 10 } 
+        define :literal, "x"
+        define :hash, { :key => "val" }
+      end
+    end
+
+    [[:regexp, "abc"], [:manual, 11], [:literal, "x"], [:hash, {:key => "val"}]].each do |r, d|
+      should "make #{ r } accessible via []" do
+        assert Sample[r]
+      end
+
+      should "wrap #{ r } in Validation class" do
+        assert Sample[r].is_a?(Validation)
+      end
+
+      should "validate #{ r }" do
+        assert Sample[r].valid?(d)
+      end
+
+    end
+
+    should "Handle self reference" do
+      assert Sample[:self_reference]
+      assert Sample[:self_reference].valid?("abc")
+      assert !Sample[:self_reference].valid?("123")
+    end
+    
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'deeply_valid'
+
+class Test::Unit::TestCase
+  class << self
+
+    def should_validate_all(data)
+      data.each do |d|
+        should "validate #{ d.inspect }" do
+          assert @validation.valid?(d)
+        end
+      end
+    end
+
+
+    def should_not_validate_any(data)
+      data.each do |d|
+        should "not validate #{ d.inspect }" do
+          assert !@validation.valid?(d)
+        end
+      end
+    end
+
+  end
+end

data/test/validation_helpers_test.rb

@@ -0,0 +1,146 @@
+require 'helper'
+
+class ValidationHelpersTest < Test::Unit::TestCase
+
+  include DeeplyValid
+
+  context "a class with validation helpers" do
+
+    setup do
+      class Sample
+        include DeeplyValid::ValidationHelpers
+      end
+    end
+
+    context "token helper" do
+
+      should "return correct regexp when no size specified" do
+        assert Sample.token == /[0-9a-zA-Z_]/
+      end
+
+      should "return correct regexp when exact size specified" do
+        assert Sample.token(32) == /[0-9a-zA-Z_]{32}/
+      end
+
+      should "return correct regexp when range size specified" do
+        assert Sample.token(1..23) == /[0-9a-zA-Z_]{1,23}/
+      end
+
+    end
+
+    context "string helper" do
+
+      should "validate correctly, without size" do
+        assert Sample.string.valid?("asdf")
+      end
+
+      should "validate correctly, with exact size" do
+        assert Sample.string(4).valid?("asdf")
+        assert !Sample.string(4).valid?("a")
+      end
+
+      should "validate correctly, with range size" do
+        assert Sample.string(1..5).valid?("asdf")
+        assert !Sample.string(3..5).valid?("a")
+      end
+
+    end
+
+    context "integer helper" do
+
+      should "validate correctly, without limit" do
+        assert Sample.integer.valid?(123)
+      end
+
+      should "validate correctly, with exact limit" do
+        assert Sample.integer(4).valid?(4)
+        assert !Sample.integer(4).valid?(5)
+      end
+
+      should "validate correctly, with range limit" do
+        assert Sample.integer(1..5).valid?(3)
+        assert !Sample.integer(3..5).valid?(20)
+      end
+
+    end
+
+    context "instance_of helper" do
+
+      should "validate correctly" do
+        assert Sample.instance_of(String).valid?("asdf")
+        assert Sample.instance_of(Array).valid?([1,2,3])
+
+        assert !Sample.instance_of(String).valid?([1,2,3])
+        assert !Sample.instance_of(Array).valid?("asdf")
+      end
+
+    end
+
+
+    context "json helper" do
+
+      should "validate correctly" do
+        assert Sample.json.valid?('{"x": "y"}')
+        assert Sample.json.valid?('{"key": ["y", 1, 2, true, false]}')
+
+        assert !Sample.json.valid?('{"x" "y"}')
+        assert !Sample.json.valid?('{"key": {"y", 1, 2, true, false]}')
+      end
+
+    end
+
+
+    context "any helper" do
+
+      should "validate literals correctly" do
+        assert Sample.any("a", "b", "c").valid?("c")
+        assert Sample.any(1, 2, 3).valid?(2)
+
+        assert !Sample.any("a", "b", "c").valid?("x")
+        assert !Sample.any(1, 2, 3).valid?(20)
+      end
+
+      should "validate correctly using nested validations" do
+        assert Sample.any(Validation.new("a"), Validation.new("b")).valid?("a")
+        assert Sample.any(Validation.new(/[a-z]+/), Validation.new(/[0-9]+/)).valid?("12")
+
+        assert !Sample.any(Validation.new("a"), Validation.new("b")).valid?("abc")
+        assert !Sample.any(Validation.new(/^[a-z]+/), Validation.new(/^[0-9]+/)).valid?("Z12")
+      end
+
+    end
+
+    context "all helper" do
+
+      should "validate correctly" do
+        assert Sample.all(Validation.new(/[a-z]+/), Validation.new(/[0-9]+/)).valid?("ab12")
+        assert !Sample.all(Validation.new(/^[a-z]+/), Validation.new(/^[0-9]+/)).valid?("ab12")
+      end
+
+    end
+
+    context "hash helper" do
+      should "validate correctly" do
+        assert Sample.hash({ (/^[a-z]+$/) => /^[0-9]+$/ }).valid?({ "abc" => "123" })
+        assert Sample.hash({ (/^[a-z]+$/) => Validation.new { |d| d.is_a?(Array) } }).valid?({ "abc" => [] })
+        assert Sample.hash({ (/^[a-z]+$/) => Validation.new { |d| d.is_a?(Array) } }).valid?({ "abc" => [], "cc" => [], "asd" => [] })
+
+        assert !Sample.hash({ (/^[a-z]+$/) => /^[0-9]+$/ }).valid?({ "abc" => 123 })
+        assert !Sample.hash({ (/^[a-z]+$/) => Validation.new { |d| d.is_a?(Array) } }).valid?({ "abc" => {} })
+        assert !Sample.hash({ (/^[a-z]+$/) => Validation.new { |d| d.is_a?(Array) } }).valid?({ "abc" => [], "cde" => 123 })
+      end
+    end
+
+    context "array helper" do
+      should "validate correctly" do
+        assert Sample.array(/^[a-z]+$/).valid?([ "abc", "def", "xyz" ])
+        assert Sample.array(Validation.new { |d| d > 10 }).valid?([ 11, 12, 23 ])
+
+        assert !Sample.array(/^[a-z]+$/).valid?([ "1abc", "def", "xyz" ])
+        assert !Sample.array(Validation.new { |d| d > 10 }).valid?([ 11, 0, 12, 23 ])
+      end
+    end
+    
+  end
+
+end

data/test/validation_test.rb

@@ -0,0 +1,104 @@
+require 'helper'
+
+class ValidationTest < Test::Unit::TestCase
+
+  include DeeplyValid
+
+  context "A regexp validation for alphanumeric strings" do
+
+    setup do
+      @validation = Validation.new(/^[a-zA-Z0-9]*$/)
+    end
+    
+    should_validate_all %w[ abc a91 192 AbC A912D ljasd122 asdDLf9sS ]
+
+    should_not_validate_any %w[ !asdlj s82_s saf.dfd 1u0od#s ]
+    
+  end
+
+  context "A block validation for numbers > 5 and < 20" do
+
+    setup do
+      @validation = Validation.new { |d| d > 5 && d < 20 }
+    end
+    
+    should_validate_all (6..19)
+
+    should_not_validate_any ((0..5).to_a + (20..25).to_a)
+    
+  end
+
+  context "A structure validation for {:key => 'alnum'} using nested validation" do
+    setup do
+      rule = { :key => Validation.new(/^[a-zA-Z0-9]*$/) }
+      @validation = Validation.new(rule)
+    end
+
+    should_validate_all([
+      {:key => "123"},
+      {:key => "1shj23"},
+      {:key => "123KJHjhksj1"},
+      {:key => "12askjfh12aBn3"},
+    ])
+
+    should_not_validate_any([
+      {:key => "12##3"},
+      {:xkey => "1sh  j23"},
+      {:key => "123K_a s@#JHjhksj1"},
+      {:ke => "12askjfh1*)}2aBn3"},
+    ])
+
+  end
+
+  context "A structure validation for {:key => 'alnum'} using regexp" do
+    setup do
+      rule = { :key => /^[a-zA-Z0-9]*$/ }
+      @validation = Validation.new(rule)
+    end
+
+    should_validate_all([
+      {:key => "123"},
+      {:key => "1shj23"},
+      {:key => "123KJHjhksj1"},
+      {:key => "12askjfh12aBn3"},
+    ])
+
+    should_not_validate_any([
+      {:sdkey => "12##3"},
+      {"key" => "1sh  j23"},
+      {:key => "123K_a s@#JHjhksj1"},
+      {:key => "12askjfh1*)}2aBn3"},
+    ])
+
+  end
+
+  context "A nested structure validation for {:token => alnum, :person => { :name => string, :age => int }}" do
+    setup do
+
+      rule = {
+        :token => /^[a-zA-Z0-9]*$/, 
+        :person => { 
+          :name => Validation.new { |d| d.is_a?(String) }, 
+          :age => Validation.new { |d| d.is_a?(Integer) && d > 0 } 
+        }
+      }
+
+      @validation = Validation.new(rule)
+    end
+
+    should_validate_all([
+      {:token => "token234", :person => { :name => "Bob Jones", :age => 22 }},
+      {:token => "tjgkh", :person => { :name => "Bob", :age => 1 }, :extra => true},
+      {:token => "token234", :person => { :name => "", :age => 2002 }},
+    ])
+
+    should_not_validate_any([
+      {:person => { :name => "Bob Jones", :age => 22 }},
+      {:token => "t__jgkh", :person => { :name => "Bob", :age => 0 }},
+      {:token => "token234", :person => { :namex => "", :age => 2002 }},
+      {"token" => "token234", :person => { :name => "", :age => 2002 }},
+    ])
+
+  end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: deeply_valid
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Starr Horne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: This gem lets you declaratively specify validations for complex data structures, like those returned from an api.
+email: starr@chromahq.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- deeply_valid.gemspec
+- lib/deeply_valid.rb
+- lib/deeply_valid/base.rb
+- lib/deeply_valid/validation.rb
+- lib/deeply_valid/validation_helpers.rb
+- test/base_test.rb
+- test/helper.rb
+- test/validation_helpers_test.rb
+- test/validation_test.rb
+has_rdoc: true
+homepage: http://github.com/starrhorne/deeply_valid
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Validation for complex data structures
+test_files: 
+- test/base_test.rb
+- test/helper.rb
+- test/validation_helpers_test.rb
+- test/validation_test.rb