ratatouille 0.1.0

data/.gitignore

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.8.7@ratatouille

data/.travis-yml

@@ -0,0 +1,8 @@
+script: "rake"
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby

data/.yardopts

@@ -0,0 +1 @@
+'lib/**/*.rb' - '*.md'

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ryan Johnson
+
+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,249 @@
+# Ratatouille [![Build Status](http://travis-ci.org/CITguy/ratatouille.png)](http://travis-ci.org/CITguy/ratatouille)
+
+DSL for validation of complex Hashes
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ratatouille'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ratatouille
+
+
+
+## Blocks
+
+All of the given methods accept a block for validation and will not progress into the block if the core method logic does not validate.
+However, some methods may be used without a block and validation will progress whether or not the method logic validates.
+
+
+### ratifiable\_object
+
+Within a block, the ratifiable\_object method provides the object that is to be validated against.
+This will change when using *given\_key*.
+
+
+
+## Usage
+
+All of the following methods perform validation on the *ratifiable\_object* defined in scope of the block.
+
+
+### given\_key
+
+This method is used to scope its given block to the key value. Useful to reduce the need to explicitly namespace nested keys in *ratifiable\_object*.
+
+* **This method doesn't perform any validation and must be used with a block to get any use out of it.**
+* Changes *ratifiable\_object* to *key value* (original scope will return on block exit)
+
+
+#### Syntax
+
+```ruby
+    given_key(:foo) do
+      # validation for ratifiable_object[:foo]
+    end
+```
+
+#### Example
+
+See **choice\_of** for an example.
+
+
+### choice\_of
+
+Meant to be used to validate that X number of given key choices exist in the Hash. 
+
+* Number of Choices must be less than size of key choice array
+* Can be used without a block
+* Works well with **given\_key()**.
+
+
+#### Syntax
+
+```ruby
+    choice_of(number_of_choices, key_choice_array) do
+      # Validation provided number of choices is satisfied
+    end
+```
+
+
+#### Example
+
+```ruby
+    r = ratify({:foo => "bar", :bar => "biz"}) do
+      choice_of(1, :foo, :bar) do
+        # Validation, provided :foo OR :bar exists
+      end
+    end
+    r.valid? #=> false (:foo OR :bar must be defined, NOT BOTH)
+
+    r = ratify({:foo => "bar", :bar => "biz"}) do
+      choice_of(2, :foo, :bar, :biz) do
+        # Validation, provided 2 of the following exist: :foo, :bar, :biz
+
+        given_key(:foo) do
+          # in context of ratifiable_object[:foo]
+        end
+
+        given_key(:bar) do
+          # in context of ratifiable_object[:bar]
+        end
+      end
+    end
+    r.valid? #=> true (a choice of 2 items from [:foo, :bar, :biz] is satisfied)
+
+    r = ratify({:foo => "bar", :bar => "biz"}) do
+      choice_of(2, :foo, :bar) do
+        # Validation ...
+      end
+    end
+    r.valid? #=> false (you might as well use required_keys)
+```
+
+
+### required\_keys
+
+Used to ensure that the list of keys exist in the Hash.
+
+* Block is optional
+
+
+#### Syntax
+
+```ruby
+    # Validate that the keys exist and perform validation if they do
+    required_keys(:foo, :bar) do
+      # Validation provided that :foo and :bar exist
+    end
+
+    # Validate that the keys exist
+    required_keys(:foo, :bar)
+```
+
+
+#### Example
+
+```ruby
+    r = ratify({:foo => "bar", :bar => "biz"}) do
+      required_keys(:foo, :bar)
+    end
+    r.valid? #=> true
+
+    r = ratify({:foo => "bar"}) do
+      required_keys(:foo, :bar)
+    end
+    r.valid? #=> false
+```
+
+
+
+### is\_empty
+
+* Self-explanatory
+* Block is optional
+
+```ruby
+    r = ratify({:foo => "bar"}) do
+      is_empty # validation continues
+      is_empty do
+        # validation in block is never performed
+      end
+    end
+    r.valid? #=> false
+
+    r = ratify({}) do
+      is_empty # validation continues even if not empty
+      is_empty do
+        # validation continues only if ratifiable_object is empty
+      end
+    end
+    r.valid? #=> true
+```
+
+
+### is\_not\_empty
+
+* Self-explanatory
+* Block is optional
+
+```ruby
+    r = ratify({:foo => "bar"}) do
+      is_not_empty # validation continues even if empty
+      is_not_empty do
+        # validation continues unless ratifiable_object is empty
+      end
+    end
+    r.valid? #=> true
+
+    r = ratify({}) do
+      is_not_empty # validation continues
+      is_not_empty do
+        # validation in block is never performed
+      end
+    end
+    r.valid? #=> false
+```
+
+
+
+## Custom Validation
+
+**Return to this section after reading the remaining sections.**
+
+Custom validation can take place using the following methods to generate custom validation logic that cannot be satisfied with the existing methods.
+
+You should use the **validation\_error** method to add your own errors to the Ratifier object.
+
+
+### validation\_error
+
+Used to insert validation error message into the Ratifier object.
+
+
+#### Syntax
+
+It is also possible to set the context of an error by passing in a second argument. However, it defaults to the root of the current ratifiable\_object ('/').
+
+```ruby
+    validation_error("This is an error")
+    validation_error("This is an error", "current_context")
+```
+
+
+
+## Advanced Example
+
+```ruby
+    include Ratatouille
+    r = ratify({:foo => {:bar => {:biz => "bang"}}}) do
+      is_not_empty
+      given_key(:foo) do
+        validation_error(":foo error")
+        given_key(:bar) do
+          validation_error(":bar error")
+          given_key(:biz) do
+            if ratifiable_object == "bang"
+              validation_error("should be 'shoot'")
+            end
+          end
+        end
+      end
+    end
+    r.valid? # => false
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-c)
+end
+
+task :default => :spec
+task :test => :spec

data/lib/ratatouille/array.rb

@@ -0,0 +1,120 @@
+module Ratatouille
+
+  # Module used to provide Array-specific validation methods
+  module ArrayMethods
+    # @return [void]
+    def is_empty(&block)
+      unless @ratifiable_object.empty?
+        validation_error("Array is not empty")  
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#is_empty
+
+
+    # @return [void]
+    def is_not_empty(&block)
+      if @ratifiable_object.empty?
+        validation_error("Array is empty")
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#is_not_empty
+
+
+    # Define Minimum Length of Array
+    # 
+    # @param [Integer] min_size
+    # @return [void]
+    def min_length(min_size=0, &block)
+      return unless valid_min_length?(min_size)
+
+      instance_eval(&block) if block_given?
+    rescue Exception => e
+      validation_error("#{e.message}")
+    end#min_length
+
+
+    # Define Maximum Length of Array
+    #
+    # @param [Integer] min_size
+    # @return [void]
+    def max_length(max_size=0, &block)
+      return unless valid_max_length?(max_size)
+
+      instance_eval(&block) if block_given?
+    rescue Exception => e
+      validation_error("#{e.message}")
+    end#max_length
+
+
+    # Define length range of Array (inclusive)
+    #
+    # @param [Integer] min_size
+    # @param [Integer] max_size
+    # @return [void]
+    def length_between(min_size=0, max_size=nil, &block)
+      return unless valid_min_length?(min_size)
+
+      if max_size.nil?
+        if min_size == 1
+          validation_error("Consider using is_not_empty")
+          return
+        end
+      else
+        return unless valid_max_length?(max_size)
+
+        if max_size == 0 && min_size == 0
+          validation_error("Consider using is_empty")
+          return
+        end
+
+        unless max_size > min_size
+          validation_error("max_size must be greater than min_size")
+          return
+        end
+      end
+
+      instance_eval(&block) if block_given?
+    end#length_between
+  private
+
+    # @return [Boolean]
+    def valid_min_length?(min_size)
+      unless min_size.to_i >= 0
+        validation_error("min_length must be a number greater than or equal to 0")
+        return false
+      end
+
+      unless @ratifiable_object.size >= min_size.to_i
+        validation_error("Array length must be #{min_size} or more") 
+        return false
+      end
+      return true
+    rescue Exception => e
+      validation_error("#{e.message}")
+      return false
+    end
+
+    # @return [Boolean]
+    def valid_max_length?(max_size)
+      unless max_size.to_i >= 0
+        validation_error("max_size must be a number greater than or equal to 0")
+        return false
+      end
+
+      if @ratifiable_object.size > max_size.to_i
+        validation_error("Array length must be less than #{max_size.to_i}")
+        return false
+      end
+
+      return true
+    rescue Exception => e
+      validation_error("#{e.message}")
+      return false
+    end
+  end#ArrayMethods
+
+end

data/lib/ratatouille/hash.rb

@@ -0,0 +1,108 @@
+module Ratatouille
+
+  # Module used to provide Hash-specific validation methods
+  module HashMethods
+    # Runs validation in block against object for the given key.
+    #
+    # @param [String, Symbol] key
+    def given_key(key, &block)
+      if @ratifiable_object.has_key?(key) && block_given?
+        child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], &block)
+        @errors[key] = child_object.errors unless child_object.valid?
+      end
+    end#given_key
+
+
+    # @return [void]
+    def is_empty(&block)
+      unless @ratifiable_object.empty?
+        validation_error("Hash is not empty")  
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#is_empty
+
+
+    # @return [void]
+    def is_not_empty(&block)
+      if @ratifiable_object.empty?
+        validation_error("Hash is empty")      
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#is_not_empty
+
+
+    # Provide a list of keys that must be present in the Hash to validate. Otherwise,
+    # an error will be added.
+    #
+    # @param [Array] args Array required keys
+    # @return [void]
+    def required_keys(*req_keys, &block)
+      common_keys = (@ratifiable_object.keys & req_keys)
+
+      if @ratifiable_object.empty?
+        validation_error("Cannot find required keys in empty hash.")
+        return
+      end
+
+      if req_keys.nil? || req_keys.empty?
+        validation_error("No required keys given to compare Hash against.")
+        return
+      end
+
+      unless common_keys.size == req_keys.size
+        (req_keys - common_keys).each do |missed| 
+          case missed
+          when Symbol then validation_error("Missing :#{missed}")
+          when String then validation_error("Missing #{missed}")
+          when respond_to?(:to_s)
+            validation_error("Missing #{missed.to_s}")
+          end
+        end
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#required_keys
+
+
+    # Provide a list of keys to choose from and a choice size (default 1). 
+    # When the Hash does not contain at least 'choice_size' keys of the key 
+    # list provided, an error will be added.
+    #
+    # @param [Integer] choice_size
+    # @param [Array] args 
+    #   Array of symbols and/or strings to denote the choices of keys.
+    #   All other values are ignored.
+    # @return [void]
+    def choice_of(choice_size=1, *key_list, &block)
+      unless key_list.nil? || key_list.empty?
+        validation_error("choice_of requires a key list to choose from")
+        return
+      end
+
+      unless choice_size =~ /\d+/ && choice_size > 0
+        validation_error("choice_of requires a positive integer for choice size")
+        return
+      end
+
+      unless key_list.size > choice_size
+        validation_error("Key list size for 'choice_of' should be larger than choice size. Consider using required_keys instead.")
+        return
+      end
+      
+      common_keys = (@ratifiable_object.keys & key_list)
+      unless common_keys.size == choice_size
+        choices = key_list.collect{|a| String === a || Symbol === a}
+        validation_error("Require #{choice_size} of the following: #{choices.join(', ')}")
+        return
+      end
+
+      instance_eval(&block) if block_given?
+    end#choice_of
+  end#HashMethods
+
+end

data/lib/ratatouille/nilclass.rb

@@ -0,0 +1,6 @@
+# MonkeyPatch NilClass to return true for empty?
+class NilClass
+  def empty?
+    return true
+  end
+end

data/lib/ratatouille/ratifier.rb

@@ -0,0 +1,98 @@
+module Ratatouille
+
+  # Ratifier  acts as a clean room in which to perform validations.
+  class Ratifier
+    attr_reader :errors
+    attr_reader :ratifiable_object
+
+    # A new instance of Ratifier
+    # @param [Hash, Array] obj Object to validate
+    def initialize(obj, options={}, &block)
+      @errors = { "/" => [] }
+      @ratifiable_object = obj
+
+      case obj
+      when Hash  then extend Ratatouille::HashMethods
+      when Array then extend Ratatouille::ArrayMethods
+      end
+
+      instance_eval( &block ) if block_given?
+
+      cleanup_errors
+
+      @errors.freeze
+    end#initialize
+
+
+    # Add validation error. Useful for custom validations.
+    # @param [String] str
+    # @param [String] context
+    # @return [void]
+    def validation_error(err_in, context="/")
+      case err_in
+      when String
+        return if err_in.blank?
+        @errors[context] = [] unless @errors[context]
+        @errors[context] << err_in
+      end
+    rescue Exception => e
+      @errors["/"] << e.message
+    end#validation_error
+
+
+    # Does the object pass all validation logic?
+    #
+    # @return [Boolean]
+    def valid?
+      @errors.empty?
+    end#valid?
+
+
+    # If there are no errors in the errors hash, empty it out.
+    #
+    # @return [void]
+    def cleanup_errors 
+      @errors = {} if errors_array.empty?
+    rescue Exception => e
+      @errors["/"] << e.message
+    end#cleanup_errors
+
+
+    # @param [Hash] hsh Hash to act upon.
+    # @return [Array]
+    def errors_array(hsh = @errors)
+      return [] unless Hash === hsh
+      all_errs = []
+
+      hsh.each_pair do |k,v|
+        pair_errs = case v
+        when Hash then errors_array(v)
+        when Array then v
+        else []
+        end
+
+        nsed_errs = pair_errs.collect do |e|
+          split_err = e.split("|")
+
+          ctxt, err = "", e
+          ctxt, err = split_err if split_err.size == 2
+
+          case k
+          when String  
+            ctxt = "#{k}#{ctxt}" unless k == '/'
+          when Symbol 
+            ctxt = ":#{k}#{ctxt}"
+          end
+
+          "/#{ctxt}|#{err}"
+        end
+
+        all_errs << nsed_errs
+        all_errs.flatten!
+      end
+
+      return all_errs
+    end#errors_array
+  end#Ratifier
+
+end

data/lib/ratatouille/string.rb

@@ -0,0 +1,6 @@
+# Monkey Patch String class
+class String
+  def blank?
+    return self.chomp.empty?
+  end
+end

data/lib/ratatouille/version.rb

@@ -0,0 +1,4 @@
+module Ratatouille
+  # Gem Version
+  VERSION = "0.1.0"
+end

data/lib/ratatouille.rb

@@ -0,0 +1,18 @@
+require "ratatouille/version"
+
+require "ratatouille/ratifier"
+require "ratatouille/nilclass"
+require "ratatouille/hash"
+require "ratatouille/array"
+require "ratatouille/string"
+
+# Module to provide DSL for validation of complex Hashes
+module Ratatouille
+
+  # @param [Hash, Array] obj Object to validate
+  # @return [Validatable::Ratifier]
+  def ratify(obj, &block)
+    Ratatouille::Ratifier.new(obj, &block)
+  end#ratify
+
+end

data/ratatouille.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ratatouille/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "ratatouille"
+  gem.version       = Ratatouille::VERSION
+  gem.authors       = ["Ryan Johnson"]
+  gem.email         = ["rhino.citguy@gmail.com"]
+  gem.homepage      = "http://github.com/CITguy/#{gem.name}"
+  gem.summary       = %q{DSL for validating complex hashes}
+  gem.description   = %q{DSL for validating complex hashes}
+
+  gem.rubyforge_project = 'ratatouille'
+
+  gem.add_development_dependency "rspec", ">= 2.4.0"
+  gem.add_development_dependency "rake"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/lib/ratatouille/array_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe "Ratatouille::ArrayMethods" do
+  [ :is_empty, 
+    :is_not_empty, 
+    :min_length, 
+    :max_length, 
+    :length_between
+  ].each do |m|
+    it "block context should respond to #{m}" do
+      r = nil
+      RatifierTest.new([]) { r = self }
+      r.should respond_to m
+    end
+  end
+
+  describe "is_empty" do
+    it "should not be valid for non-empty array" do
+      RatifierTest.new(['bar']){ is_empty }.should_not be_valid
+    end
+
+    it "should be valid for empty array" do
+      RatifierTest.new([]){ is_empty }.should be_valid
+    end
+  end
+  
+  describe "is_not_empty" do
+    it "should be valid for non-empty array" do
+      RatifierTest.new(['bar']){ is_not_empty }.should be_valid
+    end
+
+    it "should not be valid for empty array" do
+      RatifierTest.new([]){ is_not_empty }.should_not be_valid
+    end
+  end
+
+  describe "length_between" do
+    describe "for empty array" do
+      before(:each) do
+        @arr = []
+      end
+
+      it "should be valid with 0 min length and any positive, non-zero max_length" do
+        RatifierTest.new(@arr) { length_between(0) }.should be_valid
+        RatifierTest.new(@arr) { length_between(0, 0) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(0, 1) }.should be_valid
+      end
+
+      it "should be invalid with 1 min_length and any max_length" do
+        RatifierTest.new(@arr) { length_between(1) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(1,1) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(1,2) }.should_not be_valid
+      end
+    end
+
+    describe "for Array with 2 elements" do
+      before(:each) do
+        @arr = ['foo', 'bar']
+      end
+
+      it "should be valid with 1 min_length and any max_length above 1" do
+        RatifierTest.new(@arr) { length_between(1,1) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(1,2) }.should be_valid
+      end
+      
+      it "should be invalid with 0 min_length and any max_length less than 2" do
+        RatifierTest.new(@arr) { length_between(0,0) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(0,1) }.should_not be_valid
+        RatifierTest.new(@arr) { length_between(0,2) }.should be_valid
+      end
+    end
+  end
+
+  describe "max_length" do
+    it "should be valid for proper length array with integer argument" do
+      RatifierTest.new([]) { max_length(1) }.should be_valid
+      RatifierTest.new(['foo']) { max_length(1) }.should be_valid
+
+      RatifierTest.new(['foo']) { max_length(0) }.should_not be_valid
+    end
+
+    it "should be invalid for non-numeric length" do
+      RatifierTest.new([]) { max_length({}) }.should_not be_valid
+    end
+
+    it "should be valid for properly transformed float values" do
+      RatifierTest.new(['foo']) { max_length(0.3) }.should_not be_valid
+      RatifierTest.new(['foo']) { max_length(1.3) }.should be_valid
+      RatifierTest.new(['foo', 'bar']) { max_length(1.3) }.should_not be_valid
+    end
+  end
+
+  describe "min_length" do
+    it "should be valid for proper length array with integer argument" do
+      RatifierTest.new([]) { min_length(0) }.should be_valid
+      RatifierTest.new([]) { min_length(1) }.should_not be_valid
+
+      RatifierTest.new(['foo']) { min_length(0) }.should be_valid
+      RatifierTest.new(['foo']) { min_length(1) }.should be_valid
+    end
+
+    it "should be invalid for non-numeric length" do
+      RatifierTest.new([]) { min_length({}) }.should_not be_valid
+    end
+
+    it "should be valid for properly transformed float values" do
+      RatifierTest.new([]) { min_length(0.3) }.should be_valid
+      RatifierTest.new([]) { min_length(1.3) }.should_not be_valid
+    end
+  end
+end

data/spec/lib/ratatouille/hash_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe "Ratatouille::HashMethods" do
+  describe "is_empty" do
+    it "should be invalid for non-empty Hash" do
+      RatifierTest.new({:bar => 'biz'}){ is_empty }.should_not be_valid
+    end
+
+    it "should be valid for empty Hash" do
+      RatifierTest.new({}){ is_empty }.should be_valid
+    end
+  end
+
+  describe "is_not_empty" do
+    it "should be valid for non-empty hash" do
+      RatifierTest.new({:bar => "biz"}){ is_not_empty }.should be_valid
+    end
+
+    it "should not be valid for empty hash" do
+      RatifierTest.new({}){ is_not_empty }.should_not be_valid
+    end
+  end
+
+  describe "choice_of" do
+    it "should be invalid if key list is empty" do
+      RatifierTest.new({}) { choice_of(1, []) }.should_not be_valid
+    end
+
+    it "should be invalid if choice size less than 1" do
+      RatifierTest.new({}) { choice_of(0, [:foo]) }.should_not be_valid
+    end
+
+    it "should be invalid if choice list is not 1 more than choice size" do
+      RatifierTest.new({}) { choice_of(1, [:foo]) }.should_not be_valid
+    end
+  end
+
+  describe "required_keys" do
+    it "should be valid if Has contains all required keys" do
+      RatifierTest.new({:foo => "foo"}) { required_keys(:foo, :bar) }.should_not be_valid
+    end
+
+    it "should be invalid if hash is empty and key list is not" do
+      RatifierTest.new({}) { required_keys(:foo) }.should_not be_valid
+    end
+
+    it "should be invalid if Hash does not contain ALL keys in key list" do
+      RatifierTest.new({:foo => "foo"}) { required_keys(:foo, :bar) }.should_not be_valid
+    end
+  end
+end

data/spec/lib/ratatouille/nilclass_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe NilClass do
+  describe "empty?" do
+    it "should return true" do
+      nil.should be_empty
+    end
+  end
+end

data/spec/lib/ratatouille/ratifier_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Ratatouille::Ratifier do
+
+  it "should be valid on instantiation of new object" do
+    e = RatifierTest.new({})
+    e.should be_valid
+  end
+
+  it "errors should contain one key within block of new instance" do
+    x = {}
+    e = RatifierTest.new({}){ x = @errors }
+    x.keys.size.should == 1
+    x.keys.should == ['/']
+    x['/'].should be_empty
+  end
+
+  describe "validation_error" do
+    it "should create an error when called within a Ratifier block" do
+      test = RatifierTest.new(Object.new) do
+        validation_error("some error")
+      end
+      test.errors_array.should have(1).String
+
+      test = RatifierTest.new({}) do
+        validation_error("some error")
+        validation_error("another error")
+      end
+      test.errors_array.should have(2).String
+    end
+
+    it "should not create an error when called with a non-string argument" do
+      test = RatifierTest.new({}) do
+        validation_error({})
+      end
+      test.errors_array.should be_empty
+    end
+
+    it "should add the error to the '/' context by default" do
+      test = RatifierTest.new({}) do
+        # NO ERRORS
+      end
+      test.errors['/'].should be_empty
+
+      test = RatifierTest.new({}) do
+        validation_error("foo")
+      end
+      test.errors['/'].should have(1).String
+    end
+
+    it "should add an error to an explicit context (even if it doesn't exist)" do
+      ctxt = "foo"
+      test = RatifierTest.new({}) do
+        # NO ERRORS
+      end
+      test.errors[ctxt].should be_nil
+
+      test = RatifierTest.new({}) do
+        validation_error("broken", ctxt)
+      end
+      test.errors[ctxt].should have(1).String
+    end
+  end
+
+  describe "valid?" do
+    it "should be true if errors is empty?" do
+      test = RatifierTest.new({}) do
+        # No Validation = Valid Object
+      end
+      test.valid?.should be_true
+    end
+  end
+
+  describe "instance variables" do
+    before(:each) do
+      @test = RatifierTest.new({})
+    end
+
+    describe "ratifiable_object" do
+      it "should raise error if modification is attempted" do
+        Proc.new { @test.ratifiable_object = {} }.should raise_error NoMethodError
+      end
+    end
+
+    describe "errors" do
+      it "should raise error if modification is attempted" do
+        Proc.new { @test.errors = {} }.should         raise_error NoMethodError
+        Proc.new { @test.errors.delete("/") }.should  raise_error TypeError
+      end
+
+      it "should be empty on valid object" do
+        ratifier = RatifierTest.new({:foo => "bar"}) do
+          # No Validations = Valid Object
+        end
+        ratifier.errors.should be_empty
+      end
+
+      it "should not be empty on invalid object" do
+        ratifier = RatifierTest.new({:foo => "bar"}) { is_empty }
+        ratifier.errors.should_not be_empty
+      end
+    end
+
+    describe "errors_array" do
+      it "should be empty on new Ratifier" do
+        @test.errors_array.should be_empty
+      end
+
+      it "should be empty on valid object" do
+        ratifier = RatifierTest.new({}) do
+          # No Validations = Valid Object
+        end
+        ratifier.errors_array.should be_empty
+      end
+
+      it "should have at least one String item for an invalid object" do
+        test = RatifierTest.new({:foo => "bar"}){ is_empty }
+        test.errors_array.should_not  be_empty
+        test.errors_array.should      have_at_least(1).String
+      end
+    end
+  end
+end

data/spec/lib/ratatouille_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+include Ratatouille
+
+describe Ratatouille do
+
+  describe "ratify" do
+    it "should return a Ratatouille::Ratifier object" do
+      ratify({}).should be_a Ratatouille::Ratifier
+    end
+
+    it "should evaluate block in context of a Ratatouille::Ratifier object" do
+      o = nil
+      ratify({}) { o = self }
+      o.should be_a Ratatouille::Ratifier
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'ratatouille'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+class RatifierTest < Ratatouille::Ratifier
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: ratatouille
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: DSL for validating complex hashes
+email: 
+- rhino.citguy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- .travis-yml
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ratatouille.rb
+- lib/ratatouille/array.rb
+- lib/ratatouille/hash.rb
+- lib/ratatouille/nilclass.rb
+- lib/ratatouille/ratifier.rb
+- lib/ratatouille/string.rb
+- lib/ratatouille/version.rb
+- ratatouille.gemspec
+- spec/lib/ratatouille/array_spec.rb
+- spec/lib/ratatouille/hash_spec.rb
+- spec/lib/ratatouille/nilclass_spec.rb
+- spec/lib/ratatouille/ratifier_spec.rb
+- spec/lib/ratatouille_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/CITguy/ratatouille
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ratatouille
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: DSL for validating complex hashes
+test_files: 
+- spec/lib/ratatouille/array_spec.rb
+- spec/lib/ratatouille/hash_spec.rb
+- spec/lib/ratatouille/nilclass_spec.rb
+- spec/lib/ratatouille/ratifier_spec.rb
+- spec/lib/ratatouille_spec.rb
+- spec/spec_helper.rb
+has_rdoc: