ratatouille 1.3.0 → 1.3.2

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.3.2
+
+### Updates
+
+* is\_empty and is\_not\_empty have been moved to generic ghost methods in the Ratifier object that also support other boolean methods.
+  * Say you have Object#foo?, you can use **is\_foo** and **is\_not\_foo** for validation against that boolean method
+* **:is\_a** added as option to perform class validation prior to the core method logic for the following methods:
+  * HashMethod#given_key
+  * HashMethod#required_key
+
 ## 1.3.0 (API Change!)
 
 ### Updates

data/lib/ratatouille/array.rb

@@ -2,47 +2,6 @@ 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(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?
-    rescue Exception => e
-      validation_error("#{e.message}")
-    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(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?
-    rescue Exception => e
-      validation_error("#{e.message}")
-    end#is_not_empty
-
-
     # Define Minimum Length of Array
     # 
     # @param [Integer] min_size
@@ -52,7 +11,9 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def min_length(min_size=0, options={}, &block)
-      unless options.fetch(:unwrap_block, false) == true
+      parse_options(options)
+
+      unless @unwrap_block == true
         # Wrapped Validation
         return unless valid_min_length?(min_size)
       end
@@ -72,7 +33,9 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def max_length(max_size=0, options={}, &block)
-      unless options.fetch(:unwrap_block, false) == true
+      parse_options(options)
+
+      unless @unwrap_block == true
         # Wrapped Validation
         return unless valid_max_length?(max_size)
       end
@@ -93,7 +56,9 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def length_between(min_size=0, max_size=nil, options={}, &block)
-      unless options.fetch(:unwrap_block, false) == true
+      parse_options(options)
+
+      unless @unwrap_block == true
         # Wrapped Validation
         return unless valid_min_length?(min_size)
 

data/lib/ratatouille/hash.rb

@@ -16,19 +16,22 @@ module Ratatouille
     #
     # @param [String, Symbol] key
     # @param [Hash] options
+    # @option options [Class] :is_a (nil) 
+    #   Used to ensure that the value of the required key is of the given class.
+    #   * Performed before all other validation (if defined).
+    #   * Validation will be skipped if option not defined.
     # @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) )
 
-      unless options.fetch(:unwrap_block, false) == true
-        # Wrapped Validation
-        if options.fetch(:required, false) == true
+      parse_options(options)
+
+      unless @unwrap_block == true
+        # WRAPPED VALIDATION
+        if @required == true
           unless @ratifiable_object.has_key?(key)
             validation_error("Missing key #{key.inspect}")
             return
@@ -36,57 +39,48 @@ module Ratatouille
         end
       end
 
-      if @ratifiable_object.has_key?(key) && block_given?
-        child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], options, &block)
-        @errors[key] = child_object.errors unless child_object.valid?
-      end
-    rescue Exception => e
-      validation_error("#{e.message}")
-    end#given_key
-
+      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
+            end
+          end
+        end
 
-    # 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(options={}, &block)
-      unless options.fetch(:unwrap_block, false) == true
-        # Wrapped Validation
-        unless @ratifiable_object.empty?
-          validation_error("not empty")  
-          return
+        if block_given?
+          child_object = Ratatouille::Ratifier.new(@ratifiable_object[key], options, &block)
+          @errors[key] = child_object.errors unless child_object.valid?
         end
       end
-
-      instance_eval(&block) if block_given?
     rescue Exception => e
       validation_error("#{e.message}")
-    end#is_empty
+    end#given_key
 
 
-    # Self-explanatory
+    # 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] :unwrap_block (false) 
-    #   Perform block validation only -- skip is_not_empty validation logic.
-    #   Useless unless block provided
+    # @option options [Class] :is_a (nil) 
+    #   Used to ensure that the value of the required key is of the given class.
+    #   * Performed before all other validation (if defined).
+    #   * Validation will be skipped if option not defined.
+    # @option options [Boolean] :required (true) Used to call given_key.
     # @return [void]
-    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?
+    def required_key(key, options={}, &block)
+      options[:required] = true
+      # Pass on processing to given_key with :required => true option
+      given_key(key, options, &block)
     rescue Exception => e
       validation_error("#{e.message}")
-    end#is_not_empty
+    end
 
 
     # Provide a list of keys that must be present in the Hash to validate. 
@@ -110,7 +104,9 @@ module Ratatouille
     #   Useless unless block provided
     # @return [void]
     def required_keys(options={}, &block)
-      unless options.fetch(:unwrap_block, false) == true
+      parse_options(options)
+
+      unless @unwrap_block == true
         req_keys = options.fetch(:key_list, [])
 
         # Wrapped Validation
@@ -140,25 +136,6 @@ module Ratatouille
     end#required_keys
 
 
-    # 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
-      # Pass on processing to given_key with :required => true option
-      given_key(key, options, &block)
-    rescue Exception => e
-      validation_error("#{e.message}")
-    end
-
-
     # 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.
@@ -184,10 +161,10 @@ module Ratatouille
     #   Perform block validation only -- skip choice_of validation logic.
     #   Useless unless block provided
     # @return [void]
-    def choice_of(options, &block)
-      options ||= {}
+    def choice_of(options={}, &block)
+      parse_options(options)
 
-      unless options.fetch(:unwrap_block, false) == true
+      unless @unwrap_block == true
         choice_size = options.fetch(:choice_size, 1)
         key_list = options.fetch(:key_list, [])
 

data/lib/ratatouille/ratifier.rb

@@ -140,6 +140,55 @@ module Ratatouille
     rescue Exception => e
       validation_error("#{e.message}", "/")
     end#is_a?
+
+
+    # Parse out common options into instance_variables for use within the
+    # validation methods defined in various places.
+    #
+    # @param [Hash] options
+    # @option options [Boolean] :unwrap_block (false)
+    #   Perform block validation only -- skip method validation logic.
+    def parse_options(options={})
+      @unwrap_block = options.fetch(:unwrap_block, false)
+      @is_a = options.fetch(:is_a, nil)
+      @required = options.fetch(:required, false)
+    end#parse_options
+
+
+    # Override Method Missing for a Ratifier to generate errors for invalid
+    # 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}")
+          end
+        end
+      when id.to_s =~ /^is_(.*)$/
+        if @ratifiable_object.respond_to?("#{$1}?")
+          if @ratifiable_object.send("#{$1}?") == false
+            validation_error("is not #{$1}")
+          end
+        end
+      else
+        validation_error("#{id} is not supported for the given object (#{@ratifiable_object.class})")
+      end
+
+      instance_eval(&block) if block_given?
+      return
+    end#method_missing
   end#Ratifier
 
 end

data/lib/ratatouille/version.rb

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

data/spec/lib/ratatouille/array_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
 describe "Ratatouille::ArrayMethods" do
-  [ :is_empty, 
-    :is_not_empty, 
-    :min_length, 
+  [ :min_length, 
     :max_length, 
     :length_between
   ].each do |m|

data/spec/lib/ratatouille/hash_spec.rb

@@ -1,42 +1,56 @@
 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
+  [ :choice_of,
+    :required_keys,
+    :required_key,
+    :given_key
+  ].each do |m|
+    it "block context should respond to #{m}" do
+      r = nil
+      RatifierTest.new({}) { r = self }
+      r.should respond_to m
     end
+  end
 
-    it "should be valid for empty Hash" do
-      RatifierTest.new({}){ is_empty }.should be_valid
-    end
+  describe "(backward compatibility)" 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
 
-    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
+      it "should be valid for empty Hash" do
+        RatifierTest.new({}){ is_empty }.should be_valid
       end
-    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
+      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
 
-    it "should not be valid for empty hash" do
-      RatifierTest.new({}){ is_not_empty }.should_not be_valid
-    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
 
-    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
+      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
   end
@@ -173,6 +187,24 @@ describe "Ratatouille::HashMethods" do
         }.should be_valid
       end
     end
+
+    describe "when :is_a is given" do
+      it "should be valid with matching key value class" do
+        RatifierTest.new({:foo => "bar"}){
+          required_key(:foo, :class => String) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should be_valid
+      end
+
+      it "should be invalid with non-matching key value class" do
+        RatifierTest.new({:foo => "bar"}){
+          required_key(:foo, :is_a => Hash) do
+            # Nothing to validate, wrapper ignored
+          end
+        }.should_not be_valid
+      end
+    end
   end
 
   describe "given_key" do

data/spec/lib/ratatouille/ratifier_spec.rb

@@ -17,6 +17,20 @@ describe Ratatouille::Ratifier do
     x['/'].should be_empty
   end
 
+  describe "when attempting to call an undefined method" do
+    it "should be invalid to call required_keys on an Array" do
+      RatifierTest.new([]){ 
+        required_keys(:key_list => [:foo]) 
+      }.should_not be_valid
+    end
+
+    it "should be invalid to call required_keys on an Object" do
+      RatifierTest.new(Object.new){ 
+        required_keys(:key_list => [:foo]) 
+      }.should_not be_valid
+    end
+  end
+
   describe "validation_error" do
     it "should create an error when called within a Ratifier block" do
       test = RatifierTest.new(Object.new) do
@@ -178,4 +192,22 @@ describe Ratatouille::Ratifier do
       end
     end
   end
+
+  describe "method_missing" do
+    describe "for non-standard boolean methods" do
+      it "should render object invalid for given method" do
+        obj = Object.new
+        obj.stub(:foo?).and_return(false)
+        RatifierTest.new(obj) { is_foo }.should_not be_valid
+        RatifierTest.new(obj) { is_not_foo }.should be_valid
+      end
+
+      it "should render object valid for given method" do
+        obj = Object.new
+        obj.stub(:bar?).and_return(true)
+        RatifierTest.new(obj) { is_bar }.should be_valid
+        RatifierTest.new(obj) { is_not_bar }.should_not be_valid
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ratatouille
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 31
   prerelease: 
   segments: 
   - 1
   - 3
-  - 0
-  version: 1.3.0
+  - 2
+  version: 1.3.2
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-20 00:00:00 Z
+date: 2012-04-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec