ratatouille 1.3.8 → 1.4.0

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 1.4.0
+
+### Updates
+
+* New global :skip option allows you to programmatically skip validation by passing in a value of true.
+* min\_length and max\_length now call length\_between to perform validation
+* is\_boolean now accepts :unwrap\_block option in addition to new :skip option
+* 12 new tests
+
+### Corrections
+
+* Fixed some false negatives with Array length validation
+* :unwrap\_block not applicable for given\_key if :required is set to true
+
 ## 1.3.8
 
 ### Updates

data/lib/ratatouille/array.rb

@@ -6,21 +6,23 @@ module Ratatouille
     # Iterator method to encapsulate validation
     #
     # @note Method will NOT work without a block
-    # @param [Hash] options
-    # @option options [Hash] :each 
-    #   options to pass to ratifier for each item in array
-    # @option options [Integer] :min_length
-    # @option options [Integer] :max_length
+    # @param [Hash] options 
+    #   Accepts global options in addition to the following:
+    # @option options [Hash] :name (array_item)
+    #   Name each ratifiable object for use in validation message.
     # @return [void]
     def ratify_each(options={}, &block)
-      if block_given?
-        item_name = options[:name] || "array_item"
-        @ratifiable_object.each_with_index do |obj, i|
-          options[:name] = "#{item_name}"
-          child_object = Ratatouille::Ratifier.new(obj, options, &block)
-          @errors["/"] << child_object.errors unless child_object.valid?
+      parse_options(options)
+
+      unless @skip
+        if block_given?
+          @ratifiable_object.each_with_index do |obj, i|
+            options[:name] = options.fetch(:name, "array_item")
+            child_object = Ratatouille::Ratifier.new(obj, options, &block)
+            @errors["/"] << child_object.errors unless child_object.valid?
+          end
         end
-      end
+      end#skip
     end#ratify_each
 
 
@@ -33,14 +35,7 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def min_length(min_size=0, options={}, &block)
-      parse_options(options)
-
-      unless @unwrap_block == true
-        # Wrapped Validation
-        return unless valid_min_length?(min_size)
-      end
-
-      instance_eval(&block) if block_given?
+      return length_between(min_size, nil, options, &block)
     rescue Exception => e
       validation_error("#{e.message}")
     end#min_length
@@ -55,14 +50,7 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def max_length(max_size=0, options={}, &block)
-      parse_options(options)
-
-      unless @unwrap_block == true
-        # Wrapped Validation
-        return unless valid_max_length?(max_size)
-      end
-
-      instance_eval(&block) if block_given?
+      return length_between(0, max_size, options, &block)
     rescue Exception => e
       validation_error("#{e.message}")
     end#max_length
@@ -80,73 +68,44 @@ module Ratatouille
     def length_between(min_size=0, max_size=nil, options={}, &block)
       parse_options(options)
 
-      unless @unwrap_block == true
-        # Wrapped Validation
-        return unless valid_min_length?(min_size)
-
-        if max_size.nil?
-          if min_size == 1
-            validation_error("Consider using is_not_empty")
+      unless @skip == true
+        unless @unwrap_block == true
+          # Minimum Length Validation
+          unless min_size.to_i >= 0
+            validation_error("min_length must be a number greater than or equal to 0")
             return
           end
-        else
-          return unless valid_max_length?(max_size)
 
-          if max_size == 0 && min_size == 0
-            validation_error("Consider using is_empty")
+          unless @ratifiable_object.size >= min_size.to_i
+            validation_error("length must be #{min_size} or more") 
             return
           end
 
-          unless max_size > min_size
-            validation_error("max_size must be greater than min_size")
-            return
+          # Maximum Length Validation
+          unless max_size.nil?
+            unless max_size.to_i >= 0
+              validation_error("max_size must be a number greater than or equal to 0")
+              return
+            end
+
+            if @ratifiable_object.size > max_size.to_i
+              validation_error("length must be less than #{max_size.to_i}")
+              return
+            end
+
+            unless max_size > min_size
+              validation_error("max_size must be greater than min_size")
+              return
+            end
           end
