validatable 1.1.2 → 1.2.1

data/README

@@ -72,8 +72,37 @@ Similar to Rails, Validatable also supports conditional validation.
 	  validates_format_of :name, :with => /.+/, :if => Proc.new { !name.nil? }
 	end
 	Person.new.valid? #=> true
+		
+Validatable also exposes an after_validate hook method.
+
+	class Person
+	  include Validatable
+	  validates_presence_of :name
+	  attr_accessor :name
+	end
+	
+	class ValidatesPresenceOf
+	  after_validate do |result, instance, attribute|
+			instance.errors.add("#{attribute} can't be blank") unless result
+		end
+	end
+
+	person = Person.new
+	person.valid? #=> false
+	person.errors.on(:name) #=> "name can't be blank"
+	
+The after_validate hook yields the result of the validation being run, 
+the instance the validation was run on, and the attribute that was validate
+
+In the above example the attribute "name" is appended to the message.
 
 See the tests for more examples
 
 == Contributors
-Rick Bradley (Revision 25)
+Rick Bradley (Revision 25)
+
+Zak Tamsen (Revision 29)
+
+Jason Miller (Revision 31)
+
+Ali Aghareza (Revision 45)

data/lib/base.rb

@@ -18,6 +18,7 @@ module Validatable
     #     * level - The level at which the validation should occur
     #     * if - A block that when executed must return true of the validation will not occur
     #     * with - The regular expression used to validate the format
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
     def validates_format_of(*args)
       add_validations(args, ValidatesFormatOf) do |validation, options|
         validation.with = options[:with]
@@ -42,6 +43,7 @@ module Validatable
     #     * if - A block that when executed must return true of the validation will not occur
     #     * minimum - The minimum size of the attribute
     #     * maximum - The maximum size of the attribute
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
     def validates_length_of(*args)
       add_validations(args, ValidatesLengthOf) do |validation, options|
         validation.minimum = options[:minimum]
@@ -49,6 +51,26 @@ module Validatable
       end
     end
 
+    # call-seq: validates_numericality_of(*args)
+    # 
+    # Validates that the specified attribute is numeric.
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_numericality_of :age
+    #   end
+    # 
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    def validates_numericality_of(*args)
+      add_validations(args, ValidatesNumericalityOf)
+    end
+
     # call-seq: validates_acceptance_of(*args)
     #
     # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
@@ -65,6 +87,7 @@ module Validatable
     #     * times - The number of times the validation applies
     #     * level - The level at which the validation should occur
     #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
     def validates_acceptance_of(*args)
       add_validations(args, ValidatesAcceptanceOf)
     end
@@ -86,12 +109,20 @@ module Validatable
     #
     # Configuration options:
     # 
+    #     * case_sensitive - Whether or not to apply case-sensitivity on the comparison.  Defaults to true.
     #     * message - The message to add to the errors collection when the validation fails
     #     * times - The number of times the validation applies
     #     * level - The level at which the validation should occur
     #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
     def validates_confirmation_of(*args)
-      add_validations(args, ValidatesConfirmationOf)
+      add_validations(args, ValidatesConfirmationOf) do |validation, options|
+        validation.case_sensitive = if options.has_key? :case_sensitive
+          options[:case_sensitive]
+        else
+          true
+        end
+      end
     end
   
     # call-seq: validates_presence_of(*args)
@@ -111,11 +142,37 @@ module Validatable
     #     * times - The number of times the validation applies
     #     * level - The level at which the validation should occur
     #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
     def validates_presence_of(*args)
       add_validations(args, ValidatesPresenceOf)
     end
     
-    # call-seq: include_validations_for(*args)
+    # call-seq: validates_true_for(*args)
+    # 
+    # Validates that the logic evaluates to true
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_true_for :first_name, :logic => lambda { first_name == 'Jamie' }
+    #   end
+    #
+    # The logic option is required.
+    #
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    #     * logic - A block that executes to perform the validation
+    def validates_true_for(*args)
+      add_validations(args, ValidatesTrueFor) do |validation, options|
+        validation.logic = options[:logic]
+      end
+    end
+    
+    # call-seq: include_validations_for(attribute_to_validate, options = {})
     # 
     # Validates the specified attributes.
     #   class Person
