validatable 1.6.4 → 1.6.6

data/lib/included_validation.rb

@@ -0,0 +1,9 @@
+module Validatable
+  class IncludedValidation #:nodoc:
+    attr_accessor :attribute
+    
+    def initialize(attribute)
+      @attribute = attribute
+    end
+  end
+end

data/lib/macros.rb

@@ -194,7 +194,37 @@ module Validatable
       add_validations(args, ValidatesTrueFor)
     end
     
-    # call-seq: include_validations_for(attribute_to_validate, options = {})
+    # call-seq: include_validations_from(attribute)
+    # 
+    # Includes all the validations that are defined on the attribute.
+    #   class Person
+    #     include Validatable
+    #     validates_presence_of :name
+    #   end
+    # 
+    #   class PersonPresenter
+    #     include Validatable
+    #     include_validataions_from :person
+    #     attr_accessor :person
+    #     def name
+    #       person.name
+    #     end
+    #
+    #     def initialize(person)
+    #       @person = person
+    #     end
+    #   end
+    #   
+    #   presenter = PersonPresenter.new(Person.new)
+    #   presenter.valid? #=> false
+    #   presenter.errors.on(:name) #=> "can't be blank"
+    #
+    # The name attribute whose validations should be added.
+    def include_validations_from(attribute_to_validate, options = {})
+      validations_to_include << IncludedValidation.new(attribute_to_validate)
+    end
+
+    # call-seq: include_errors_from(attribute_to_validate, options = {})
     # 
     # Validates the specified attributes.
     #   class Person
@@ -205,7 +235,7 @@ module Validatable
     # 
     #   class PersonPresenter
     #     include Validatable
-    #     include_validations_for :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
+    #     include_errors_from :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
     #     attr_accessor :person
     #     
     #     def initialize(person)
@@ -224,10 +254,28 @@ module Validatable
     # 
     #     * 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 = {})
+    def include_errors_from(attribute_to_validate, options = {})
       children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
     end
     
+    def include_validations_for(attribute_to_validate, options = {}) #:nodoc:
+      puts "include_validations_for is deprecated; use include_errors_from instead"
+      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+    end
+    
+    # call-seq: before_validation(&block)
+    # 
+    # Is called before valid? or valid_for_*?
+    # 
+    #   class Person
+    #     include Validatable
+    #     before_validation do
+    #       self.name = "default name"
+    #     end
+    # 
+    #     attr_accessor :name
+    #   end
+    # 
     def before_validation(&block)
       before_validations << block
     end

data/lib/object_extension.rb

@@ -1,5 +1,6 @@
-class Object
-  module InstanceExecHelper; end
+class Object #:nodoc:
+  module InstanceExecHelper #:nodoc:
+  end
   include InstanceExecHelper
   def instance_eval_with_params(*args, &block)
     begin

data/lib/validatable.rb

@@ -4,6 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/errors')
 require File.expand_path(File.dirname(__FILE__) + '/validatable_class_methods')
 require File.expand_path(File.dirname(__FILE__) + '/macros')
 require File.expand_path(File.dirname(__FILE__) + '/validatable_instance_methods')
+require File.expand_path(File.dirname(__FILE__) + '/included_validation')
 require File.expand_path(File.dirname(__FILE__) + '/child_validation')
 require File.expand_path(File.dirname(__FILE__) + '/understandable')
 require File.expand_path(File.dirname(__FILE__) + '/requireable')
