ratatouille 0.1.0 → 0.9.2

data/README.md

@@ -1,6 +1,6 @@
-# Ratatouille [![Build Status](http://travis-ci.org/CITguy/ratatouille.png)](http://travis-ci.org/CITguy/ratatouille)
+# Ratatouille
 
-DSL for validation of complex Hashes
+TODO: Write a gem description
 
 ## Installation
 
@@ -16,229 +16,9 @@ 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
-```
+TODO: Write usage instructions here
 
 ## Contributing
 

data/lib/ratatouille/array.rb

@@ -1,6 +1,5 @@
 module Ratatouille
 
-  # Module used to provide Array-specific validation methods
   module ArrayMethods
     # @return [void]
     def is_empty(&block)
@@ -29,11 +28,17 @@ module Ratatouille
     # @param [Integer] min_size
     # @return [void]
     def min_length(min_size=0, &block)
-      return unless valid_min_length?(min_size)
+      unless min_size =~ /\d+/
+        validation_error("min_length argument must be an Integer")
+        return
+      end
+
+      unless @ratifiable_object.size >= min_size
+        validation_error("Array length must be #{size} or more") 
+        return
+      end
 
       instance_eval(&block) if block_given?
-    rescue Exception => e
-      validation_error("#{e.message}")
     end#min_length
 
 
@@ -42,11 +47,17 @@ module Ratatouille
     # @param [Integer] min_size
     # @return [void]
     def max_length(max_size=0, &block)
-      return unless valid_max_length?(max_size)
+      unless max_size =~ /\d+/
+        validation_error("max_length argument must be an Integer")
+        return
+      end
+
+      if @ratifiable_object.size > max_size
+        validation_error("Array length must be less than #{size}")
+        return
+      end
 
       instance_eval(&block) if block_given?
-    rescue Exception => e
-      validation_error("#{e.message}")
     end#max_length
 
 
@@ -56,65 +67,36 @@ module Ratatouille
     # @param [Integer] max_size
     # @return [void]
     def length_between(min_size=0, max_size=nil, &block)
-      return unless valid_min_length?(min_size)
+      unless min_size =~ /\d+/
+        validation_error("min_size must be an integer")
+        return
+      end
 
-      if max_size.nil?
-        if min_size == 1
-          validation_error("Consider using is_not_empty")
+      array_size = @ratifiable_object.size
+      unless array_size >= min_size
+        validation_error("Array length must be #{min_size} or more")
+        return
+      end
+
+      unless max_size.nil?
+        unless max_size =~ /\d+/
+          validation_error("max_size must be an integer")
           return
         end
-      else
-        return unless valid_max_length?(max_size)
 
-        if max_size == 0 && min_size == 0
-          validation_error("Consider using is_empty")
+        unless max_size >= min_size
+          validation_error("max_size must be greater than or equal to min_size")
           return
         end
 
-        unless max_size > min_size
-          validation_error("max_size must be greater than min_size")
+        unless array_size <= max_size
+          validation_error("Array length must be #{max_size} or less")
           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

@@ -1,12 +1,11 @@
 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?
+      if @ratifiable_object.has_key?(key)
         child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], &block)
         @errors[key] = child_object.errors unless child_object.valid?
       end
@@ -38,28 +37,17 @@ module Ratatouille
     # 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
+    # @param [Array] args Array of symbols and/or strings to denote the required keys
     # @return [void]
-    def required_keys(*req_keys, &block)
+    def required_keys(*args, &block)
+      req_keys = args.collect{|a| String === a || Symbol === a}
       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
@@ -79,18 +67,8 @@ module Ratatouille
     #   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.")
+        validation_error("choice_of requires a positive integer as first argument")
         return
       end
       

data/lib/ratatouille/nilclass.rb

@@ -1,6 +1,7 @@
-# MonkeyPatch NilClass to return true for empty?
-class NilClass
-  def empty?
-    return true
+module Ratatouille
+  class ::NilClass
+    def empty?
+      return true
+    end
   end
 end

data/lib/ratatouille/ratifier.rb

@@ -16,7 +16,7 @@ module Ratatouille
       when Array then extend Ratatouille::ArrayMethods
       end
 
-      instance_eval( &block ) if block_given?
+      instance_eval(&block) if block_given?
 
       cleanup_errors
 
@@ -28,13 +28,11 @@ module Ratatouille
     # @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
+    def validation_error(str="", context="/")
+      return unless str.respond_to?(:to_s)
+      return if str.to_s.chomp == ''
+      @errors[context] = [] unless @errors[context]
+      @errors[context] << str.to_s
     rescue Exception => e
       @errors["/"] << e.message
     end#validation_error
@@ -52,7 +50,9 @@ module Ratatouille
     #
     # @return [void]
     def cleanup_errors 
-      @errors = {} if errors_array.empty?
+      if errors_array.empty?
+        @errors = {}
+      end
     rescue Exception => e
       @errors["/"] << e.message
     end#cleanup_errors

data/lib/ratatouille/version.rb

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

data/lib/ratatouille.rb

@@ -4,9 +4,7 @@ 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

data/spec/lib/{ratatouille/ratifier_spec.rb → ratatouille_ratifier_spec.rb}

@@ -1,12 +1,8 @@
 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
+class RatifierTest < Ratatouille::Ratifier; end
 
+describe Ratatouille::Ratifier do
   it "errors should contain one key within block of new instance" do
     x = {}
     e = RatifierTest.new({}){ x = @errors }

data/spec/lib/ratatouille_spec.rb

@@ -1,18 +1,65 @@
 require 'spec_helper'
 
-include Ratatouille
+class RatifierTest < Ratatouille::Ratifier; end
 
 describe Ratatouille do
 
-  describe "ratify" do
-    it "should return a Ratatouille::Ratifier object" do
-      ratify({}).should be_a Ratatouille::Ratifier
+  describe "with Hash" do 
+    describe "is_empty" do
+      it "should not be valid for non-empty Hash" do
+        e = RatifierTest.new({:bar => 'biz'}){ is_empty }
+        #puts "RatifierTest:"
+        #puts "@ratifiable_object.nil? #{e.ratifiable_object.nil?}"
+        #puts e.ratifiable_object.inspect
+        #puts "Errors.nil? #{e.errors.nil?}"
+        #puts e.errors.inspect
+        #puts "Errors.empty? #{e.errors.empty?}"
+        #puts "Valid?: #{e.valid?}"
+        e.valid?.should be_false
+      end
+
+      it "should be valid for empty Hash" do
+        e = RatifierTest.new({}){ is_empty }
+        e.valid?.should be_true
+      end
+    end
+
+    describe "is_not_empty" do
+      it "should be valid for non-empty hash" do
+        e = RatifierTest.new({:bar => "biz"}){ is_not_empty }
+        e.valid?.should be_true
+      end
+
+      it "should not be valid for empty hash" do
+        e = RatifierTest.new({}){ is_not_empty }
+        e.valid?.should be_false
+      end
+    end
+  end
+
+  describe "with Array" do
+    describe "is_empty" do
+      it "should not be valid for non-empty array" do
+        e = RatifierTest.new(['bar']){ is_empty }
+        e.valid?.should be_false
+      end
+
+      it "should be valid for empty array" do
+        e = RatifierTest.new([]){ is_empty }
+        e.valid?.should be_true
+      end
     end
+    
+    describe "is_not_empty" do
+      it "should be valid for non-empty array" do
+        e = RatifierTest.new(['bar']){ is_not_empty }
+        e.valid?.should be_true
+      end
 
-    it "should evaluate block in context of a Ratatouille::Ratifier object" do
-      o = nil
-      ratify({}) { o = self }
-      o.should be_a Ratatouille::Ratifier
+      it "should not be valid for empty array" do
+        e = RatifierTest.new([]){ is_not_empty }
+        e.valid?.should be_false
+      end
     end
   end
 

data/spec/ratifier_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+class TestRatifier < Ratatouille::Ratifier; end
+
+describe Ratatouille::Ratifier do
+  it "should be valid upon instantiation without a block" do
+    r = TestRatifier.new({})
+    r.valid?.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,3 @@ require 'ratatouille'
 RSpec.configure do |config|
   config.color_enabled = true
 end
-
-class RatifierTest < Ratatouille::Ratifier
-end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratatouille
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 63
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 0
-  version: 0.1.0
+  - 9
+  - 2
+  version: 0.9.2
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-14 00:00:00 Z
+date: 2012-04-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -70,14 +70,11 @@ files:
 - 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_ratifier_spec.rb
 - spec/lib/ratatouille_spec.rb
+- spec/ratifier_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/CITguy/ratatouille
 licenses: []
@@ -113,10 +110,8 @@ 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_ratifier_spec.rb
 - spec/lib/ratatouille_spec.rb
+- spec/ratifier_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/ratatouille/string.rb

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

data/spec/lib/ratatouille/array_spec.rb

@@ -1,111 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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