ratatouille 1.2.6 → 1.3.0

data/CHANGELOG.md

@@ -1,25 +1,46 @@
+## 1.3.0 (API Change!)
+
+### Updates
+
+* All Methods have been modified to accept optional hashes as arguments
+  * This is to provide better flexibility with future versions of the API.
+  * NOTE: As such, some methods have been updated to conform to this new call format. See README for details.
+* Optional key, **:unwrap_block** supported by all methods. 
+  * See README for details.
+
 ## 1.2.6
 
+### Updates
+
 * CHANGELOG added
 * required\_key logic moved to given\_key and triggered with a :required => true option
   * required\_key now calls given_key with :required => true
 
 ## 1.2.5
 
-* required\_key fixed so that block behaves like given\_key block, by diving into the context of the key value
+### Corrections
+
+* required\_key fixed so that block behaves like given\_key block, by diving into the 
+  context of the key value
 
 ## 1.2.4
 
-* required\_key added to HashMethods
+### Updates
+
+* **required\_key** added to HashMethods
 * Additional Tests
 
 ## 1.2.2
 
-* is\_a? method added to HashMethods
+### Updates
+
+* **is\_a?** method added to HashMethods
 * Additional Tests
 
 ## 1.2.0
 
+### Updates
+
 * Added Ratatouille::Ratifier name attribute for use with dynamically changing scoped errors.
 * The current Ratifier name (in scope of the validation block) will be appended to errors created
   in the direct context of that block.
@@ -28,12 +49,17 @@
 
 ## 1.1.1
 
+### Corrections
+
 * choice\_of validation errors show semantically correct key names (Symbols, Strings, etc.)
 * choice\_of tweaked/fixed to perform proper validation on list of keys
 
 ## 1.0.0
 
 * Not to be mistaken by 0.1.0
+
+### Updates
+
 * Plethora of tests added
 * Refactoring Code
 * Organization and Documentation

data/README.md

@@ -5,6 +5,7 @@ DSL for validation of complex Hashes
 ## Travis CI Status: 
 [![Build Status](https://secure.travis-ci.org/CITguy/ratatouille.png?branch=master)](http://travis-ci.org/CITguy/ratatouille)
 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,6 +22,11 @@ Or install it yourself as:
 
 
 
+## Information
+
+Specific uses and syntax can be found in the documentation of each module. The information defined
+here is common information amongst the entirety of the ratatouille gem.
+
 ## 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.
@@ -35,223 +41,72 @@ This will change when using *given\_key*.
 
 ### name
 
-Within a block, the name method provides the name of the scope. This can be used in your custom validation messages.
-
+Within a block, the **name** method provides the name of the scope. 
+This can be used in your custom validation messages and is already prepended to the beginning
+of every validation error.
 
 
-## Usage
 
-All of the following methods perform validation on the *ratifiable\_object* defined in scope of the block.
+## Custom Validation
 
+**Return to this section after reading the remaining sections.**
 
-### is\_a?
+Custom validation can take place using the following methods to generate custom validation logic that cannot be satisfied with the existing methods.
 
-Method to check if ratifiable\_object matches given class. Will not validate without a given class.
+You should use the **validation\_error** method to add your own errors to the Ratifier object.
 
 
-### given\_key
+### validation\_error
 
-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*.
+Used to insert validation error message into the Ratifier 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)
+* Scope name prepended to every validation error
 
 
 #### 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
+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
-    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)
+    validation_error("This is an error")
+    validation_error("This is an error", "current_context")
 ```
 
 
-### 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
+## Universal Options
 
-    # Validate that the keys exist
-    required_keys(:foo, :bar)
-```
+### :unwrap\_block
 
+This optional key, when set to true, will skip the wrapped validation provided in the called
+method and run the validations contained in its given block (if any). This is useful
+if previous validation results dictate further validation logic.
 
 #### 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
-```
-
-
-
-### required\_key
-
-Used to ensure given key exists in the Hash.
-
-* Eliminates the need to perform "given\_key" methods within a "required\_keys" block.
-* Evaluates an optional block in context of key value (same as given\_key)
-
-
-#### Syntax
+*A choice of :bar or :biz is required only if :foo is 'green', 
+otherwise :bar and :biz should be validated if they are present.*
 
 ```ruby
-    # Validate that the keys exist and perform validation if they do
+  ratify({:foo => "red"}) do
     required_key(:foo) do
-      # Validation provided that :foo exists in Hash
+      unwrap_choice = true
+      unwrap_choice = false if ratifiable_object == 'green'
     end
 
-    # Validate that the keys exist
-    required_key(:foo)
-```
-
-
-
-### 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
+    # Because :foo is 'red', choice_of logic will be ignored and the block will be entered.
+    choice_of(:key_list => [:bar, :biz], :unwrap_block => unwrap_choice) do
+      given_key(:bar) do
+        # :bar validation
       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
+      given_key(:biz) do
+        # :biz validation
       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.
-
-* Scope name prepended to every validation error
-
-
-#### 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")
+    # If :foo were 'green', choice_of logic would be performed before entering the block.
+  end
 ```
 
 
@@ -277,6 +132,8 @@ It is also possible to set the context of an error by passing in a second argume
     r.valid? # => false
 ```
 
+
+
 ## Contributing
 
 1. Fork it

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/lib/ratatouille/array.rb

@@ -2,11 +2,19 @@ module Ratatouille
 
   # Module used to provide Array-specific validation methods
   module ArrayMethods
+
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip is_empty validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def is_empty(&block)
-      unless @ratifiable_object.empty?
-        validation_error("not empty")  
-        return
+    def is_empty(options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        unless @ratifiable_object.empty?
+          validation_error("not empty")  
+          return
+        end
       end
 
       instance_eval(&block) if block_given?
@@ -15,11 +23,18 @@ module Ratatouille
     end#is_empty
 
 
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip is_not_empty validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def is_not_empty(&block)
-      if @ratifiable_object.empty?
-        validation_error("empty")
-        return
+    def is_not_empty(options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        if @ratifiable_object.empty?
+          validation_error("empty")
+          return
+        end
       end
 
       instance_eval(&block) if block_given?
@@ -31,9 +46,16 @@ module Ratatouille
     # Define Minimum Length of Array
     # 
     # @param [Integer] min_size
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip min_length validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def min_length(min_size=0, &block)
-      return unless valid_min_length?(min_size)
+    def min_length(min_size=0, options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        return unless valid_min_length?(min_size)
+      end
 
       instance_eval(&block) if block_given?
     rescue Exception => e
@@ -43,10 +65,17 @@ module Ratatouille
 
     # Define Maximum Length of Array
     #
-    # @param [Integer] min_size
+    # @param [Integer] max_size
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip max_length validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def max_length(max_size=0, &block)
-      return unless valid_max_length?(max_size)
+    def max_length(max_size=0, options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        return unless valid_max_length?(max_size)
+      end
 
       instance_eval(&block) if block_given?
     rescue Exception => e
@@ -58,26 +87,33 @@ module Ratatouille
     #
     # @param [Integer] min_size
     # @param [Integer] max_size
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip length_between validation logic.
+    #   Useless unless block provided
     # @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
+    def length_between(min_size=0, max_size=nil, options={}, &block)
+      unless options.fetch(:unwrap_block, false) == 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")
+            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
       end
 
@@ -85,8 +121,10 @@ module Ratatouille
     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
@@ -104,6 +142,7 @@ module Ratatouille
       return false
     end
 
+    # @note Supporting Method
     # @return [Boolean]
     def valid_max_length?(max_size)
       unless max_size.to_i >= 0

data/lib/ratatouille/hash.rb

@@ -1,18 +1,38 @@
 module Ratatouille
 
   # Module used to provide Hash-specific validation methods
+  #
+  # All of the Hash methods perform validation on the *ratifiable_object* defined in 
+  # scope of their given block.
   module HashMethods
-    # Runs validation in block against object for the given key.
+    # Runs validation in block against object for the given key. It 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.
     #
     # @param [String, Symbol] key
     # @param [Hash] options
+    # @option options [String, Symbol] :name (key.to_s)
+    #   Name of ratifiable_object for use with validation error messages.
+    # @option options [Boolean] :required (false) 
+    #   Ensure that ratifiable_object has the given key
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip is_empty validation logic.
+    #   Useless unless block provided
     def given_key(key, options={}, &block)
       options[:name] = options.fetch(:name, (Symbol === key ? ":#{key}" : key.to_s) )
 
-      if options.fetch(:required, false) == true
-        unless @ratifiable_object.has_key?(key)
-          validation_error("Missing key #{key.inspect}")
-          return
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        if options.fetch(:required, false) == true
+          unless @ratifiable_object.has_key?(key)
+            validation_error("Missing key #{key.inspect}")
+            return
+          end
         end
       end
 
@@ -25,11 +45,20 @@ module Ratatouille
     end#given_key
 
 
+    # Self-explanatory
+    #
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false) 
+    #   Perform block validation only -- skip is_empty validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def is_empty(&block)
-      unless @ratifiable_object.empty?
-        validation_error("not empty")  
-        return
+    def is_empty(options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        unless @ratifiable_object.empty?
+          validation_error("not empty")  
+          return
+        end
       end
 
       instance_eval(&block) if block_given?
@@ -38,11 +67,20 @@ module Ratatouille
     end#is_empty
 
 
+    # Self-explanatory
+    #
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false) 
+    #   Perform block validation only -- skip is_not_empty validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def is_not_empty(&block)
-      if @ratifiable_object.empty?
-        validation_error("empty")      
-        return
+    def is_not_empty(options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        # Wrapped Validation
+        if @ratifiable_object.empty?
+          validation_error("empty")
+          return
+        end
       end
 
       instance_eval(&block) if block_given?
@@ -51,29 +89,49 @@ module Ratatouille
     end#is_not_empty
 
 
-    # Provide a list of keys that must be present in the Hash to validate. Otherwise,
-    # an error will be added.
+    # Provide a list of keys that must be present in the Hash to validate. 
+    # Otherwise, an error will be added.
+    #
+    # * block is optional
     #
-    # @param [Array] args Array required keys
+    # *NOTE:* Due to the addition of the optional hash in 1.3.0, required\_keys has been modified 
+    # considerably and will break compatibility with previous versions of Ratatouille code.
+    #
+    # @example pre 1.3.0 vs 1.3.0+
+    #   # Old Way
+    #   required_keys(:foo, :bar) { validation_here }
+    #   # New Way
+    #   required_keys(:key_list => [:foo, :bar]) { validation_here }
+    #
+    # @param [Hash] options
+    # @option options [Array] :key_list ([]) Required Keys
+    # @option options [Boolean] :unwrap_block (false) 
+    #   Perform block validation only -- skip required_keys validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def required_keys(*req_keys, &block)
-      common_keys = (@ratifiable_object.keys & req_keys)
+    def required_keys(options={}, &block)
+      unless options.fetch(:unwrap_block, false) == true
+        req_keys = options.fetch(:key_list, [])
 
-      if @ratifiable_object.empty?
-        validation_error("Cannot find required keys")
-        return
-      end
+        # Wrapped Validation
+        common_keys = (@ratifiable_object.keys & req_keys)
 
-      if req_keys.nil? || req_keys.empty?
-        validation_error("No required keys given to compare against.")
-        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
 
-      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
 
       instance_eval(&block) if block_given?
@@ -82,10 +140,15 @@ module Ratatouille
     end#required_keys
 
 
-    # Perform validation on a key that must be present in the Hash to validate. Otherwise,
-    # an error will be added.
+    # Perform validation on a single key that must be present in the Hash to validate. 
+    # Otherwise, an error will be added.
+    #
+    # * Eliminates the need to perform given_key methods within a required_keys block.
+    # * Evaluates an optional block in context of key value (same as given_key)
     #
     # @param key Required Key
+    # @param [Hash] options
+    # @option options [Boolean] :required (true) Used to call given_key.
     # @return [void]
     def required_key(key, options={}, &block)
       options[:required] = true
@@ -96,57 +159,81 @@ module Ratatouille
     end
 
 
-    # Provide a list of keys to choose from and a choice size (default 1). 
+    # Provide a list of keys to choose from and a choice size. 
     # 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.
+    # *NOTE:* Due to the addition of the optional hash in version 1.3.0, choice\_of has been modified 
+    # considerably and will break compatibility with previous versions of Ratatouille code.
+    #
+    # @example pre 1.3.0 vs 1.3.0+
+    #   # Old Way
+    #   choice_of(1, :foo, :bar) { validation_here }
+    #   # New Way
+    #   choice_of(:key_list => [:foo, :bar]) { validation_here }
+    #
+    #   # Old Way
+    #   choice_of(2, :foo, :bar, :biz) { validation_here }
+    #   # New Way
+    #   choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz]) { validation_here }
+    #
+    # @param [Hash] options
+    # @option options [Integer] :choice_size (1) Number of choices required
+    # @option options [Array] :key_list ([]) Keys to choose from
+    # @option options [Boolean] :unwrap_block (false) 
+    #   Perform block validation only -- skip choice_of validation logic.
+    #   Useless unless block provided
     # @return [void]
-    def choice_of(choice_size=1, *key_list, &block)
-      if key_list.nil? || key_list.empty?
-        validation_error("choice_of requires a key list to choose from")
-        return
-      end
-      key_list.flatten!
+    def choice_of(options, &block)
+      options ||= {}
 
-      # 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")
+      unless options.fetch(:unwrap_block, false) == 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
-      else
-        unless choice_size.respond_to?(:to_i)
-          validation_error("choice_of requires an object that responds to :to_i for choice size")
-          return
+        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
-        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 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
+        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
 
       instance_eval(&block) if block_given?

data/lib/ratatouille/ratifier.rb

@@ -25,6 +25,9 @@ module Ratatouille
       @errors.freeze
     end#initialize
 
+    # Alias method (much shorter to type)
+    alias :ro :ratifiable_object
+
 
     # Name of instance
     #
@@ -118,7 +121,8 @@ module Ratatouille
     end#errors_array
 
 
-    # Validate against ratifiable_object class
+    # Method to check if ratifiable_object matches given class.
+    # Will not validate without class.
     #
     # @param [Class] klass
     def is_a?(klass=nil, &block)

data/lib/ratatouille/version.rb

@@ -1,4 +1,4 @@
 module Ratatouille
   # Gem Version
-  VERSION = "1.2.6"
+  VERSION = "1.3.0"
 end

data/ratatouille.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rspec", ">= 2.4.0"
   gem.add_development_dependency "rake"
+  gem.add_development_dependency "autotest"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/lib/ratatouille/hash_spec.rb

@@ -9,6 +9,16 @@ describe "Ratatouille::HashMethods" do
     it "should be valid for empty Hash" do
       RatifierTest.new({}){ is_empty }.should be_valid
     end
+
+    describe "when :unwrap_block is true" do
+      it "should be valid for non-empty Hash" do
+        RatifierTest.new({:bar => 'biz'}){ 
+          is_empty(:unwrap_block => true) do
+            # Nothing to validate, wrapper ignored.
+          end
+        }.should be_valid
+      end
+    end
   end
 
   describe "is_not_empty" do
@@ -19,47 +29,113 @@ describe "Ratatouille::HashMethods" do
     it "should not be valid for empty hash" do
       RatifierTest.new({}){ 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({}){ 
+          is_not_empty(:unwrap_block => true) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should be_valid
+      end
+    end
   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
+
     it "should be invalid if key list is empty" do
-      RatifierTest.new({}) { choice_of(1, []) }.should_not be_valid
+      RatifierTest.new({}) { 
+        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(0, [:foo]) }.should_not be_valid
+      RatifierTest.new({}) { 
+        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(1, [:foo]) }.should_not be_valid
+      RatifierTest.new({}) { 
+        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(1, [:foo, :bar]) }.should be_valid
+      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(2, [:foo, :bar, :biz]) 
+        choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz]) 
       }.should be_valid
 
       RatifierTest.new({:foo => "foo", :bar => "bar"}){ 
-        choice_of(2, [:foo, :bar, :biz, :bang]) 
+        choice_of(:choice_size => 2, :key_list => [:foo, :bar, :biz, :bang]) 
       }.should be_valid
     end
+
+    describe "when :unwrap_block is true" do
+      it "should be valid when used on empty Hash" do
+        RatifierTest.new({}){
+          choice_of(:key_list => [:foo, :bar], :unwrap_block => true) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should be_valid
+
+        RatifierTest.new({}){
+          choice_of(:key_list => [:foo, :bar]) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should_not be_valid
+      end
+    end
   end
 
   describe "required_keys" do
     it "should be valid if Hash contains all required keys" do
-      RatifierTest.new({:foo => "foo"}) { required_keys(:foo, :bar) }.should_not be_valid
+      RatifierTest.new({:foo => "foo"}) { 
+        required_keys(:key_list => [:foo, :bar]) 
+      }.should_not be_valid
+
+      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({}) { required_keys(:foo) }.should_not be_valid
+      RatifierTest.new({}) { 
+        required_keys(:key_list => [: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
+      RatifierTest.new({:foo => "foo"}) { 
+        required_keys(:key_list => [:foo, :bar]) 
+      }.should_not be_valid
+    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
+        }.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
 
@@ -87,6 +163,16 @@ describe "Ratatouille::HashMethods" do
       end
       n.should == ":foo"
     end
+
+    describe "when :unwrap_block is true" do
+      it "should be valid when used on empty Hash" do
+        RatifierTest.new({}){
+          required_key(:foo, :unwrap_block => true) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should be_valid
+      end
+    end
   end
 
   describe "given_key" do
@@ -108,6 +194,14 @@ describe "Ratatouille::HashMethods" do
       n.should == "None"
     end
 
+    it "block should respond to :ro" do
+      responded = false
+      RatifierTest.new({:foo => "bar"}, :name => "Outer") do
+        responded = self.respond_to?(:ro)
+      end
+      responded.should be_true
+    end
+
     it "should not change the outer scope's name" do
       o = n = ""
       RatifierTest.new({:foo => "bar"}) do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratatouille
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 27
   prerelease: 
   segments: 
   - 1
-  - 2
-  - 6
-  version: 1.2.6
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-16 00:00:00 Z
+date: 2012-04-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -47,6 +47,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: DSL for validating complex hashes
 email: 
 - rhino.citguy@gmail.com
@@ -65,6 +79,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- autotest/discover.rb
 - lib/ratatouille.rb
 - lib/ratatouille/array.rb
 - lib/ratatouille/hash.rb