@@ -126,7 +183,7 @@ module Validatable
     # 
     #   class PersonPresenter
     #     include Validatable
-    #     include_validations_for :person
+    #     include_validations_for :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
     #     attr_accessor :person
     #     
     #     def initialize(person)
@@ -136,11 +193,16 @@ module Validatable
     #   
     #   presenter = PersonPresenter.new(Person.new)
     #   presenter.valid? #=> false
-    #   presenter.errors.on(:name) #=> "can't be blank"
+    #   presenter.errors.on(:namen) #=> "can't be blank"
     #
     # The person attribute will be validated.  If person is invalid the errors will be added to the PersonPresenter errors collection.
-    def include_validations_for(*args)
-      children_to_validate.concat args
+    #
+    # Configuration options:
+    # 
+    #     * map - A hash that maps attributes of the child to attributes of the parent.
+    #     * if - A block that when executed must return true of the validation will not occur.
+    def include_validations_for(attribute_to_validate, options = {})
+      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
     end
     
     def validate(instance) #:nodoc:
@@ -155,12 +217,13 @@ module Validatable
       end
     end
     
-    def validate_children(instance) #:nodoc:
-      self.children_to_validate.each do |child_name|
-        child = instance.send child_name
-        child.valid?
+    def validate_children(instance, groups) #:nodoc:
+      self.children_to_validate.each do |child_validation|
+        next unless child_validation.should_validate?(instance)
+        child = instance.send child_validation.attribute
+        child.valid?(*groups)
         child.errors.each do |attribute, message|
-          instance.errors.add(attribute, message)
+          instance.errors.add(child_validation.map[attribute.to_sym] || attribute, message)
         end
       end
     end
@@ -191,10 +254,10 @@ module Validatable
   # call-seq: valid?
   #
   # Returns true if no errors were added otherwise false.
-  def valid?
+  def valid?(*groups)
     errors.clear
-    self.class.validate_children(self)
-    self.validate
+    self.class.validate_children(self, groups)
+    self.validate(groups)
     errors.empty?
   end
   
@@ -206,17 +269,25 @@ module Validatable
   end
   
   protected
-  def validate #:nodoc:
-    validation_levels.sort.each do |level|
-      validations_for_level(level).each do |validation|
-        if validation.should_validate?(self)
-          self.errors.add(validation.attribute, validation.message) unless validation.valid?(self)
+  def validate(groups) #:nodoc:
+    validations_for_groups(groups).each do |validation|
+      validation_levels.sort.each do |level|
+        validations_for_level(level).each do |validation|
+          if validation.should_validate?(self)
+            run_validation(validation)
+          end
         end
+        return unless self.errors.empty?
       end
-      return unless self.errors.empty?
     end
   end
   
+  def run_validation(validation) #:nodoc:
+    validation_result = validation.valid?(self)
+    self.errors.add(validation.attribute, validation.message) unless validation_result
+    validation.run_after_validate(validation_result, self, validation.attribute)
+  end
+  
   def validation_levels #:nodoc:
     self.validations.collect { |validation| validation.level }.uniq
   end
@@ -225,6 +296,11 @@ module Validatable
     self.validations.select { |validation| validation.level == level }
   end
   
+  def validations_for_groups(groups) #:nodoc:
+    return self.validations if groups.empty?
+    self.validations.select { |validation|  (groups & validation.groups).any? }
+  end
+  
   def validations #:nodoc:
     @validations ||= self.class.validations.collect { |validation| validation.dup }
   end

data/lib/child_validation.rb

@@ -0,0 +1,15 @@
+module Validatable
+  class ChildValidation #:nodoc:
+    attr_accessor :attribute, :map, :should_validate_proc
+    
+    def initialize(attribute, map, should_validate_proc)
+      @attribute = attribute
+      @map = map
+      @should_validate_proc = should_validate_proc
+    end
+    
+    def should_validate?(instance)
+      instance.instance_eval &should_validate_proc
+    end
+  end
+end

data/lib/errors.rb

@@ -2,7 +2,7 @@ module Validatable
   class Errors
     extend Forwardable
     
-    def_delegators :errors, :empty?, :clear, :each
+    def_delegators :errors, :any?, :clear, :each, :each_pair, :empty?, :length, :size
     
     # call-seq: on(attribute)
     # 
@@ -15,6 +15,11 @@ module Validatable
     def add(attribute, message) #:nodoc:
       errors[attribute.to_sym] = message
     end
+    
+    def merge!(errors) #:nodoc:
+      errors.each_pair{|k, v| add(k,v)}
+      self
+    end
 
     def errors #:nodoc:
       @errors ||= {}

data/lib/validatable.rb

@@ -1,9 +1,12 @@
 require 'forwardable'
 require File.expand_path(File.dirname(__FILE__) + '/errors')
 require File.expand_path(File.dirname(__FILE__) + '/base')
+require File.expand_path(File.dirname(__FILE__) + '/child_validation')
 require File.expand_path(File.dirname(__FILE__) + '/validations/validation_base')
 require File.expand_path(File.dirname(__FILE__) + '/validations/validates_format_of')
 require File.expand_path(File.dirname(__FILE__) + '/validations/validates_presence_of')
 require File.expand_path(File.dirname(__FILE__) + '/validations/validates_acceptance_of')
 require File.expand_path(File.dirname(__FILE__) + '/validations/validates_confirmation_of')
-require File.expand_path(File.dirname(__FILE__) + '/validations/validates_length_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_length_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_true_for')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_numericality_of')

data/lib/validations/validates_confirmation_of.rb

@@ -1,7 +1,10 @@
 module Validatable
   class ValidatesConfirmationOf < ValidationBase #:nodoc:
+    attr_accessor :case_sensitive
+    
     def valid?(instance)
-      instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym)
+      return instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
+      instance.send(self.attribute).to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
     end
     
     def message

data/lib/validations/validates_numericality_of.rb

@@ -0,0 +1,13 @@
+module Validatable 
+  class ValidatesNumericalityOf < ValidationBase #:nodoc:
+
+    def valid?(instance)
+      not (instance.send(self.attribute).to_s =~ /^\d*\.{0,1}\d+$/).nil?
+    end
+    
+    def message
+      super || "must be a number"
+    end
+  end
+end
+

data/lib/validations/validates_true_for.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesTrueFor < ValidationBase #:nodoc:
+    attr_accessor :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic) == true
+    end
+    
+    def message
+      super || "is invalid"
+    end
+  end
+end

data/lib/validations/validation_base.rb

@@ -1,7 +1,7 @@
 module Validatable
   class ValidationBase #:nodoc:
-    attr_accessor :attribute, :message
-    attr_reader :level
+    attr_accessor :attribute, :message, :times
+    attr_reader :level, :groups
     
     def initialize(attribute, options={})
       @attribute = attribute
@@ -9,6 +9,7 @@ module Validatable
       @conditional = options[:if] || Proc.new { true }
       @times = options[:times]
       @level = options[:level] || 1
+      @groups = options[:groups].is_a?(Array) ? options[:groups] : [options[:groups]]
     end
     
     def should_validate?(instance)
@@ -17,8 +18,29 @@ module Validatable
     
     def validate_this_time?
       return true if @times.nil?
-      @times -= 1
-      @times >= 0
+      self.times -= 1
+      self.times >= 0
+    end
+    
+    def run_after_validate(result, instance, attribute)
+      self.class.all_after_validations.each do |block|
+        block.call result, instance, attribute
+      end
+    end
+    
+    class << self
+      def after_validate(&block)
+        after_validations << block
+      end
+      
+      def after_validations
+        @after_validations ||= []
+      end
+      
+      def all_after_validations
+        return after_validations + self.superclass.after_validations if self.superclass.respond_to? :after_validations
+        after_validations
+      end
     end
   end
 end

data/rakefile.rb

@@ -29,7 +29,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
 	s.name   = "validatable"
   s.summary = "Validatable is a library for adding validations."
-	s.version = "1.1.2"
+	s.version = "1.2.1"
 	s.author = 'Jay Fields'
 	s.description = "Validatable is a library for adding validations."
 	s.email = 'validatable-developer@rubyforge.org'

