validatable 1.3.4 → 1.4.0

data/README

@@ -115,4 +115,4 @@ In the above example the attribute "name" is appended to the message.
 See the tests for more examples
 
 == Contributors
-Rick Bradley, Anonymous Z, Jason Miller, Ali Aghareza, Xavier Shay, Dan Manges, Karthik Krishnan and Venkat
+Rick Bradley, Anonymous Z, Jason Miller, Ali Aghareza, Xavier Shay, Dan Manges, Karthik Krishnan and Venkat, Clint Bishop

data/lib/validatable_class_methods.rb

@@ -195,11 +195,15 @@ module Validatable
       children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
     end
     
-    def validate_children(instance, groups) #:nodoc:
+    def validate_children(instance, group) #: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)
+        if (child.respond_to?(:valid_for_group?))
+          child.valid_for_group?(group)
+        else
+          child.valid?
+        end
         child.errors.each do |attribute, messages|
           if messages.is_a?(String)
             add_error(instance, child_validation.map[attribute.to_sym] || attribute, messages)
@@ -220,12 +224,16 @@ module Validatable
       instance.errors.add(attribute, msg)
     end
     
+    def validation_keys_include?(key)
+      validations.map { |validation| validation.key }.include?(key)
+    end
+    
     protected
     
     def add_validations(args, klass) #:nodoc:
       options = args.last.is_a?(Hash) ? args.pop : {}
       args.each do |attribute|
-        new_validation = klass.new attribute, options
+        new_validation = klass.new self, attribute, options
         self.validations << new_validation
         self.create_valid_method_for_groups new_validation.groups
       end

data/lib/validatable_instance_methods.rb

@@ -17,17 +17,35 @@ module Validatable
     @errors ||= Validatable::Errors.new
   end
   
-  protected
-  def valid_for_group?(*groups) #:nodoc:
+  def valid_for_group?(group=nil) #:nodoc:
     errors.clear
-    self.class.validate_children(self, groups)
-    self.validate(groups)
+    self.class.validate_children(self, group)
+    self.validate(group)
     errors.empty?
   end
+  
+  def times_validated(key)
+    times_validated_hash[key] || 0
+  end
+  
+  def times_validated_hash
+    @times_validated_hash ||= {}
+  end
+  
+  def increment_times_validated_for(validation)
+    if validation.key != nil
+      if times_validated_hash[validation.key].nil?
+        times_validated_hash[validation.key] = 1
+      else
+        times_validated_hash[validation.key] += 1
+      end
+    end
+  end
 
-  def validate(groups) #:nodoc:
+  protected
+  def validate(group) #:nodoc:
     validation_levels.each do |level|
-      validations_for_level_and_groups(level, groups).each do |validation|
+      validations_for_level_and_group(level, group).each do |validation|
         run_validation(validation) if validation.should_validate?(self)
       end
       return unless self.errors.empty?
@@ -37,6 +55,7 @@ module Validatable
   def run_validation(validation) #:nodoc:
     validation_result = validation.valid?(self)
     add_error(validation.attribute, validation.message(self)) unless validation_result
+    increment_times_validated_for(validation)
     validation.run_after_validate(validation_result, self, validation.attribute)
   end
   
@@ -44,17 +63,13 @@ module Validatable
     self.class.add_error(self, attribute, message)
   end
   
-  def validations_for_level_and_groups(level, groups) #:nodoc:
-    validations_for_level = self.validations.select { |validation| validation.level == level }
-    return validations_for_level if groups.empty?
-    validations_for_level.select { |validation| (groups & validation.groups).any? }
+  def validations_for_level_and_group(level, group) #:nodoc:
+    validations_for_level = self.class.validations.select { |validation| validation.level == level }
+    return validations_for_level if group.nil?
+    validations_for_level.select { |validation| validation.groups.include?(group) }
   end
   
   def validation_levels #:nodoc:
-    self.validations.inject([1]) { |accum,validation| accum << validation.level }.uniq.sort
-  end
-  
-  def validations #:nodoc:
-    @validations ||= self.class.validations.collect { |validation| validation.dup }
+    self.class.validations.inject([1]) { |accum,validation| accum << validation.level }.uniq.sort
   end
 end