@@ -15,7 +16,4 @@ require File.expand_path(File.dirname(__FILE__) + '/validations/validates_confir
 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')
-require File.expand_path(File.dirname(__FILE__) + '/validations/validates_each')
-require File.expand_path(File.dirname(__FILE__) + '/validation_assertion')
-require File.expand_path(File.dirname(__FILE__) + '/validation_assertion_collector')
-require File.expand_path(File.dirname(__FILE__) + '/validatable_assertions')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_each')

data/lib/validatable_class_methods.rb

@@ -34,7 +34,9 @@ module Validatable
     end
 
     def all_validations
-      return validations + self.superclass.all_validations if self.superclass.respond_to? :all_validations
+      if self.respond_to?(:superclass) && self.superclass.respond_to?(:all_validations)
+        return validations + self.superclass.all_validations 
+      end
       validations
     end
 
@@ -50,6 +52,10 @@ module Validatable
       validations.map { |validation| validation.key }.include?(key)
     end
     
+    def validations_to_include
+      @validations_to_include ||= []
+    end
+    
     protected
     
     def add_validations(args, klass)

data/lib/validatable_instance_methods.rb

@@ -40,6 +40,22 @@ module Validatable
     end
   end
 
+  # call-seq: validate_only(key)
+  #
+  # Only executes a specified validation. The argument should follow a pattern based on the key of the validation.
+  #   Examples:
+  #     * validates_presence_of :name can be run with obj.validate_only("presence_of/name")
+  #     * validates_presence_of :birthday, :key => "a key" can be run with obj.validate_only("presence_of/a key")
+  def validate_only(key)
+    validation_name, attribute_name = key.split("/")
+    validation_name = validation_name.split("_").collect{|word| word.capitalize}.join
+    validation_key = "#{self.class.name}/Validatable::Validates#{validation_name}/#{attribute_name}"
+    validation = self.class.all_validations.find { |validation| validation.key == validation_key }
+    raise ArgumentError.new("validation with key #{validation_key} could not be found") if validation.nil?
+    errors.clear
+    run_validation(validation)
+  end
+
   protected
   def times_validated_hash #:nodoc:
     @times_validated_hash ||= {}
@@ -61,7 +77,7 @@ module Validatable
     validation.run_after_validate(validation_result, self, validation.attribute)
   end
   
-  def run_before_validations
+  def run_before_validations #:nodoc:
     self.class.all_before_validations.each do |block|
       instance_eval &block
     end
@@ -72,11 +88,18 @@ module Validatable
   end
   
   def validations_for_level_and_group(level, group) #:nodoc:
-    validations_for_level = self.class.all_validations.select { |validation| validation.level == level }
+    validations_for_level = self.all_validations.select { |validation| validation.level == level }
     return validations_for_level.select { |validation| validation.groups.empty? } if group.nil?
     validations_for_level.select { |validation| validation.groups.include?(group) }
   end
   
+  def all_validations #:nodoc:
+    res = self.class.validations_to_include.inject(self.class.all_validations) do |result, included_validation_class|
+      result += self.send(included_validation_class.attribute).all_validations
+      result
+    end
+  end
+  
   def validation_levels #:nodoc:
     self.class.all_validations.inject([1]) { |result, validation| result << validation.level }.uniq.sort
   end

data/lib/validations/validation_base.rb

@@ -54,8 +54,8 @@ 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?
+      self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
+      raise_error_if_key_is_dup(klass)
     end
     
     def raise_error_if_key_is_dup(klass)

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.6.4"
+	s.version = "1.6.6"
 	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

@@ -1,6 +1,44 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 functional_tests do
+
+  expect "can't be empty" do
+    child_class = Module.new do
+      include Validatable
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      include_validations_from :child 
+      define_method :child do
+        child_class
+      end
+      attr_accessor :name
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:name)
+  end
+  
+  expect "can't be empty" do
+    child_class = Module.new do
+      include Validatable
+      validates_presence_of :name
+    end
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :address
+      include_validations_from :child 
+      define_method :child do
+        child_class
+      end
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.valid?
+    instance.errors.on(:address)
+  end
+  
   expect :is_set do
     klass = Class.new do
       include Validatable
@@ -91,7 +129,7 @@ functional_tests do
     end
     klass = Class.new do
       include Validatable
-      include_validations_for :child 
+      include_errors_from :child 
       define_method :child do
         child_class.new
       end
@@ -110,7 +148,7 @@ functional_tests do
     end
     klass = Class.new do
       include Validatable
-      include_validations_for :child 
+      include_errors_from :child 
       define_method :child do
         child_class.new
       end
@@ -133,7 +171,7 @@ functional_tests do
       extend Forwardable
       def_delegator :child, :name
       validates_true_for :name, :logic => lambda { false }, :level => 2, :message => "invalid message"
-      include_validations_for :child 
+      include_errors_from :child 
       define_method :child do
         @child ||= child_class.new
       end
@@ -153,7 +191,7 @@ functional_tests do
     klass = Class.new do
       include Validatable
       validates_true_for :address, :logic => lambda { false }, :level => 1, :message => "invalid message"
-      include_validations_for :child 
+      include_errors_from :child 
       define_method :child do
         @child ||= child_class.new
       end
@@ -173,7 +211,7 @@ functional_tests do
     end
     klass = Class.new do
       include Validatable
-      include_validations_for :child, :map => {:name => :namen}
+      include_errors_from :child, :map => {:name => :namen}
       define_method :child do
         child_class.new
       end
@@ -191,7 +229,7 @@ functional_tests do
     end
     klass = Class.new do
       include Validatable
-      include_validations_for :child, :if => lambda { true }
+      include_errors_from :child, :if => lambda { true }
       define_method :child do
         child_class.new
       end
@@ -209,7 +247,7 @@ functional_tests do
     end
     klass = Class.new do
       include Validatable
-      include_validations_for :child, :if => lambda { false }
+      include_errors_from :child, :if => lambda { false }
       define_method :child do
         child_class.new
       end
@@ -356,4 +394,44 @@ functional_tests do
     instance.valid?
     instance.errors.on(:address)
   end
+  
+  expect "Mod::Klass/Validatable::ValidatesPresenceOf/name" do
+    module Mod
+      class Klass
+        include Validatable
+        validates_presence_of :name
+      end
+    end
+    Mod::Klass.validations.first.key
+  end
+
+  expect "/Validatable::ValidatesPresenceOf/custom key" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :key => "custom key"
+    end
+    klass.validations.first.key
+  end
+  
+  expect "can't be empty" do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :address
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.validate_only("presence_of/name")
+    instance.errors.on(:name)
+  end
+
+  expect nil do
+    klass = Class.new do
+      include Validatable
+      validates_presence_of :name, :address
+      attr_accessor :name, :address
+    end
+    instance = klass.new
+    instance.validate_only("presence_of/name")
+    instance.errors.on(:address)
+  end
 end

data/test/test_helper.rb

@@ -7,12 +7,6 @@ require 'set'
 require File.dirname(__FILE__) + '/../lib/validatable'
 
 class << Test::Unit::TestCase
-  def test(name, &block)
-    test_name = :"test_#{name.gsub(' ','_')}"
-    raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include? test_name.to_s
-    define_method test_name, &block
-  end
-  
   def expect(expected_value, &block)
     define_method :"test_#{caller.first.split("/").last}" do
       begin

data/test/unit/validates_acceptance_of_test.rb

@@ -2,20 +2,20 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidatesAcceptanceOfTest < Test::Unit::TestCase
   test "valid acceptance" do
-    validation = Validatable::ValidatesAcceptanceOf.new stub, :acceptance
+    validation = Validatable::ValidatesAcceptanceOf.new stub_everything, :acceptance
     instance = stub(:acceptance=>'true')
     assert_equal true, validation.valid?(instance)
   end
   
   test "invalid acceptance" do
-    validation = Validatable::ValidatesAcceptanceOf.new stub, :acceptance
+    validation = Validatable::ValidatesAcceptanceOf.new stub_everything, :acceptance
     instance = stub(:acceptance=>'false')
     assert_equal false, validation.valid?(instance)
   end
   
   expect true do
     options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil}
-    Validatable::ValidatesAcceptanceOf.new(stub, :test).must_understand(options)
+    Validatable::ValidatesAcceptanceOf.new(stub_everything, :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 stub, :username
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :username
     instance = stub(:username=>"username", :username_confirmation=>"username")
     assert_equal true, validation.valid?(instance)
   end
   
   test "invalid confirmation" do
-    validation = Validatable::ValidatesConfirmationOf.new stub, :username
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => true
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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 stub, :username, :case_sensitive => false
+    validation = Validatable::ValidatesConfirmationOf.new stub_everything, :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(stub, :test).must_understand(options)
+    Validatable::ValidatesConfirmationOf.new(stub_everything, :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 stub, :name, :with => /book/
+    validation = Validatable::ValidatesFormatOf.new stub_everything, :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 stub, :name, :with => /book/
+    validation = Validatable::ValidatesFormatOf.new stub_everything, :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 stub, :age, :with => /14/
+    validation = Validatable::ValidatesFormatOf.new stub_everything, :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 stub, :age
+      validation = Validatable::ValidatesFormatOf.new stub_everything, :age
     end
   end
   
   expect true do
     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)
+    Validatable::ValidatesFormatOf.new(stub_everything, :test, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
   end
   
   expect true do
     options = [:with]
-    Validatable::ValidatesFormatOf.new(stub, :name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
+    Validatable::ValidatesFormatOf.new(stub_everything, :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 stub, :username, :maximum => 8
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :username, :maximum => 8
       validation.valid?(stub(:username=>"usernamefdfd"))
     end
     
     test "min length" do
-      validation = Validatable::ValidatesLengthOf.new stub, :username, :minimum => 2
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :username, :minimum => 2
       instance = stub(:username=>"u")
       assert_equal false, validation.valid?(instance)
     end
   
     test "valid length" do
-      validation = Validatable::ValidatesLengthOf.new stub, :username, :minimum => 2, :maximum => 8
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :is => 2
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :username, :is => 2
       instance = stub(:username=>"u")
       assert_equal false, validation.valid?(instance)
     end
     
     test "is length is true" do
-      validation = Validatable::ValidatesLengthOf.new stub, :username, :is => 2
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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 stub, :username, :within => 2..4, :allow_nil => true
+      validation = Validatable::ValidatesLengthOf.new stub_everything, :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(stub, :test).must_understand(options.to_blank_options_hash)
+      Validatable::ValidatesLengthOf.new(stub_everything, :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 stub, :nothing
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :some_int
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :some_decimal
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :some_decimal, :only_integer => true
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :some_negative_number, :only_integer => true
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :some_non_numeric
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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 stub, :multiple_dots
+      validation = Validatable::ValidatesNumericalityOf.new stub_everything, :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(stub, :test).must_understand(options.to_blank_options_hash)
+      Validatable::ValidatesNumericalityOf.new(stub_everything, :test).must_understand(options.to_blank_options_hash)
     end
     
   end

data/test/unit/validates_presence_of_test.rb

@@ -2,23 +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 stub, :name
+    validation = Validatable::ValidatesPresenceOf.new stub_everything, :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 stub, :name
+    validation = Validatable::ValidatesPresenceOf.new stub_everything, :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 stub, :employee
+    validation = Validatable::ValidatesPresenceOf.new stub_everything, :employee
     assert_equal true, validation.valid?(stub(:employee => stub(:nil? => false)))
   end
   
   expect true do
     options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil}
-    Validatable::ValidatesPresenceOf.new(stub, :test).must_understand(options)
+    Validatable::ValidatesPresenceOf.new(stub_everything, :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 stub, :name, :logic => lambda { false }
+    validation = Validatable::ValidatesTrueFor.new stub_everything, :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 stub, :name, :logic => lambda { true }
+    validation = Validatable::ValidatesTrueFor.new stub_everything, :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 stub, :age
+      validation = Validatable::ValidatesTrueFor.new stub_everything, :age
     end
   end
   
   expect true do
     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)
+    Validatable::ValidatesTrueFor.new(stub_everything, :name, options.to_blank_options_hash).must_understand(options.to_blank_options_hash)
   end
   
   expect true do
     options = [:logic]
-    Validatable::ValidatesTrueFor.new(stub, :name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
+    Validatable::ValidatesTrueFor.new(stub_everything, :name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
   end
   
 end

data/test/unit/validation_base_test.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class ValidationBaseTest < Test::Unit::TestCase
   expect true do
-    validation = Validatable::ValidationBase.new stub, :base
+    validation = Validatable::ValidationBase.new stub_everything, :base
     validation.should_validate? Object.new
   end
   
@@ -12,7 +12,7 @@ class ValidationBaseTest < Test::Unit::TestCase
   end
   
   expect true do
-    validation = Validatable::ValidationBase.new stub, :base
+    validation = Validatable::ValidationBase.new stub_everything, :base
     validation.validate_this_time?(nil)
   end
   
@@ -21,16 +21,6 @@ class ValidationBaseTest < Test::Unit::TestCase
     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 stub_everything, :base, :times => 1
     validation.validate_this_time?(stub(:times_validated => 1))
@@ -42,21 +32,21 @@ class ValidationBaseTest < Test::Unit::TestCase
   end
   
   expect ArgumentError do
-    Validatable::ValidationBase.new stub(:validation_keys_include? => true), :base, :times => 1
+    Validatable::ValidationBase.new stub_everything(:validation_keys_include? => true), :base, :times => 1
   end
   
   expect "some message 100" do
-    validation = Validatable::ValidationBase.new stub, :base, :message => lambda { "some message #{a_method}" }
+    validation = Validatable::ValidationBase.new stub_everything, :base, :message => lambda { "some message #{a_method}" }
     validation.message(stub(:a_method=>'100'))
   end
   
   expect ArgumentError do
-    Validatable::ValidationBase.new(stub, :base).must_understand(:foo => 1, :bar => 2)
+    Validatable::ValidationBase.new(stub_everything, :base).must_understand(:foo => 1, :bar => 2)
   end
   
   expect true do
     options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :key => nil}
-    Validatable::ValidationBase.new(stub, :base).must_understand(options)
+    Validatable::ValidationBase.new(stub_everything, :base).must_understand(options)
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.6.4
-date: 2007-08-15 00:00:00 -04:00
+  version: 1.6.6
+date: 2007-11-04 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib
@@ -31,16 +31,14 @@ authors:
 files: 
 - lib/child_validation.rb
 - lib/errors.rb
+- lib/included_validation.rb
 - lib/macros.rb
 - lib/object_extension.rb
 - lib/requireable.rb
 - lib/understandable.rb
 - lib/validatable.rb
-- lib/validatable_assertions.rb
 - lib/validatable_class_methods.rb
 - lib/validatable_instance_methods.rb
-- lib/validation_assertion.rb
-- lib/validation_assertion_collector.rb
 - lib/validations/validates_acceptance_of.rb
 - lib/validations/validates_confirmation_of.rb
 - lib/validations/validates_each.rb
@@ -51,8 +49,6 @@ files:
 - lib/validations/validates_true_for.rb
 - lib/validations/validation_base.rb
 - test/all_tests.rb
-- test/test_helper.rb
-- test/functional/validatable_assertions_test.rb
 - test/functional/validatable_test.rb
 - test/functional/validates_acceptance_of_test.rb
 - test/functional/validates_confirmation_of_test.rb
@@ -62,7 +58,7 @@ files:
 - test/functional/validates_numericality_of_test.rb
 - test/functional/validates_presence_of_test.rb
 - test/functional/validates_true_for_test.rb
-- test/functional/validation_assertion_collector_test.rb
+- test/test_helper.rb
 - test/unit/errors_test.rb
 - test/unit/understandable_test.rb
 - test/unit/validatable_test.rb

data/lib/validatable_assertions.rb

@@ -1,77 +0,0 @@
-module Validatable
-  module Assertions
-
-    def create_message_for_assertion(assertion) #:nodoc:
-      message = "#{assertion.klass} does not contain a #{assertion.validation_type} for #{assertion.attribute}"
-      message += " with options #{assertion.options.inspect}" unless assertion.options == {}
-      message
-    end
-
-    def create_backtrace #:nodoc:
-      backtrace = caller
-      backtrace.shift
-      backtrace.shift
-      backtrace
-    end
-
-    def validation_matching_proc(assertion) #:nodoc:
-      lambda do |validation|
-        result = assertion.validation_type === validation
-        result &&= assertion.attribute == validation.attribute
-        assertion.options.each_pair do |key, value|
-          validation_value = validation.send key if validation.respond_to? key
-          result = false if validation_value.nil?
-          result &&= validation_value == value
-        end
-        result
-      end
-    end
-
-    def self.included(klass) #:nodoc:
-      Test::Unit::TestCase.class_eval do
-        def self.create_test_name(assertion) #:nodoc:
-          "test#{assertion.validation_type.to_s.gsub(/Validatable::/,'').gsub(/([A-Z])/, '_\1').downcase}_#{assertion.attribute}"
-        end
-
-        def self.define_test_method name, &block #:nodoc:
-          class_eval do
-            define_method name, &block
-          end
-        end
-      end
-
-      Class.class_eval do
-        # call-seq: must_validate
-        #
-        #   class FooTest < Test::Unit::TestCase
-        #     include Validatable::Assertions
-        # 
-        #     Foo.must_validate do
-        #       presence_of :name
-        #       format_of(:name).with(/^[A-Z]/)
-        #       numericality_of(:age).only_integer(true)
-        #     end
-        #   end
-        # 
-        # The above code creates a test for each line in the block given to must_validate. 
-        # If the Foo class does not contain a presence of validation for name, 
-        # an error with the text "Foo does not contain a Validatable::ValidatesPresenceOf for name" will be raised.
-        # 
-        # Clearly this solution has limitations. Any validates_true_for validation cannot be tested using 
-        # this DSL style of testing. Furthermore, any validation that uses an :if argument cannot use this DSL, 
-        # since those validations require an instance to eval the :if argument against. However, for validations 
-        # that are not validates_true_for and do not rely on an :if argument, the ValidatableAssertions can 
-        # replace various existing success and failure validation tests.
-        def must_validate(&block)
-          test_class = eval "self", block.binding
-          ValidationAssertionCollector.gather(self, &block).each do |assertion|
-            test_class.define_test_method test_class.create_test_name(assertion) do
-              validation = assertion.klass.validations.find &validation_matching_proc(assertion)
-              add_failure create_message_for_assertion(assertion), create_backtrace if validation.nil?
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/validation_assertion.rb

@@ -1,7 +0,0 @@
-class ValidationAssertion #:nodoc:
-  attr_accessor :klass, :validation_type, :options, :attribute
-  
-  def initialize(klass, validation_type, attribute)
-    self.klass, self.validation_type, self.attribute, self.options = klass, validation_type, attribute, {}
-  end
-end

data/lib/validation_assertion_collector.rb

@@ -1,43 +0,0 @@
-class ValidationAssertionCollector #:nodoc:
-  def self.gather(klass, &block)
-    collector = self.new(klass)
-    collector.instance_eval(&block)
-    collector.assertions
-  end
-  
-  def self.define_method_for_validation_method(validation_method, validatable_class)
-    define_method validation_method.gsub(/^validates_/,'').to_sym do |attribute|
-      assertions << ValidationAssertion.new(self.klass, validatable_class, attribute)
-      define_methods_on_assertion_to_collect_options validatable_class, assertions.last
-    end
-  end
-
-  Validatable::Macros.public_instance_methods.sort.grep(/^validates_/).each do |validation_method|
-    next if validation_method == 'validates_true_for'
-    validatable_class = Validatable.const_get(validation_method.split(/_/).collect { |word| word.capitalize}.join)
-    define_method_for_validation_method(validation_method, validatable_class)
-  end
-  
-  attr_accessor :klass
-  
-  def initialize(klass)
-    self.klass = klass
-  end
-    
-  def define_methods_on_assertion_to_collect_options(validatable_class, assertion)
-    validatable_class.all_understandings.each do |option|
-      next if option == :if
-      class << assertion; self; end.instance_eval do
-        define_method option do |value|
-          self.options.merge!(option=>value)
-          self
-        end
-      end
-    end
-    assertion
-  end
-  
-  def assertions
-    @assertions ||= []
-  end
-end

data/test/functional/validatable_assertions_test.rb

@@ -1,98 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class Validatable::AssertionsTest < Test::Unit::TestCase
-  expect "Klass does not contain a ValidationType for Attribute" do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    klass.new.create_message_for_assertion(stub(:klass=>"Klass", :validation_type=>"ValidationType", :attribute=>"Attribute", :options=>{}))
-  end
-
-  expect "Klass does not contain a ValidationType for Attribute" do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    klass.new.create_message_for_assertion(stub(:klass=>"Klass", :validation_type=>"ValidationType", :attribute=>"Attribute", :options=>{}))
-  end
-  
-  expect false do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    assertion = stub(:validation_type=>stub(:=== => true), :attribute => "attribute", :options=>{:level => 1, :times => 2})
-    validation = stub(:validation_type=>"validation_type", :attribute => "attribute", :level => 2, :times => 2)
-    klass.new.validation_matching_proc(assertion).call(validation)
-  end
-
-  expect false do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    assertion = stub(:validation_type=>stub(:=== => true), :attribute => "non matching attribute", :options=>{})
-    validation = stub(:validation_type=>"validation_type", :attribute => nil)
-    klass.new.validation_matching_proc(assertion).call(validation)
-  end
-  
-  expect false do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    assertion = stub(:validation_type=>"non matching validation_type", :options=>{})
-    validation = stub(:validation_type=>"validation_type")
-    klass.new.validation_matching_proc(assertion).call(validation)
-  end
-
-  expect true do
-    klass = Class.new do
-      include Validatable::Assertions
-    end
-    assertion = stub(:validation_type=>stub(:=== => true), :attribute => "attribute", :options=>{:level => 1, :times => 2})
-    validation = stub(:validation_type=>"validation_type", :attribute => "attribute", :level => 1, :times => 2)
-    klass.new.validation_matching_proc(assertion).call(validation)
-  end
-  
-  expect true do
-    Class.new do
-      include Validatable::Assertions
-    end
-    
-    Class.respond_to? :must_validate
-  end
-  
-  expect "test_validates_presence_of_name" do
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Validatable::Assertions
-    end
-    test_class.create_test_name(stub(:validation_type=>Validatable::ValidatesPresenceOf, :attribute=>:name))
-  end
-  
-  expect true do
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Validatable::Assertions
-    end
-    
-    test_class.define_test_method :some_test do 
-      true 
-    end
-    
-    test_class.instance_methods.include? "some_test"
-  end
-  
-  expect true do
-    klass = Class.new do
-      include Validatable
-    end
-    test_class = Class.new Test::Unit::TestCase do
-      include Validatable::Assertions
-      
-      klass.must_validate do
-        presence_of :anything
-      end
-      
-    end
-    
-    test_class.any_instance.expects(:add_failure)
-    test_class.new(:test_validates_presence_of_anything).test_validates_presence_of_anything
-    true
-  end
-end

data/test/functional/validation_assertion_collector_test.rb

@@ -1,49 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class ValidationAssertionCollectorTest < Test::Unit::TestCase
-  expect 1 do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      presence_of :name
-    end
-    assertions.size
-  end
-  
-  expect "save this message" do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      presence_of(:name).message("ignore this message").message("save this message")
-    end
-    assertions.first.options[:message]
-  end
-  
-  expect :class_being_validated do
-    assertions = ValidationAssertionCollector.gather(:class_being_validated) do
-      presence_of(:name)
-    end
-    assertions.first.klass
-  end
-  
-  expect NoMethodError do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      presence_of(:name).invalid_option
-    end
-  end
-    
-  expect NoMethodError do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      true_for(:name)
-    end
-  end
-  
-  expect NoMethodError do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      presence_of(:name).if lambda { true }
-    end
-  end
-  
-  expect Validatable::ValidatesPresenceOf do
-    assertions = ValidationAssertionCollector.gather(Class.new) do
-      presence_of(:name)
-    end
-    assertions.first.validation_type
-  end
-end