data/test/functional/validatable_test.rb

@@ -22,6 +22,135 @@ module Functional
       assert_equal "can't be empty", instance.errors.on(:name)
     end
     
+    test "given a child class with validations, the error is in the parent objects error collection as the mapped attribute" do
+      child_class = Class.new do
+        include Validatable
+        attr_accessor :name, :address
+        validates_presence_of :name
+      end
+      klass = Class.new do
+        include Validatable
+        include_validations_for :child, :map => {:name => :namen}
+        define_method :child do
+          child_class.new
+        end
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "can't be empty", instance.errors.on(:namen)
+    end
+    
+    test "given a child class with validations, the error is in the parent objects error collection when the 'if' evals to true" do
+      child_class = Class.new do
+        include Validatable
+        attr_accessor :name, :address
+        validates_presence_of :name
+      end
+      klass = Class.new do
+        include Validatable
+        include_validations_for :child, :if => lambda { true }
+        define_method :child do
+          child_class.new
+        end
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "can't be empty", instance.errors.on(:name)
+    end
+    
+    test "given a child class with validations, the error is not in the parent objects error collection when the if evals to false" do
+      child_class = Class.new do
+        include Validatable
+        attr_accessor :name, :address
+        validates_presence_of :name
+      end
+      klass = Class.new do
+        include Validatable
+        include_validations_for :child, :if => lambda { false }
+        define_method :child do
+          child_class.new
+        end
+      end
+      instance = klass.new
+      assert_equal true, instance.valid?
+    end
+    
+    test "nonmatching groups are not used as validations" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        attr_accessor :name
+      end
+      instance = klass.new
+      assert_equal true, instance.valid?(:group_two)
+    end
+    
+    test "after validate is called following a validation" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name
+        attr_accessor :name
+      end
+      
+      Validatable::ValidationBase.class_eval do
+        after_validate do |result, instance, attribute|
+          instance.errors.add(attribute, instance.errors.on(attribute) + " changed message")
+        end
+      end
+      Validatable::ValidatesPresenceOf.class_eval do
+        after_validate do |result, instance, attribute|
+          instance.errors.add(attribute, instance.errors.on(attribute) + " twice")
+        end
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "can't be empty twice changed message", instance.errors.on(:name) 
+      Validatable::ValidatesPresenceOf.after_validations.clear
+      Validatable::ValidationBase.after_validations.clear
+    end
+
+    test "matching groups are used as validations when multiple groups are given to valid" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        attr_accessor :name
+      end
+      instance = klass.new
+      assert_equal false, instance.valid?(:group_one)
+    end
+    
+    test "matching groups are used as validations when validations are part of multiple groups" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => [:group_one, :group_two]
+        attr_accessor :name
+      end
+      instance = klass.new
+      assert_equal false, instance.valid?(:group_one)
+    end
+    
+    test "no group given then all validations are used" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        attr_accessor :name
+      end
+      instance = klass.new
+      assert_equal false, instance.valid?
+    end
+    
+    test "matching multiple groups for validations" do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        validates_presence_of :address, :groups => :group_two
+        attr_accessor :name, :address
+      end
+      instance = klass.new
+      instance.valid?(:group_one, :group_two)
+      assert_equal 2, instance.errors.size
+    end
+    
     expect true do
       klass = Class.new do
         include Validatable

data/test/functional/validates_confirmation_of_test.rb

@@ -14,5 +14,43 @@ module Functional
       instance.valid?
       assert_equal "doesn't match confirmation", instance.errors.on(:name)
     end
+
+    test "given matching attributes, when validated, then no error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name, :name_confirmation
+        validates_confirmation_of :name
+      end
+      instance = klass.new
+      instance.name = "foo"
+      instance.name_confirmation = "foo"
+      assert_equal true, instance.valid?
+    end
+
+    test "given matching attributes of different case, when validated with case sensitive false, then no error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name, :name_confirmation
+        validates_confirmation_of :name, :case_sensitive => false
+      end
+      instance = klass.new
+      instance.name = "foo"
+      instance.name_confirmation = "FOO"
+      assert_equal true, instance.valid?
+    end
+
+    test "given matching attributes of different case, when validated with case sensitive true, then error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name, :name_confirmation
+        validates_confirmation_of :name
+      end
+      instance = klass.new
+      instance.name = "foo"
+      instance.name_confirmation = "FOO"
+      assert_equal false, instance.valid?
+      assert_equal "doesn't match confirmation", instance.errors.on(:name)
+      
+    end
   end
 end

data/test/functional/validates_numericality_of_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+module Functional
+  class ValidatesNumericalityOfTest < Test::Unit::TestCase
+    test "when validating numericality and the value is nil an error should exist on the instance" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :nothing
+        validates_numericality_of :nothing
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "must be a number", instance.errors.on(:nothing)
+    end
+
+    test "when validating numericality and the value has a non numeric character an error should exist on the instance" do
+      klass = Class.new do
+        include Validatable
+        validates_numericality_of :some_string
+        
+        def some_string
+          "some_string"
+        end
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "must be a number", instance.errors.on(:some_string)
+    end
+    
+    test "when validating a number no error will be in the instance" do
+      klass = Class.new do
+        include Validatable
+        validates_numericality_of :valid_number
+        
+        def valid_number
+          1.23
+        end
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal nil, instance.errors.on(:valid_number)
+    end
+    
+  end
+end

data/test/functional/validates_true_for_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+module Functional
+  class ValidatesFormatOfTest < Test::Unit::TestCase
+    test "given invalid name, when validated, then error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_true_for :name, :logic => lambda { name == "nombre" }
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "is invalid", instance.errors.on(:name)
+    end
+
+    test "given valid name, when validated, then no error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_true_for :name, :logic => lambda { name == "nombre" }
+      end
+      instance = klass.new
+      instance.name = "nombre"
+      assert_equal true, instance.valid?
+    end
+  end
+end

data/test/unit/validatable_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 module Unit
   class ValidatableTest < Test::Unit::TestCase
     expect false do
-      validation = stub(:valid? => false, :should_validate? => true, :attribute => "attribute", :message => "message", :level => 1)
+      validation = stub(:valid? => false, :should_validate? => true, :attribute => "attribute", :message => "message", :level => 1, :run_after_validate => nil)
       klass = Class.new do
         include Validatable
         validations << validation
@@ -11,14 +11,6 @@ module Unit
       klass.new.valid?
     end
   
-    expect [:anything, :else] do
-      klass = Class.new do
-        include Validatable
-        include_validations_for :anything, :else
-      end
-      klass.send(:children_to_validate)
-    end
-  
     test "when validate is executed, then messages are added for each validation that fails" do
       klass = Class.new do
         include Validatable

data/test/unit/validates_confirmation_of_test.rb

@@ -12,4 +12,54 @@ class ValidatesConfirmationOfTest < Test::Unit::TestCase
     instance = stub(:username=>"username", :username_confirmation=>"usessrname")
     assert_equal false, validation.valid?(instance)
   end
+  
+  test "valid confirmation with case insensitive" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = false
+    instance = stub(:username=>"username", :username_confirmation=>"USERNAME")
+    assert_equal true, validation.valid?(instance)
+  end
+  
+  test "invalid confirmation with case sensitive" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = true
+    instance = stub(:username=>"username", :username_confirmation=>"USERNAME")
+    assert_equal false, validation.valid?(instance)
+  end
+  
+  test "invalid confirmation if value is nil and confirmation is not with case sensitive true" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = true
+    assert_equal false, validation.valid?(stub(:username => nil, :username_confirmation => 'something'))
+  end
+
+  test "invalid confirmation if confirmation is nil and value is not with case sensitive true" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = true
+    assert_equal false, validation.valid?(stub(:username => 'something', :username_confirmation => nil))
+  end
+
+  test "valid confirmation if value and confirmation are nil with case sensitive true" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = true
+    assert_equal true, validation.valid?(stub(:username => nil, :username_confirmation => nil))
+  end
+  
+  test "invalid confirmation if value is nil and confirmation is not with case sensitive false" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = false
+    assert_equal false, validation.valid?(stub(:username => nil, :username_confirmation => 'something'))
+  end
+
+  test "invalid confirmation if confirmation is nil and value is not with case sensitive false" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = false
+    assert_equal false, validation.valid?(stub(:username => 'something', :username_confirmation => nil))
+  end
+
+  test "valid confirmation if value and confirmation are nil with case sensitive false" do
+    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation.case_sensitive = false
+    assert_equal true, validation.valid?(stub(:username => nil, :username_confirmation => nil))
+  end
 end

data/test/unit/validates_numericality_of_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+module Unit
+  class ValidatesNumericalityOfTest < Test::Unit::TestCase
+ 
+    test "when the value is  nil then valid is false" do
+      validation = Validatable::ValidatesNumericalityOf.new :nothing
+      instance = stub(:nothing => nil)
+      assert_equal false, validation.valid?(instance)
+    end
+  
+    test "when value is an integer then valid is true" do
+      validation = Validatable::ValidatesNumericalityOf.new :some_int
+      instance = stub(:some_int => 50)
+      assert_equal true, validation.valid?(instance)
+    end  
+   
+    test "when value is an decimal then valid is true" do
+      validation = Validatable::ValidatesNumericalityOf.new :some_decimal
+      instance = stub(:some_decimal => 1.23)
+      assert_equal true, validation.valid?(instance)
+    end
+  
+    test "when value has non numeric characters then valid is false" do
+      validation = Validatable::ValidatesNumericalityOf.new :some_non_numeric
+      instance = stub(:some_non_numeric => "50F")
+      assert_equal false, validation.valid?(instance)
+    end
+  
+    test "when value is a string with multiple dots then valid is false" do
+      validation = Validatable::ValidatesNumericalityOf.new :multiple_dots
+      instance = stub(:multiple_dots => "50.0.0")
+      assert_equal false, validation.valid?(instance)
+    end
+  end
+end

data/test/unit/validates_true_for_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ValidatesTrueForTest < Test::Unit::TestCase
+  test "when block returns false for attribute value, then valid is false" do
+    validation = Validatable::ValidatesTrueFor.new :name
+    validation.logic = lambda { false }
+    assert_equal false, validation.valid?(stub_everything)
+  end
+  
+  test "when block returns true for attribute value, then valid is false" do
+    validation = Validatable::ValidatesTrueFor.new :name
+    validation.logic = lambda { true }
+    assert_equal true, validation.valid?(stub_everything)
+  end
+  
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.2
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.1.2
-date: 2007-03-25 00:00:00 -04:00
+  version: 1.2.1
+date: 2007-04-26 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib
@@ -25,17 +25,21 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Jay Fields
 files: 
 - lib/base.rb
+- lib/child_validation.rb
 - lib/errors.rb
 - lib/validatable.rb
 - lib/validations/validates_acceptance_of.rb
 - lib/validations/validates_confirmation_of.rb
 - lib/validations/validates_format_of.rb
 - lib/validations/validates_length_of.rb
+- lib/validations/validates_numericality_of.rb
 - lib/validations/validates_presence_of.rb
+- lib/validations/validates_true_for.rb
 - lib/validations/validation_base.rb
 - test/all_tests.rb
 - test/test_helper.rb
@@ -44,14 +48,18 @@ files:
 - test/functional/validates_confirmation_of_test.rb
 - test/functional/validates_format_of_test.rb
 - test/functional/validates_length_of_test.rb
+- test/functional/validates_numericality_of_test.rb
 - test/functional/validates_presence_of_test.rb
+- test/functional/validates_true_for_test.rb
 - test/unit/errors_test.rb
 - test/unit/validatable_test.rb
 - test/unit/validates_acceptance_of_test.rb
 - test/unit/validates_confirmation_of_test.rb
 - test/unit/validates_format_of_test.rb
 - test/unit/validates_length_of_test.rb
+- test/unit/validates_numericality_of_test.rb
 - test/unit/validates_presence_of_test.rb
+- test/unit/validates_true_for_test.rb
 - test/unit/validation_base_test.rb
 - rakefile.rb
 - README