data/lib/validations/validation_base.rb

@@ -41,11 +41,11 @@ module Validatable
     include Understandable
     include Requireable
     
-    option :message, :if, :times, :level, :groups
-    default :if => lambda { true }, :level => 1, :groups => []
+    option :message, :if, :times, :level, :groups, :key
+    default :level => 1, :groups => []
     attr_accessor :attribute
     
-    def initialize(attribute, options={})
+    def initialize(klass, attribute, options={})
       must_understand options
       requires options
       self.class.all_understandings.each do |understanding|
@@ -54,20 +54,28 @@ module Validatable
       end
       self.attribute = attribute
       self.groups = [self.groups] unless self.groups.is_a?(Array)
+      self.key = "#{self.class.name}:#{self.attribute}:#{self.key || "key"}" unless self.times.nil?
+      raise_error_if_key_is_dup(klass) unless self.key.nil?
+    end
+    
+    def raise_error_if_key_is_dup(klass)
+      message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
+      raise ArgumentError.new(message) if klass.validation_keys_include? self.key
     end
     
     def should_validate?(instance)
-      instance.instance_eval(&self.if) && validate_this_time?
+      result = validate_this_time?(instance)
+      result &&= instance.instance_eval(&self.if) unless self.if.nil?
+      result
     end
     
     def message(instance)
       @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
     end
     
-    def validate_this_time?
+    def validate_this_time?(instance)
       return true if @times.nil?
-      self.times -= 1
-      self.times >= 0
+      self.times > instance.times_validated(self.key)
     end
     
     def run_after_validate(result, instance, attribute)

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.3.4"
+	s.version = "1.4.0"
 	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

@@ -2,20 +2,45 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 module Functional
   class ValidatableTest < Test::Unit::TestCase
-    test "validations are only executed once" do
-      if_condition = mock
-      if_condition.expects(:where?).times 2
-      klass = Class.new do
+    
+    expect ArgumentError do
+      Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_presence_of :name, :times => 1
+        validates_presence_of :name, :times => 1
+      end
+    end
+    
+    expect ArgumentError do
+      Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_presence_of :name, :times => 1, :key => 'anything'
+        validates_presence_of :name, :times => 1, :key => 'anything'
+      end
+    end
+    
+    expect "is invalid" do
+      child_class = Class.new do
         include Validatable
         attr_accessor :name, :address
-        validates_presence_of :name, :if => lambda { if_condition.where? }
-        validates_presence_of :address, :if => lambda { if_condition.where? }
+        validates_presence_of :name
+        validates_format_of :address, :with => /.+/
+      end
+      klass = Class.new do
+        include Validatable
+        include_validations_for :child 
+        define_method :child do
+          child_class.new
+        end
       end
       instance = klass.new
       instance.valid?
+      instance.errors.on(:address)
     end
     
-    test "given a child class with validations, when parent class is validated, then the error is in the parent objects error collection" do
+    expect "can't be empty" do
       child_class = Class.new do
         include Validatable
         attr_accessor :name, :address
@@ -31,8 +56,7 @@ module Functional
       end
       instance = klass.new
       instance.valid?
-      assert_equal "is invalid", instance.errors.on(:address)
-      assert_equal "can't be empty", instance.errors.on(:name)
+      instance.errors.on(:name)
     end
     
     
@@ -42,20 +66,16 @@ module Functional
         attr_accessor :name
         validates_presence_of :name
       end
+      
       klass = Class.new do
         include Validatable
         extend Forwardable
-        
         def_delegator :child, :name
-        
         validates_true_for :name, :logic => lambda { false }, :level => 2, :message => "invalid message"
-        
         include_validations_for :child 
-
         define_method :child do
           @child ||= child_class.new
         end
-        
       end
       instance = klass.new
       instance.valid?
@@ -67,15 +87,12 @@ module Functional
         include Validatable
         attr_accessor :name
         validates_presence_of :name
-        
       end
+
       klass = Class.new do
         include Validatable
-
         validates_true_for :address, :logic => lambda { false }, :level => 1, :message => "invalid message"
-
         include_validations_for :child 
-
         define_method :child do
           @child ||= child_class.new
         end
@@ -87,7 +104,7 @@ module Functional
       assert_equal "invalid message", instance.errors.on(:address)
     end
   
-    test "given a child class with validations, the error is in the parent objects error collection as the mapped attribute" do
+    expect "can't be empty" do
       child_class = Class.new do
         include Validatable
         attr_accessor :name, :address
@@ -102,10 +119,10 @@ module Functional
       end
       instance = klass.new
       instance.valid?
-      assert_equal "can't be empty", instance.errors.on(:namen)
+      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
+    expect "can't be empty" do
       child_class = Class.new do
         include Validatable
         attr_accessor :name, :address
@@ -120,10 +137,10 @@ module Functional
       end
       instance = klass.new
       instance.valid?
-      assert_equal "can't be empty", instance.errors.on(:name)
+      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
+    expect true do
       child_class = Class.new do
         include Validatable
         attr_accessor :name, :address
@@ -137,7 +154,7 @@ module Functional
         end
       end
       instance = klass.new
-      assert_equal true, instance.valid?
+      instance.valid?
     end
     
     test "classes only have valid_for_* methods for groups that appear in their validations" do
@@ -166,7 +183,7 @@ module Functional
       assert_equal nil, instance.errors.on(:name)
     end
     
-    test "after validate is called following a validation" do
+    expect "can't be empty twice changed message" do
       klass = Class.new do
         include Validatable
         validates_presence_of :name
@@ -185,39 +202,39 @@ module Functional
       end
       instance = klass.new
       instance.valid?
-      assert_equal "can't be empty twice changed message", instance.errors.on(:name).join
       Validatable::ValidatesPresenceOf.after_validations.clear
       Validatable::ValidationBase.after_validations.clear
+      instance.errors.on(:name).join
     end
 
-    test "matching groups are used as validations when multiple groups are given to valid" do
+    expect false 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_for_group_one?
+      instance.valid_for_group_one?
     end
     
-    test "matching groups are used as validations when validations are part of multiple groups" do
+    expect false 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_for_group_one?
+      instance.valid_for_group_one?
     end
     
-    test "no group given then all validations are used" do
+    expect false 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?
+      instance.valid?
     end
     
     expect true do
@@ -242,7 +259,7 @@ module Functional
       instance2 = klass.new
       instance2.valid?
     end
-    
+        
     expect "name message" do
       klass = Class.new do
         include Validatable

data/test/unit/validatable_test.rb

@@ -3,8 +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, :run_after_validate => nil)
+      validation = stub_everything(:valid? => false, :should_validate? => true, :attribute => "attribute", :level => 1)
       klass = Class.new do
         include Validatable
         validations << validation
@@ -21,6 +20,21 @@ module Unit
       instance.valid?
       instance.errors.empty?
     end
-  
+    
+    expect false do
+      klass = Class.new do
+        include Validatable
+      end
+      klass.validation_keys_include?("anything")
+    end
+    
+    expect true do
+      validation = stub_everything(:key => "key")
+      klass = Class.new do
+        include Validatable
+        validations << validation
+      end
+      klass.validation_keys_include?("key")
+    end
   end
 end

data/test/unit/validates_acceptance_of_test.rb

@@ -2,19 +2,20 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidatesAcceptanceOfTest < Test::Unit::TestCase
   test "valid acceptance" do
-    validation = Validatable::ValidatesAcceptanceOf.new :acceptance
+    validation = Validatable::ValidatesAcceptanceOf.new stub, :acceptance
     instance = stub(:acceptance=>'true')
     assert_equal true, validation.valid?(instance)
   end
   
   test "invalid acceptance" do
-    validation = Validatable::ValidatesAcceptanceOf.new :acceptance
+    validation = Validatable::ValidatesAcceptanceOf.new stub, :acceptance
     instance = stub(:acceptance=>'false')
     assert_equal false, validation.valid?(instance)
   end
   
   expect true do
-    Validatable::ValidatesAcceptanceOf.new(:test).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil}
+    Validatable::ValidatesAcceptanceOf.new(stub, :test).must_understand(options)
   end
   
 end

data/test/unit/validates_confirmation_of_test.rb

@@ -2,62 +2,62 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidatesConfirmationOfTest < Test::Unit::TestCase
   test "valid confirmation" do
