ratatouille 0.9.2 → 1.0.0

data/README.md

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

data/lib/ratatouille.rb

@@ -4,7 +4,9 @@ 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/lib/ratatouille/array.rb

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

@@ -1,11 +1,12 @@
 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)
+      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
@@ -37,17 +38,28 @@ 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 of symbols and/or strings to denote the required keys
+    # @param [Array] args Array required keys
     # @return [void]
-    def required_keys(*args, &block)
-      req_keys = args.collect{|a| String === a || Symbol === a}
+    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
@@ -67,8 +79,18 @@ 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 as first argument")
+        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
       

data/lib/ratatouille/nilclass.rb

@@ -1,7 +1,6 @@
-module Ratatouille
-  class ::NilClass
-    def empty?
-      return true
-    end
+# MonkeyPatch NilClass to return true for empty?
+class NilClass
+  def empty?
+    return true
   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,11 +28,13 @@ module Ratatouille
     # @param [String] str
     # @param [String] context
     # @return [void]
-    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
+    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
@@ -50,9 +52,7 @@ module Ratatouille
     #
     # @return [void]
     def cleanup_errors 
-      if errors_array.empty?
-        @errors = {}
-      end
+      @errors = {} if errors_array.empty?
     rescue Exception => e
       @errors["/"] << e.message
     end#cleanup_errors

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

@@ -1,3 +1,4 @@
 module Ratatouille
-  VERSION = "0.9.2"
+  # Gem Version
+  VERSION = "1.0.0"
 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 → ratatouille/ratifier_spec.rb}

@@ -1,8 +1,12 @@
 require 'spec_helper'
 
-class RatifierTest < Ratatouille::Ratifier; end
-
 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 }

data/spec/lib/ratatouille_spec.rb

@@ -1,65 +1,18 @@
 require 'spec_helper'
 
-class RatifierTest < Ratatouille::Ratifier; end
+include Ratatouille
 
 describe Ratatouille do
 
-  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
+  describe "ratify" do
+    it "should return a Ratatouille::Ratifier object" do
+      ratify({}).should be_a Ratatouille::Ratifier
     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 not be valid for empty array" do
-        e = RatifierTest.new([]){ is_not_empty }
-        e.valid?.should be_false
-      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
 

data/spec/spec_helper.rb

@@ -4,3 +4,6 @@ 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: 63
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 9
-  - 2
-  version: 0.9.2
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-13 00:00:00 Z
+date: 2012-04-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -70,11 +70,14 @@ 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_ratifier_spec.rb
+- 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/ratifier_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/CITguy/ratatouille
 licenses: []
@@ -110,8 +113,10 @@ signing_key:
 specification_version: 3
 summary: DSL for validating complex hashes
 test_files: 
-- spec/lib/ratatouille_ratifier_spec.rb
+- 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/ratifier_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/ratifier_spec.rb

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