-        end
-      end
+        end#unwrap_block
 
-      instance_eval(&block) if block_given?
+        instance_eval(&block) if block_given?
+      end#skip
     rescue Exception => e
       validation_error("#{e.message}")
     end#length_between
 
-  private
-
-    # @note Supporting Method
-    # @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("length must be #{min_size} or more") 
-        return false
-      end
-      return true
-    rescue Exception => e
-      validation_error("#{e.message}")
-      return false
-    end
-
-    # @note Supporting Method
-    # @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("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
+end#module

data/lib/ratatouille/hash.rb

@@ -24,35 +24,33 @@ module Ratatouille
     #   Name of ratifiable_object for use with validation error messages.
     # @option options [Boolean] :required (false) 
     #   Ensure that ratifiable_object has the given key
+    # @return [void]
+    # @note :unwrap_block option not applicable if key is required
     def given_key(key, options={}, &block)
       options[:name] = options.fetch(:name, (Symbol === key ? ":#{key}" : key.to_s) )
 
       parse_options(options)
 
-      unless @unwrap_block == true
-        # WRAPPED VALIDATION
-        if @required == true
-          unless @ratifiable_object.has_key?(key)
+      unless @skip == true
+        unless @ratifiable_object.has_key?(key) # Key Not Found
+          if @required == true
             validation_error("Missing key #{key.inspect}")
             return
           end
-        end
-      end
-
-      if @ratifiable_object.has_key?(key)
-        unless @unwrap_block == true
-          # WRAPPED VALIDATION
-          unless @is_a.nil?
-            unless @is_a === @ratifiable_object[key]
-              validation_error("key value is not of type #{@is_a}")
-              return
+        else # Key Found
+          unless @unwrap_block == true
+            unless @is_a.nil?
+              unless @is_a === @ratifiable_object[key]
+                validation_error("key value is not of type #{@is_a}")
+                return
+              end
             end
-          end
-        end
+          end#unwrap_block
 
-        if block_given?
-          child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], options, &block)
-          @errors[key] = child_object.errors unless child_object.valid?
+          if block_given?
+            child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], options, &block)
+            @errors[key] = child_object.errors unless child_object.valid?
+          end
         end
       end
     rescue Exception => e
@@ -106,31 +104,33 @@ module Ratatouille
     def required_keys(options={}, &block)
       parse_options(options)
 
-      unless @unwrap_block == true
-        req_keys = options.fetch(:key_list, [])
+      unless @skip == true
+        unless @unwrap_block == true
+          req_keys = options.fetch(:key_list, [])
 
-        # Wrapped Validation
-        common_keys = (@ratifiable_object.keys & req_keys)
+          # Wrapped Validation
+          common_keys = (@ratifiable_object.keys & req_keys)
 
-        if @ratifiable_object.empty?
-          validation_error("Cannot find required keys")
-          return
-        end
+          if @ratifiable_object.empty?
+            validation_error("Cannot find required keys")
+            return
+          end
 
-        if req_keys.nil? || req_keys.empty?
-          validation_error("No required keys given to compare against.")
-          return
-        end
+          if req_keys.nil? || req_keys.empty?
+            validation_error("No required keys given to compare against.")
+            return
+          end
 
-        unless common_keys.size == req_keys.size
-          (req_keys - common_keys).each do |missed| 
-            validation_error("Missing #{missed.inspect}")
+          unless common_keys.size == req_keys.size
+            (req_keys - common_keys).each do |missed| 
+              validation_error("Missing #{missed.inspect}")
+            end
+            return
           end
-          return
         end
-      end
 
-      instance_eval(&block) if block_given?
+        instance_eval(&block) if block_given?
+      end
     rescue Exception => e
       validation_error("#{e.message}")
     end#required_keys
@@ -164,56 +164,58 @@ module Ratatouille
     def choice_of(options={}, &block)
       parse_options(options)
 
-      unless @unwrap_block == true
-        choice_size = options.fetch(:choice_size, 1)
-        key_list = options.fetch(:key_list, [])
+      unless @skip == true
+        unless @unwrap_block == true
+          choice_size = options.fetch(:choice_size, 1)
+          key_list = options.fetch(:key_list, [])
 
-        # Wrapped Validation
-        if key_list.nil? || key_list.empty?
-          validation_error("choice_of requires a key list to choose from")
-          return
-        end
-        key_list.flatten!
+          # Wrapped Validation
+          if key_list.nil? || key_list.empty?
+            validation_error("choice_of requires a key list to choose from")
+            return
+          end
+          key_list.flatten!
+
+          # I can work with a non-zero integer or any object that responds
+          case choice_size
+          when Integer
+            unless choice_size > 0
+              validation_error("choice_of requires a positive integer for choice size")
+              return
+            end
+          else
+            unless choice_size.respond_to?(:to_i)
+              validation_error("choice_of requires an object that responds to :to_i for choice size")
+              return
+            end
+            choice_size = choice_size.to_i
+          end
 
-        # I can work with a non-zero integer or any object that responds
-        case choice_size
-        when Integer
           unless choice_size > 0
-            validation_error("choice_of requires a positive integer for choice size")
+            validation_error("choice size for choice_of must be positive non-zero number")
+            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
-        else
-          unless choice_size.respond_to?(:to_i)
-            validation_error("choice_of requires an object that responds to :to_i for choice size")
+          
+          common_keys = (@ratifiable_object.keys & key_list)
+          unless common_keys.size == choice_size
+            choices = key_list.collect{|a| 
+              case a
+              when Symbol then ":#{a}"
+              when String then "#{a}"
+              end
+            }
+            validation_error("Require #{choice_size} of the following: #{choices.join(', ')}")
             return
           end
-          choice_size = choice_size.to_i
-        end
-
-        unless choice_size > 0
-          validation_error("choice size for choice_of must be positive non-zero number")
-          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| 
-            case a
-            when Symbol then ":#{a}"
-            when String then "#{a}"
-            end
-          }
-          validation_error("Require #{choice_size} of the following: #{choices.join(', ')}")
-          return
-        end
-      end
+        end#unwrap_block
 
-      instance_eval(&block) if block_given?
+        instance_eval(&block) if block_given?
+      end#skip
     rescue Exception => e
       validation_error("#{e.message}")
     end#choice_of

data/lib/ratatouille/ratifier.rb

@@ -13,7 +13,7 @@ module Ratatouille
       @ratifiable_object = obj
       self.name = options[:name]
 
-      @is_a ||= options[:is_a]
+      parse_options(options)
 
       case obj
       when Hash  then extend Ratatouille::HashMethods
@@ -57,7 +57,7 @@ module Ratatouille
 
 
     # Add validation error. Useful for custom validations.
-    # @param [String] str
+    # @param [String] err_in
     # @param [String] context
     # @return [void]
     def validation_error(err_in, context="/")
@@ -90,7 +90,7 @@ module Ratatouille
     end#cleanup_errors
 
 
-    # @param [Hash] hsh Hash to act upon.
+    # @param [Hash] item Hash to act upon.
     # @return [Array]
     def errors_array(item = @errors)
       all_errs = []
@@ -150,13 +150,21 @@ module Ratatouille
     # Any other class will result in a failed validation.
     #
     # @return [Boolean]
-    def is_boolean(&block)
-      case @ratifiable_object
-      when TrueClass, FalseClass 
+    def is_boolean(options={}, &block)
+      parse_options(options)
+
+      unless @skip == true
+        unless @unwrap_block == true
+          case @ratifiable_object
+          when TrueClass, FalseClass 
+            # OK to enter block
+          else 
+            validation_error("object is not a boolean")
+            return
+          end
+        end
+
         instance_eval(&block) if block_given?
-      else 
-        validation_error("object is not a boolean")
-        return
       end
     rescue Exception => e
       validation_error("#{e.message}", "/")
@@ -169,12 +177,16 @@ module Ratatouille
     # @param [Hash] options
     # @option options [Class] :is_a (nil)
     # @option options [Boolean] :required (false)
+    # @option options [Boolean] :skip (false)
     # @option options [Boolean] :unwrap_block (false)
     #   Perform block validation only -- skip method validation logic.
     def parse_options(options={})
-      @is_a = options.fetch(:is_a, nil)
-      @required = options.fetch(:required, false)
-      @unwrap_block = options.fetch(:unwrap_block, false)
+      if Hash === options
+        @is_a =         options.fetch(:is_a, nil)
+        @required =     options.fetch(:required, false)
+        @skip =         options.fetch(:skip, false)
+        @unwrap_block = options.fetch(:unwrap_block, false)
+      end
     end#parse_options
 
 
@@ -182,43 +194,39 @@ module Ratatouille
     # methods called on incorrect objects (hash validation on arrays, etc.)
     # as well as some catch-all methods for boolean validations (is_* and is_not_*)
     def method_missing(id, *args, &block)
-      should_unwrap = false
-      if args.first.respond_to?(:keys)
-        if args.first.fetch(:unwrap_block, false) == true
-          should_unwrap = true
-        end
-      end
-
-      case
-      when should_unwrap == true
-        # Perform no validation logic
-        # Skip to block evaluation
-      when id.to_s =~ /^is_not_(.*)$/
-        if @ratifiable_object.respond_to?("#{$1}?")
-          if @ratifiable_object.send("#{$1}?") == true
-            validation_error("is #{$1}")
-            return
+      parse_options(args.first)
+
+      unless @skip == true
+        case
+        when @unwrap_block == true
+          # Perform no validation logic
+          # Skip to block evaluation
+        when id.to_s =~ /^is_not_(.*)$/
+          if @ratifiable_object.respond_to?("#{$1}?")
+            if @ratifiable_object.send("#{$1}?") == true
+              validation_error("is #{$1}")
+              return
+            end
           end
-        end
-      when id.to_s =~ /^is_(.*)$/
-        if @ratifiable_object.respond_to?("#{$1}?")
-          if @ratifiable_object.send("#{$1}?") == false
-            validation_error("is not #{$1}")
+        when id.to_s =~ /^is_(.*)$/
+          if @ratifiable_object.respond_to?("#{$1}?")
+            if @ratifiable_object.send("#{$1}?") == false
+              validation_error("is not #{$1}")
+              return
+            end
+          end
+        else
+          begin
+            super
             return
+          rescue Exception => e
+            validation_error("#{id} is not supported for the given object (#{@ratifiable_object.class})")
+            return e
           end
         end
-      else
-        begin
-          super
-          return
-        rescue Exception => e
-          validation_error("#{id} is not supported for the given object (#{@ratifiable_object.class})")
-          return e
-        end
-      end
 
-      instance_eval(&block) if block_given?
-      return
+        instance_eval(&block) if block_given?
+      end#skip
     end#method_missing
 
 

data/lib/ratatouille/version.rb

@@ -1,4 +1,4 @@
 module Ratatouille
   # Gem Version
-  VERSION = "1.3.8"
+  VERSION = "1.4.0"
 end

data/spec/lib/ratatouille/array_spec.rb

@@ -14,130 +14,178 @@ describe "Ratatouille::ArrayMethods" do
   end
 
   describe "ratify_each" do
-    it "should set block name to name in options" do
-      n = ""
-      RatifierTest.new(['foo', 'bar']) do
-        ratify_each { n = name }
+    context "with default options" do
+      it "should set block name to name in options" do
+        n = ""
+        RatifierTest.new(['foo', 'bar']) do
+          ratify_each { n = name }
+        end
+        n.should match /^(array_item)/i
+
+        RatifierTest.new(['foo', 'bar']) do
+          ratify_each(:name => "foo") { n = name }
+        end
+        n.should match /^foo/i
       end
-      n.should match /^(array_item)/i
 
-      RatifierTest.new(['foo', 'bar']) do
-        ratify_each(:name => "foo") { n = name }
+      it "should be invalid for given array" do
+        r = RatifierTest.new(['bar', 'biz']) do
+          ratify_each(:is_a => String) do
+            validation_error("#{ro} is not 'bang'") unless ro == 'bang'
+          end
+        end
+        r.errors_array.length.should == 2
       end
-      n.should match /^foo/i
-    end
 
-    it "should be invalid for given array" do
-      r = RatifierTest.new(['bar', 'biz']) do
-        ratify_each(:is_a => String) do
-          validation_error("#{ro} is not 'bang'") unless ro == 'bang'
+      it "should be valid for given array" do
+        r = RatifierTest.new(['bar', 'biz']) do
+          ratify_each(:is_a => String) do
+            validation_error("too short") unless ro.size > 2
+          end
         end
+        r.should be_valid
       end
-      r.errors_array.length.should == 2
     end
 
-    it "should be valid for given array" do
-      r = RatifierTest.new(['bar', 'biz']) do
-        ratify_each(:is_a => String) do
-          validation_error("too short") unless ro.size > 2
+    context "with :skip => true" do
+      it "should not enter block" do
+        n = false
+        RatifierTest.new(['foo', 'bar']) do
+          ratify_each(:skip => true) { n = true }
         end
+        n.should be_false
       end
-      r.should be_valid
     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
+    context "with default options" 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
 
-    it "should be valid for empty array" do
-      RatifierTest.new([]){ is_empty }.should be_valid
+    context "with :skip => true" do
+      it "should not run validation" do
+        RatifierTest.new(['bar']){ is_empty(:skip => true) }.should be_valid
+      end
     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
+    context "with default options" 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
 
-    it "should not be valid for empty array" do
-      RatifierTest.new([]){ is_not_empty }.should_not be_valid
+    context "with :skip => true" do
+      it "should not run validation" do
+        RatifierTest.new([]){ is_not_empty(:skip => true) }.should be_valid
+      end
     end
   end
 
   describe "length_between" do
-    describe "for empty array" do
-      before(:each) do
-        @arr = []
-      end
+    let(:empty_array) { [] }
+    let(:one_element_array) { ['foo'] }
+    let(:two_element_array) { ['foo', 'bar'] }
+
+    context "with default options" do
+      context "for an empty array" do
+        it "should be valid with 0 min length and any positive, non-zero max_length" do
+          RatifierTest.new(empty_array) { length_between(0) }.should be_valid
+          RatifierTest.new(empty_array) { length_between(0, 0) }.should_not be_valid
+          RatifierTest.new(empty_array) { length_between(0, 1) }.should be_valid
+        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
+        it "should be invalid with 1 min_length and any max_length" do
+          RatifierTest.new(empty_array) { length_between(1) }.should_not be_valid
+          RatifierTest.new(empty_array) { length_between(1,1) }.should_not be_valid
+          RatifierTest.new(empty_array) { length_between(1,2) }.should_not be_valid
+        end
       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
+      context "for a two-element array" do
+        it "should be valid with 1 min_length and any max_length above 1" do
+          RatifierTest.new(two_element_array) { length_between(1,1) }.should_not be_valid
+          RatifierTest.new(two_element_array) { 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(two_element_array) { length_between(0,0) }.should_not be_valid
+          RatifierTest.new(two_element_array) { length_between(0,1) }.should_not be_valid
+          RatifierTest.new(two_element_array) { length_between(0,2) }.should be_valid
+        end
       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
+    context "with :skip => true" do
+      it "should be valid if validation says otherwise" do
+        RatifierTest.new(empty_array) { length_between(1,2, :skip => true) }.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
+    context "with default options" 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
+        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
+      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
 
-    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
+    context "with :skip => true" do
+      it "should be valid when validation would say otherwise" do
+        RatifierTest.new(['foo', 'bar']) { max_length(1, :skip => true) }.should be_valid
+      end
     end
-  end
+  end#max_length
 
   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
+    context "with default options" 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
+        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 invalid for non-numeric length" do
-      RatifierTest.new([]) { min_length({}) }.should_not be_valid
+      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
 
-    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
+    context "with :skip => true" do
+      it "should not perform validation" do
+        RatifierTest.new([]) { min_length(1, :skip => true) }.should be_valid
+      end
     end
-  end
+  end#min_length
 end

data/spec/lib/ratatouille/hash_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe "Ratatouille::HashMethods" do
+  let(:empty_hash) { {} }
+
   [ :choice_of,
     :required_keys,
     :required_key,
@@ -20,7 +22,7 @@ describe "Ratatouille::HashMethods" do
       end
 
       it "should be valid for empty Hash" do
-        RatifierTest.new({}){ is_empty }.should be_valid
+        RatifierTest.new(empty_hash){ is_empty }.should be_valid
       end
 
       describe "when :unwrap_block is true" do
@@ -40,12 +42,12 @@ describe "Ratatouille::HashMethods" do
       end
 
       it "should not be valid for empty hash" do
-        RatifierTest.new({}){ is_not_empty }.should_not be_valid
+        RatifierTest.new(empty_hash){ is_not_empty }.should_not be_valid
       end
 
       describe "when :unwrap_block is true" do
         it "should be valid for empty hash" do
-          RatifierTest.new({}){ 
+          RatifierTest.new(empty_hash){ 
             is_not_empty(:unwrap_block => true) do
               # Nothing to validate, wrapper ignored
             end
@@ -56,139 +58,163 @@ describe "Ratatouille::HashMethods" do
   end
 
   describe "choice_of" do
-    it "should be valid with no :choice_size given" do
-      RatifierTest.new({:foo => "bar"}) {
-        choice_of(:key_list => [:foo, :bar])
-      }.should be_valid
-    end
+    context "with default options" do
+      it "should be valid with no :choice_size given" do
+        RatifierTest.new({:foo => "bar"}) {
+          choice_of(:key_list => [:foo, :bar])
+        }.should be_valid
+      end
 
-    it "should be invalid if key list is empty" do
-      RatifierTest.new({}) { 
-        choice_of(:choice_size => 1, :key_list => []) 
-      }.should_not be_valid
-    end
+      it "should be invalid if key list is empty" do
+        RatifierTest.new(empty_hash) { 
+          choice_of(:choice_size => 1, :key_list => []) 
+        }.should_not be_valid
+      end
 
-    it "should be invalid if choice size less than 1" do
-      RatifierTest.new({}) { 
-        choice_of(:choice_size => 0, :key_list => [:foo]) 
-      }.should_not be_valid
-    end
+      it "should be invalid if choice size less than 1" do
+        RatifierTest.new(empty_hash) { 
+          choice_of(:choice_size => 0, :key_list => [: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(:choice_size => 1, :key_list => [:foo]) 
-      }.should_not be_valid
-    end
+      it "should be invalid if choice list is not 1 more than choice size" do
+        RatifierTest.new(empty_hash) { 
+          choice_of(:choice_size => 1, :key_list => [:foo]) 
+        }.should_not be_valid
+      end
 
-    it "should be valid when given hash has 1 key in a choice list of 2 or more" do
-      RatifierTest.new({:foo => "bar"}){ 
-        choice_of(:key_list => [:foo, :bar]) 
-      }.should be_valid
-    end
+      it "should be valid when given hash has 1 key in a choice list of 2 or more" do
+        RatifierTest.new({:foo => "bar"}){ 
+          choice_of(:key_list => [:foo, :bar]) 
+        }.should be_valid
+      end
 
-    it "should be valid when given hash has 2 keys in choice list of 3 or more" do
-      RatifierTest.new({:foo => "foo", :bar => "bar"}){ 
-        choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz]) 
-      }.should be_valid
+      it "should be valid when given hash has 2 keys in choice list of 3 or more" do
+        RatifierTest.new({:foo => "foo", :bar => "bar"}){ 
+          choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz]) 
+        }.should be_valid
 
-      RatifierTest.new({:foo => "foo", :bar => "bar"}){ 
-        choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz, :bang]) 
-      }.should be_valid
+        RatifierTest.new({:foo => "foo", :bar => "bar"}){ 
+          choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz, :bang]) 
+        }.should be_valid
+      end
     end
 
-    describe "when :unwrap_block is true" do
+    context "with :unwrap_block => true" do
       it "should be valid when used on empty Hash" do
-        RatifierTest.new({}){
+        RatifierTest.new(empty_hash){
           choice_of(:key_list => [:foo, :bar], :unwrap_block => true) do
             # Nothing to validate, wrapper ignored
           end
         }.should be_valid
 
-        RatifierTest.new({}){
+        RatifierTest.new(empty_hash){
           choice_of(:key_list => [:foo, :bar]) do
             # Nothing to validate, wrapper ignored
           end
         }.should_not be_valid
       end
     end
+
+    context "with :skip => true" do
+      context "with empty hash" do
+        it "should be valid" do
+          RatifierTest.new(empty_hash){ 
+            choice_of(:key_list => [:foo, :bar], :skip => true) 
+          }.should be_valid
+        end
+      end
+    end
   end
 
   describe "required_keys" do
-    it "should be valid if Hash contains all required keys" do
-      RatifierTest.new({:foo => "foo"}) { 
-        required_keys(:key_list => [:foo, :bar]) 
-      }.should_not be_valid
+    context "with default options" do
+      it "should be valid if Hash contains all required keys" do
+        RatifierTest.new({:foo => "foo", :bar => "bar"}) { 
+          required_keys(:key_list => [:foo, :bar]) 
+        }.should be_valid
+      end
 
-      RatifierTest.new({:foo => "foo", :bar => "bar"}) { 
-        required_keys(:key_list => [:foo, :bar]) 
-      }.should be_valid
-    end
+      it "should be invalid if Hash is empty and key list is not" do
+        RatifierTest.new(empty_hash) { 
+          required_keys(:key_list => [:foo]) 
+        }.should_not be_valid
+      end
 
-    it "should be invalid if Hash is empty and key list is not" do
-      RatifierTest.new({}) { 
-        required_keys(:key_list => [:foo]) 
-      }.should_not be_valid
+      it "should be invalid if Hash does not contain ALL keys in key list" do
+        RatifierTest.new({:foo => "foo"}) { 
+          required_keys(:key_list => [:foo, :bar]) 
+        }.should_not be_valid
+      end
     end
 
-    it "should be invalid if Hash does not contain ALL keys in key list" do
-      RatifierTest.new({:foo => "foo"}) { 
-        required_keys(:key_list => [:foo, :bar]) 
-      }.should_not be_valid
+    context "with :unwrap_block => true" do
+      context "when used on empty Hash" do
+        it "should be valid" do
+          RatifierTest.new(empty_hash){
+            required_keys(:key_list => [:foo, :bar], :unwrap_block => true) {}
+          }.should be_valid
+        end
+
+        it "should enter block with required keys" do
+          entered_block = false
+          RatifierTest.new(empty_hash){
+            required_keys(:key_list => [:foo, :bar], :unwrap_block => true) do 
+              entered_block = true
+            end
+          }
+          entered_block.should be_true
+        end
+      end
     end
 
-    describe "when :unwrap_block is true" do
-      it "should be valid when used on empty Hash" do
-        RatifierTest.new({}){
-          required_keys(:key_list => [:foo, :bar], :unwrap_block => true) do
-            # Nothing to validate, wrapper ignored
-          end
+    context "with :skip => true" do
+      it "should be valid if Hash does not contain all required keys" do
+        RatifierTest.new({:foo => "foo"}) { 
+          required_keys(:key_list => [:foo, :bar], :skip => true) 
         }.should be_valid
-
-        RatifierTest.new({}){
-          required_keys(:key_list => [:foo, :bar]) do
-            # Nothing to validate, wrapper ignored
-          end
-        }.should_not be_valid
       end
     end
   end
 
   describe "required_key" do
-    it "should be invalid when given a key for an empty hash" do
-      RatifierTest.new({}){ required_key(:foo) }.should_not be_valid
-    end
+    context "with default options" do
+      it "should be invalid when given a key for an empty hash" do
+        RatifierTest.new({}){ required_key(:foo) }.should_not be_valid
+      end
 
-    it "should be invalid when given a key that doesn't exist in the hash" do
-      RatifierTest.new({:foo => "foo"}){ required_key(:bar) }.should_not be_valid
-    end
+      it "should be invalid when given a key that doesn't exist in the hash" do
+        RatifierTest.new({:foo => "foo"}){ required_key(:bar) }.should_not be_valid
+      end
 
-    it "should not progress into block if invalid" do
-      f = false
-      RatifierTest.new({}) do
-        required_key(:foo) { f = true }
+      it "should not progress into block if invalid" do
+        f = false
+        RatifierTest.new({}) do
+          required_key(:foo) { f = true }
+        end
+        f.should be_false
       end
-      f.should be_false
-    end
 
-    it "should change the scope name to default to the key if no name passed as option" do
-      n = ""
-      RatifierTest.new({:foo => "bar"}) do
-        required_key(:foo) { n = name }
+      it "should change the scope name to default to the key if no name passed as option" do
+        n = ""
+        RatifierTest.new({:foo => "bar"}) do
+          required_key(:foo) { n = name }
+        end
+        n.should == ":foo"
       end
-      n.should == ":foo"
     end
 
-    describe "when :unwrap_block is true" do
-      it "should be valid when used on empty Hash" do
+    context "with :unwrap_block => true" do
+      it "should be invalid when used on empty Hash" do
         RatifierTest.new({}){
           required_key(:foo, :unwrap_block => true) do
             # Nothing to validate, wrapper ignored
           end
-        }.should be_valid
+        }.should_not be_valid
       end
     end
 
-    describe "when :is_a is given" do
+    describe "with :is_a" do
       it "should be valid with matching key value class" do
         RatifierTest.new({:foo => "bar"}){
           required_key(:foo, :class => String) do

data/spec/lib/ratatouille/ratifier_spec.rb

@@ -144,15 +144,43 @@ describe Ratatouille::Ratifier do
   end
 
   describe "is_boolean" do
-    [true, false].each do |b|
-      it "should enter block for #{b} value" do
+    context "with default options" do
+      [true, false].each do |b|
+        it "should enter block for #{b} value" do
+          block_entered = false
+          RatifierTest.new(b) do
+            is_boolean { block_entered = true }
+          end
+          block_entered.should be_true
+        end
+      end
+
+      it "should not enter block for non-boolean value" do
         block_entered = false
-        RatifierTest.new(b) do
+        RatifierTest.new("foo") do
           is_boolean { block_entered = true }
         end
+        block_entered.should be_false
+      end
+    end
+
+    context "with :unwrap_block => true" do
+      it "should enter block if ratifiable object is NOT boolean" do
+        block_entered = false
+        RatifierTest.new("foo") do 
+          is_boolean(:unwrap_block => true) { block_entered = true }
+        end
         block_entered.should be_true
       end
     end
+
+    context "with :skip => true" do
+      it "should be valid even if validation says otherwise" do
+        RatifierTest.new("foo") { 
+          is_boolean(:skip => true) 
+        }.should be_valid
+      end
+    end
   end
 
   describe "name" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratatouille
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: 
   segments: 
   - 1
-  - 3
-  - 8
-  version: 1.3.8
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-06 00:00:00 Z
+date: 2012-05-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ratatouille
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: DSL for validating complex hashes