-    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username
     instance = stub(:username=>"username", :username_confirmation=>"username")
     assert_equal true, validation.valid?(instance)
   end
   
   test "invalid confirmation" do
-    validation = Validatable::ValidatesConfirmationOf.new :username
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username
     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, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :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, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub, :username, :case_sensitive => false
     assert_equal true, validation.valid?(stub(:username => nil, :username_confirmation => nil))
   end
   
   expect true do
     options = { :message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :case_sensitive => nil }
-    Validatable::ValidatesConfirmationOf.new(:test).must_understand(options)
+    Validatable::ValidatesConfirmationOf.new(stub, :test).must_understand(options)
   end
   
 end

data/test/unit/validates_format_of_test.rb

@@ -2,34 +2,34 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidatesFormatOfTest < Test::Unit::TestCase
   test "when attribute value does not match the given regex, then valid is false" do
-    validation = Validatable::ValidatesFormatOf.new :name, :with => /book/
+    validation = Validatable::ValidatesFormatOf.new stub, :name, :with => /book/
     assert_equal false, validation.valid?(stub_everything)
   end
   
   test "when attribute value does match the given regex, then valid is true" do
-    validation = Validatable::ValidatesFormatOf.new :name, :with => /book/
+    validation = Validatable::ValidatesFormatOf.new stub, :name, :with => /book/
     assert_equal true, validation.valid?(stub(:name=>"book"))
   end
   
   test "when attribute value is an integer it should be converted to a string before matching" do
-    validation = Validatable::ValidatesFormatOf.new :age, :with => /14/
+    validation = Validatable::ValidatesFormatOf.new stub, :age, :with => /14/
     assert_equal true, validation.valid?(stub(:age=>14))
   end
   
   test "when no with is given, then an error is raised during construction" do
     assert_raises ArgumentError do
-      validation = Validatable::ValidatesFormatOf.new :age
+      validation = Validatable::ValidatesFormatOf.new stub, :age
     end
   end
   
   expect true do
-    options = [:message, :if, :times, :level, :groups, :with]
-    Validatable::ValidatesFormatOf.new(:test, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
+    options = [:message, :if, :times, :level, :groups, :with, :key]
+    Validatable::ValidatesFormatOf.new(stub, :test, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
   end
   
   expect true do
     options = [:with]
-    Validatable::ValidatesFormatOf.new(:name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
+    Validatable::ValidatesFormatOf.new(stub, :name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
   end
   
 end

data/test/unit/validates_length_of_test.rb

@@ -3,74 +3,74 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 module Unit
   class ValidatesLengthOfTest < Test::Unit::TestCase
     expect false do
-      validation = Validatable::ValidatesLengthOf.new :username, :maximum => 8
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :maximum => 8
       validation.valid?(stub(:username=>"usernamefdfd"))
     end
     
     test "min length" do
-      validation = Validatable::ValidatesLengthOf.new :username, :minimum => 2
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :minimum => 2
       instance = stub(:username=>"u")
       assert_equal false, validation.valid?(instance)
     end
   
     test "valid length" do
-      validation = Validatable::ValidatesLengthOf.new :username, :minimum => 2, :maximum => 8
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :minimum => 2, :maximum => 8
       instance = stub(:username=>"udfgdf")
       assert_equal true, validation.valid?(instance)
     end
     
     test "is length is false" do
-      validation = Validatable::ValidatesLengthOf.new :username, :is => 2
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :is => 2
       instance = stub(:username=>"u")
       assert_equal false, validation.valid?(instance)
     end
     
     test "is length is true" do
-      validation = Validatable::ValidatesLengthOf.new :username, :is => 2
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :is => 2
       instance = stub(:username=>"uu")
       assert_equal true, validation.valid?(instance)
     end
     
     test "within lower bound is true" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4
       instance = stub(:username => "aa")
       assert_equal true, validation.valid?(instance)
     end
 
     test "within outside lower bound is false" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4
       instance = stub(:username => "a")
       assert_equal false, validation.valid?(instance)
     end
 
     test "within upper bound is true" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4
       instance = stub(:username => "aaaa")
       assert_equal true, validation.valid?(instance)
     end
 
     test "within outside upper bound is false" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4
       instance = stub(:username => "aaaaa")
       assert_equal false, validation.valid?(instance)
     end
 
     test "given nil value, should not be valid" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4
       instance = stub(:username => nil)
       assert_equal false, validation.valid?(instance)
     end
 
 
     test "given allow_nil is true, nil value should be valid" do
-      validation = Validatable::ValidatesLengthOf.new :username, :within => 2..4, :allow_nil => true
+      validation = Validatable::ValidatesLengthOf.new stub, :username, :within => 2..4, :allow_nil => true
       instance = stub(:username => nil)
       assert_equal true, validation.valid?(instance)
     end
     
     expect true do
       options = [:message, :if, :times, :level, :groups, :maximum, :minimum, :is, :within, :allow_nil]
-      Validatable::ValidatesLengthOf.new(:test).must_understand(options.to_blank_options_hash)
+      Validatable::ValidatesLengthOf.new(stub, :test).must_understand(options.to_blank_options_hash)
     end
     
   end

data/test/unit/validates_numericality_of_test.rb

@@ -4,50 +4,50 @@ module Unit
   class ValidatesNumericalityOfTest < Test::Unit::TestCase
  
     test "when the value is  nil then valid is false" do
-      validation = Validatable::ValidatesNumericalityOf.new :nothing
+      validation = Validatable::ValidatesNumericalityOf.new stub, :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
+      validation = Validatable::ValidatesNumericalityOf.new stub, :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
+      validation = Validatable::ValidatesNumericalityOf.new stub, :some_decimal
       instance = stub(:some_decimal => 1.23)
       assert_equal true, validation.valid?(instance)
     end
   
     test "when value is a decimal but only_integer is true, then valid is false" do
-      validation = Validatable::ValidatesNumericalityOf.new :some_decimal, :only_integer => true
+      validation = Validatable::ValidatesNumericalityOf.new stub, :some_decimal, :only_integer => true
       instance = stub(:some_decimal => 1.23)
       assert_equal false, validation.valid?(instance)
     end
     
     test "when value is an integer string and only_integer is true, then valid is true" do
-      validation = Validatable::ValidatesNumericalityOf.new :some_negative_number, :only_integer => true
+      validation = Validatable::ValidatesNumericalityOf.new stub, :some_negative_number, :only_integer => true
       instance = stub(:some_negative_number => "-1")
       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
+      validation = Validatable::ValidatesNumericalityOf.new stub, :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
+      validation = Validatable::ValidatesNumericalityOf.new stub, :multiple_dots
       instance = stub(:multiple_dots => "50.0.0")
       assert_equal false, validation.valid?(instance)
     end
     
     expect true do
       options = [:message, :if, :times, :level, :groups, :only_integer]
-      Validatable::ValidatesNumericalityOf.new(:test).must_understand(options.to_blank_options_hash)
+      Validatable::ValidatesNumericalityOf.new(stub, :test).must_understand(options.to_blank_options_hash)
     end
     
   end

data/test/unit/validates_presence_of_test.rb

@@ -2,22 +2,23 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidatesPresenceOfTest < Test::Unit::TestCase
   test "when attribute value does not match the given regex, then valid is false" do
-    validation = Validatable::ValidatesPresenceOf.new :name
+    validation = Validatable::ValidatesPresenceOf.new stub, :name
     assert_equal false, validation.valid?(stub_everything)
   end
   
   test "when attribute value does match the given regex, then valid is true" do
-    validation = Validatable::ValidatesPresenceOf.new :name
+    validation = Validatable::ValidatesPresenceOf.new stub, :name
     assert_equal true, validation.valid?(stub(:name=>"book"))
   end
   
   test "when given a true value which is not a String, then valid is true" do 
-    validation = Validatable::ValidatesPresenceOf.new :employee
+    validation = Validatable::ValidatesPresenceOf.new stub, :employee
     assert_equal true, validation.valid?(stub(:employee => stub(:nil? => false)))
   end
   
   expect true do
-    Validatable::ValidatesPresenceOf.new(:test).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil}
+    Validatable::ValidatesPresenceOf.new(stub, :test).must_understand(options)
   end
   
 end

data/test/unit/validates_true_for_test.rb

@@ -2,29 +2,29 @@ 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, :logic => lambda { false }
+    validation = Validatable::ValidatesTrueFor.new stub, :name, :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, :logic => lambda { true }
+    validation = Validatable::ValidatesTrueFor.new stub, :name, :logic => lambda { true }
     assert_equal true, validation.valid?(stub_everything)
   end
   
   test "when no logic is given, then an error is raised during construction" do
     assert_raises ArgumentError do
-      validation = Validatable::ValidatesTrueFor.new :age
+      validation = Validatable::ValidatesTrueFor.new stub, :age
     end
   end
   
   expect true do
-    options = [:message, :if, :times, :level, :groups, :logic]
-    Validatable::ValidatesTrueFor.new(:name, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
+    options = [:message, :if, :times, :level, :groups, :logic, :key]
+    Validatable::ValidatesTrueFor.new(stub, :name, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
   end
   
   expect true do
     options = [:logic]
-    Validatable::ValidatesTrueFor.new(:name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
+    Validatable::ValidatesTrueFor.new(stub, :name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
   end
   
 end

data/test/unit/validation_base_test.rb

@@ -2,50 +2,61 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidationBaseTest < Test::Unit::TestCase
   expect true do
-    validation = Validatable::ValidationBase.new :base
+    validation = Validatable::ValidationBase.new stub, :base
     validation.should_validate? Object.new
   end
   
   expect true do
-    validation = Validatable::ValidationBase.new :base, :times => 1
-    validation.validate_this_time?
+    validation = Validatable::ValidationBase.new stub_everything, :base, :times => 1
+    validation.validate_this_time?(stub(:times_validated => 0))
   end
   
   expect true do
-    validation = Validatable::ValidationBase.new :base
-    validation.validate_this_time?
+    validation = Validatable::ValidationBase.new stub, :base
+    validation.validate_this_time?(nil)
   end
   
   expect true do
-    validation = Validatable::ValidationBase.new :base, :times => 2
-    validation.validate_this_time?
-    validation.validate_this_time?
+    validation = Validatable::ValidationBase.new stub_everything, :base, :times => 2
+    validation.validate_this_time?(stub(:times_validated => 1))
   end
 
+  expect "Validatable::ValidationBase:base:key" do
+    validation = Validatable::ValidationBase.new stub_everything, :base, :times => 1, :key => "key"
+    validation.key
+  end
+  
+  expect "Validatable::ValidationBase:base:key" do
+    validation = Validatable::ValidationBase.new stub_everything, :base, :times => 1
+    validation.key
+  end
+  
   expect false do
-    validation = Validatable::ValidationBase.new :base, :times => 1
-    validation.validate_this_time?
-    validation.validate_this_time?
+    validation = Validatable::ValidationBase.new stub_everything, :base, :times => 1
+    validation.validate_this_time?(stub(:times_validated => 1))
   end
   
   expect 1 do
-    validation = Validatable::ValidationBase.new :base
+    validation = Validatable::ValidationBase.new stub_everything, :base
     validation.level
   end
   
+  expect ArgumentError do
+    Validatable::ValidationBase.new stub(:validation_keys_include? => true), :base, :times => 1
+  end
+  
   expect "some message 100" do
-    validation = Validatable::ValidationBase.new :base, :message => lambda { "some message #{a_method}" }
+    validation = Validatable::ValidationBase.new stub, :base, :message => lambda { "some message #{a_method}" }
     validation.message(stub(:a_method=>'100'))
   end
   
-  test "invalid option causes raise" do
-    assert_raises ArgumentError do
-      Validatable::ValidationBase.new(:base).must_understand(:foo => 1, :bar => 2)
-    end
+  expect ArgumentError do
+    Validatable::ValidationBase.new(stub, :base).must_understand(:foo => 1, :bar => 2)
   end
   
   expect true do
-    Validatable::ValidationBase.new(:base).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :key => nil}
+    Validatable::ValidationBase.new(stub, :base).must_understand(options)
   end
 
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.2
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.3.4
-date: 2007-05-31 00:00:00 -04:00
+  version: 1.4.0
+date: 2007-06-02 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib