validatable 1.2.2 → 1.3.0

data/README

@@ -77,6 +77,8 @@ Validations can also be given groups. Groups can be used to validate an object w
   application.ssn = 377990118
   application.valid_for_saving? #=> true
   application.valid_for_underwriting? #=> false
+  
+As you can see, you can use an array if the validation needs to be part of various groups.  However, if the validation only applies to one group you can simply use a symbol for the group name.
 
 Similar to Rails, Validatable also supports conditional validation.
 
@@ -106,19 +108,11 @@ Validatable also exposes an after_validate hook method.
 	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
+the instance the validation was run on, and the attribute that was validated
 
 In the above example the attribute "name" is appended to the message.
 
 See the tests for more examples
 
 == Contributors
-Rick Bradley (Revision 25)
-
-Anonymous Z (Revision 29)
-
-Jason Miller (Revision 31)
-
-Ali Aghareza (Revision 43)
-
-Xavier Shay (Revision 48 & 49)
+Rick Bradley, Anonymous Z, Jason Miller, Ali Aghareza, Xavier Shay

data/lib/requireable.rb

@@ -0,0 +1,26 @@
+module Validatable
+  module Requireable #:nodoc:
+    module ClassMethods
+      def requires(*args)
+        required_options.concat args        
+      end
+      
+      def required_options
+        @required_options ||= []
+      end
+    end
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+    
+    def requires(options)
+      required_options = self.class.required_options.inject([]) do |errors, attribute|
+        errors << attribute.to_s unless options.has_key?(attribute)
+        errors
+      end
+      raise ArgumentError.new("#{self.class} requires options: #{required_options.join(', ')}") if required_options.any?
+      true
+    end
+  end
+end

data/lib/understandable.rb

@@ -1,21 +1,27 @@
 module Validatable
-  module Understandable
-    def understands(*args)
-      understandings.concat args
-    end
+  module Understandable #:nodoc:
+    module ClassMethods
+      def understands(*args)
+        understandings.concat args
+      end
     
-    def understandings
-      @understandings ||= []
+      def understandings
+        @understandings ||= []
+      end
+    
+      def all_understandings
+        return understandings + self.superclass.all_understandings if self.superclass.respond_to? :all_understandings
+        understandings
+      end
     end
     
-    def all_understandings
-      return understandings + self.superclass.understandings if self.superclass.respond_to? :understandings
-      understandings
+    def self.included(klass)
+      klass.extend ClassMethods
     end
     
     def must_understand(hash)
       invalid_options = hash.inject([]) do |errors, (key, value)|
-        errors << key.to_s unless all_understandings.include?(key)
+        errors << key.to_s unless self.class.all_understandings.include?(key)
         errors
       end
       raise ArgumentError.new("invalid options: #{invalid_options.join(', ')}") if invalid_options.any?

data/lib/validatable.rb

@@ -4,6 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/validatable_class_methods')
 require File.expand_path(File.dirname(__FILE__) + '/validatable_instance_methods')
 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')
 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')
@@ -11,4 +12,7 @@ require File.expand_path(File.dirname(__FILE__) + '/validations/validates_accept
 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_true_for')
-require File.expand_path(File.dirname(__FILE__) + '/validations/validates_numericality_of')
+require File.expand_path(File.dirname(__FILE__) + '/validations/validates_numericality_of')
+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')

data/lib/validatable_assertions.rb

@@ -0,0 +1,54 @@
+module ValidatableAssertions
+  
+  def create_message_for_assertion(assertion)
+    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
+    backtrace = caller
+    backtrace.shift
+    backtrace.shift
+    backtrace
+  end
+  
+  def validation_matching_proc(assertion)
+    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)
+    Test::Unit::TestCase.class_eval do
+      def self.create_test_name(assertion)
+        "test#{assertion.validation_type.to_s.gsub(/Validatable::/,'').gsub(/([A-Z])/, '_\1').downcase}_#{assertion.attribute}"
+      end
+      
+      def self.define_test_method name, &block
+        class_eval do
+          define_method name, &block
+        end
+      end
+    end
+
+    Class.class_eval do
+      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

data/lib/validatable_class_methods.rb

@@ -20,9 +20,7 @@ module Validatable
     #     * 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]
-      end
+      add_validations(args, ValidatesFormatOf)
     end
     
     # call-seq: validates_length_of(*args)
@@ -43,13 +41,11 @@ 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
+    #     * is - The size the attribute must be
+    #     * within - A range that the size of the attribute must fall within
     #     * 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]
-        validation.maximum = options[:maximum]
-        validation.is = options[:is]
-      end
+      add_validations(args, ValidatesLengthOf)
     end
 
     # call-seq: validates_numericality_of(*args)
@@ -68,6 +64,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
     #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    #     * only_integer - Whether the attribute must be an integer (default is false)
     def validates_numericality_of(*args)
       add_validations(args, ValidatesNumericalityOf)
     end
@@ -117,13 +114,7 @@ module Validatable
     #     * 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) do |validation, options|
-        validation.case_sensitive = if options.has_key? :case_sensitive
-          options[:case_sensitive]
-        else
-          true
-        end
-      end
+      add_validations(args, ValidatesConfirmationOf)
     end
   
     # call-seq: validates_presence_of(*args)
@@ -168,9 +159,7 @@ module Validatable
     #     * 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
+      add_validations(args, ValidatesTrueFor)
     end
     
     # call-seq: include_validations_for(attribute_to_validate, options = {})
@@ -206,25 +195,13 @@ module Validatable
       children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
     end
     
-    def validate(instance) #:nodoc:
-      levels = self.validations.collect { |validation| validation.level }.uniq
-      levels.sort.each do |level|
-        self.validations.select { |validation| validation.level == level }.each do |validation|
-          if validation.should_validate?(instance)
-            instance.errors.add(validation.attribute, validation.message) unless validation.valid?(instance)
-          end
-        end
-        return if instance.errors.any?
-      end
-    end
-    
     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(child_validation.map[attribute.to_sym] || attribute, message)
+          add_error(instance, child_validation.map[attribute.to_sym] || attribute, message)
         end
       end
     end
@@ -232,23 +209,26 @@ module Validatable
     def validations #:nodoc:
       @validations ||= []
     end
-
+    
+    def add_error(instance, attribute, message) #:nodoc:
+      instance.errors.add(attribute, message)
+    end
+    
     protected
+    
     def add_validations(args, klass) #:nodoc:
       options = args.last.is_a?(Hash) ? args.pop : {}
       args.each do |attribute|
-        klass.must_understand options
         new_validation = klass.new attribute, options
-        yield new_validation, options if block_given?
         self.validations << new_validation
-        self.create_valid_method_for_groups  new_validation.groups
+        self.create_valid_method_for_groups new_validation.groups
       end
     end
     
-    def create_valid_method_for_groups(groups)
+    def create_valid_method_for_groups(groups) #:nodoc:
       groups.each do |group|
         self.class_eval do
-          define_method :"valid_for_#{group}?" do
+          define_method "valid_for_#{group}?".to_sym do
             valid_for_group?(group)
           end
         end
@@ -258,5 +238,6 @@ module Validatable
     def children_to_validate #:nodoc:
       @children_to_validate ||= []
     end
+    
   end
 end

data/lib/validatable_instance_methods.rb

@@ -18,7 +18,7 @@ module Validatable
   end
   
   protected
-  def valid_for_group?(*groups)
+  def valid_for_group?(*groups) #:nodoc:
     errors.clear
     self.class.validate_children(self, groups)
     self.validate(groups)
@@ -36,18 +36,22 @@ module Validatable
 
   def run_validation(validation) #:nodoc:
     validation_result = validation.valid?(self)
-    self.errors.add(validation.attribute, validation.message) unless validation_result
+    add_error(validation.attribute, validation.message) unless validation_result
     validation.run_after_validate(validation_result, self, validation.attribute)
   end
   
-  def validations_for_level_and_groups(level, groups)
+  def add_error(attribute, message) #:nodoc:
+    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? }
   end
   
   def validation_levels #:nodoc:
-    self.validations.collect { |validation| validation.level }.uniq.sort
+    self.validations.inject([1]) { |accum,validation| accum << validation.level }.uniq.sort
   end
   
   def validations #:nodoc:

data/lib/validation_assertion.rb

@@ -0,0 +1,7 @@
+class ValidationAssertion
+  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

@@ -0,0 +1,43 @@
+class ValidationAssertionCollector
+  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::ClassMethods.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/lib/validations/validates_confirmation_of.rb

@@ -1,7 +1,7 @@
 module Validatable
   class ValidatesConfirmationOf < ValidationBase #:nodoc:
-    attr_accessor :case_sensitive
-    understands :case_sensitive
+    option :case_sensitive
+    default :case_sensitive => true
     
     def valid?(instance)
       return instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive

data/lib/validations/validates_format_of.rb

@@ -1,7 +1,6 @@
 module Validatable
   class ValidatesFormatOf < ValidationBase #:nodoc:
-    attr_accessor :with
-    understands :with
+    required_option :with
   
     def valid?(instance)
       not (instance.send(self.attribute).to_s =~ self.with).nil?

data/lib/validations/validates_length_of.rb

@@ -1,7 +1,6 @@
 module Validatable
   class ValidatesLengthOf < ValidationBase #:nodoc:
-    attr_accessor :minimum, :maximum, :is
-    understands :minimum, :maximum, :is
+    option :minimum, :maximum, :is, :within
     
     def message
       super || "is invalid"
@@ -10,9 +9,11 @@ module Validatable
     def valid?(instance)
       valid = true
       value = instance.send(self.attribute) || ""
+
       valid &&= value.length <= maximum unless maximum.nil? 
       valid &&= value.length >= minimum unless minimum.nil?
       valid &&= value.length == is unless is.nil?
+      valid &&= within.include?(value.length) unless within.nil?
       valid
     end
   end

data/lib/validations/validates_numericality_of.rb

@@ -1,8 +1,11 @@
 module Validatable 
   class ValidatesNumericalityOf < ValidationBase #:nodoc:
-
+    option :only_integer
+    
     def valid?(instance)
-      not (instance.send(self.attribute).to_s =~ /^\d*\.{0,1}\d+$/).nil?
+      value = instance.send(self.attribute).to_s
+      regex = self.only_integer ? /\A[+-]?\d+\Z/ : /^\d*\.{0,1}\d+$/
+      not (value =~ regex).nil?
     end
     
     def message

data/lib/validations/validates_true_for.rb

@@ -1,7 +1,6 @@
 module Validatable
   class ValidatesTrueFor < ValidationBase #:nodoc:
-    attr_accessor :logic
-    understands :logic
+    required_option :logic
   
     def valid?(instance)
       instance.instance_eval(&logic) == true

data/lib/validations/validation_base.rb

@@ -1,26 +1,63 @@
 module Validatable
   class ValidationBase #:nodoc:
-    extend Understandable
-    understands :message, :if, :times, :level, :groups
-  
-    attr_accessor :attribute, :message, :times
-    attr_reader :level, :groups
+    class << self
+      def required_option(*args)
+        option(*args)
+        requires(*args)
+      end
+      
+      def option(*args)
+        attr_accessor(*args)
+        understands(*args)
+      end
+      
+      def default(hash)
+        defaults.merge! hash
+      end
+      
+      def defaults
+        @defaults ||= {}
+      end
+      
+      def all_defaults
+        return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
+        defaults
+      end
+      
+      def after_validate(&block)
+        after_validations << block
+      end
+      
+      def after_validations
+        @after_validations ||= []
+      end
+      
+      def all_after_validations
+        return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
+        after_validations
+      end
+    end
+
+    include Understandable
+    include Requireable
+    
+    option :message, :if, :times, :level, :groups
+    default :if => lambda { true }, :level => 1, :groups => []
+    attr_accessor :attribute
     
     def initialize(attribute, options={})
-      @attribute = attribute
-      @message = options[:message]
-      @conditional = options[:if] || Proc.new { true }
-      @times = options[:times]
-      @level = options[:level] || 1
-      @groups = case options[:groups]
-        when nil then []
-        when Array then options[:groups]
-        else [options[:groups]]
+      must_understand options
+      requires options
+      self.class.all_understandings.each do |understanding|
+        options[understanding] = self.class.all_defaults[understanding] unless options.has_key? understanding
+        self.instance_variable_set("@#{understanding}", options[understanding])
       end
+      self.attribute = attribute
+      self.groups = [self.groups] unless self.groups.is_a?(Array)
     end
     
     def should_validate?(instance)
-      instance.instance_eval(&@conditional) && validate_this_time?
+      instance.instance_eval(&self.if) && validate_this_time?
     end
     
     def validate_this_time?
@@ -34,20 +71,5 @@ module Validatable
         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.2.2"
+	s.version = "1.3.0"
 	s.author = 'Jay Fields'
 	s.description = "Validatable is a library for adding validations."
 	s.email = 'validatable-developer@rubyforge.org'

data/test/functional/validatable_assertions_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ValidatableAssertionsTest < Test::Unit::TestCase
+  expect "Klass does not contain a ValidationType for Attribute" do
+    klass = Class.new do
+      include ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+    end
+    
+    Class.respond_to? :must_validate
+  end
+  
+  expect "test_validates_presence_of_name" do
+    test_class = Class.new(Test::Unit::TestCase) do
+      include ValidatableAssertions
+    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 ValidatableAssertions
+    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 ValidatableAssertions
+      
+      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/validatable_test.rb

@@ -35,6 +35,58 @@ module Functional
       assert_equal "can't be empty", instance.errors.on(:name)
     end
     
+    
+    test "when child validations have errors, level 2 and higher parent validations are not performed" do
+      child_class = Class.new do
+        include Validatable
+        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?
+      assert_equal "can't be empty", instance.errors.on(:name)
+    end
+  
+   test "when child validations have errors, level 1 parent validations are still performed" do
+      child_class = Class.new do
+        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
+
+      end
+      instance = klass.new
+      instance.valid?
+      assert_equal "can't be empty", instance.errors.on(:name)
+      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
       child_class = Class.new do
         include Validatable

data/test/functional/validates_length_of_test.rb

@@ -13,23 +13,49 @@ module Functional
       assert_equal "is invalid", instance.errors.on(:name)
     end
     
-    test "given exact value, when validated, then error is in the objects error collection" do
+    test "given is constraint, when validated, then error is in the objects error collection" do
       klass = Class.new do
         include Validatable
         attr_accessor :name
         validates_length_of :name, :is => 2
       end
+
       instance = klass.new
       instance.valid?
       assert_equal "is invalid", instance.errors.on(:name)
     end
 
-    test "given exact value is met, when validated, then valid is true" do
+    test "given is constraint is met, when validated, then valid is true" do
       klass = Class.new do
         include Validatable
         attr_accessor :name
         validates_length_of :name, :is => 2
       end
+
+      instance = klass.new
+      instance.name = "bk"
+      assert_equal true, instance.valid?
+    end
+    
+    test "given within constraint, when validated, then error is in the objects error collection" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_length_of :name, :within => 2..4
+      end
+
+      instance = klass.new
+      instance.valid?
+      assert_equal "is invalid", instance.errors.on(:name)
+    end
+
+    test "given within constraint, when validated, then valid is true" do
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name
+        validates_length_of :name, :within => 2..4
+      end
+
       instance = klass.new
       instance.name = "bk"
       assert_equal true, instance.valid?

data/test/functional/validates_numericality_of_test.rb

@@ -41,5 +41,17 @@ module Functional
       assert_equal nil, instance.errors.on(:valid_number)
     end
     
+    test "when validating an integer and the value is a decimal an error should exist on the instance" do
+      klass = Class.new do
+        include Validatable
+        validates_numericality_of :valid_number, :only_integer => true
+        attr_accessor :valid_number
+      end
+      
+      instance = klass.new
+      instance.valid_number = 1.23
+      instance.valid?
+      assert_equal "must be a number", instance.errors.on(:valid_number)
+    end
   end
 end

data/test/functional/validation_assertion_collector_test.rb

@@ -0,0 +1,49 @@
+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

data/test/test_helper.rb

@@ -1,6 +1,8 @@
 require 'test/unit'
 require 'rubygems'
 require 'mocha'
+require 'set'
+
 require File.dirname(__FILE__) + '/../lib/validatable'
 
 class << Test::Unit::TestCase
@@ -12,7 +14,24 @@ class << Test::Unit::TestCase
   
   def expect(expected_value, &block)
     define_method :"test_#{caller.first.split("/").last}" do
-      assert_equal expected_value, instance_eval(&block)
+      begin
+        assert_equal expected_value, instance_eval(&block)
+      rescue Exception => ex
+        raise ex unless expected_value.is_a?(Class) && ex.is_a?(expected_value)
+        assert_equal expected_value, ex.class
+      end
     end 
   end
+end
+
+class Test::Unit::TestCase
+  def assert_array_equal a, b
+    assert_equal Set.new(a), Set.new(b)
+  end
+end
+
+class Array
+  def to_blank_options_hash
+    self.inject({}) {|hash, value| hash[value] = nil; hash }
+  end
 end

data/test/unit/understandable_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class UnderstandableTest < Test::Unit::TestCase
+  test "all understandings should collect understandings from all super classes" do
+    a = Class.new do
+      include Validatable::Understandable
+      understands :a
+    end
+    
+    b = Class.new(a) do
+      include Validatable::Understandable
+      understands :b
+    end
+    c = Class.new(b) do
+      include Validatable::Understandable
+      understands :c
+    end
+    
+    assert_array_equal [:a, :b, :c], c.all_understandings
+  end
+end

data/test/unit/validatable_test.rb

@@ -10,20 +10,6 @@ module Unit
       end
       klass.new.valid?
     end
-  
-    test "when validate is executed, then messages are added for each validation that fails" do
-      klass = Class.new do
-        include Validatable
-      end
-      klass.send(:validations) << stub(:valid? => false, :should_validate? => true, :attribute => 'attribute', :message => 'message', :level => 1)
-      klass.send(:validations) << stub(:valid? => false, :should_validate? => true, :attribute => 'attribute2', :message => 'message2', :level => 1)
-      instance=mock
-      instance.expects(:errors).returns(errors=mock).times 3
-      errors.expects(:add).with('attribute', 'message')
-      errors.expects(:add).with('attribute2', 'message2')
-      errors.expects(:any?).returns false
-      klass.validate(instance)
-    end
 
     expect true do
       klass = Class.new do

data/test/unit/validates_acceptance_of_test.rb

@@ -14,7 +14,7 @@ class ValidatesAcceptanceOfTest < Test::Unit::TestCase
   end
   
   expect true do
-    Validatable::ValidatesAcceptanceOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    Validatable::ValidatesAcceptanceOf.new(:test).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
   end
   
 end

data/test/unit/validates_confirmation_of_test.rb

@@ -14,58 +14,50 @@ class ValidatesConfirmationOfTest < Test::Unit::TestCase
   end
   
   test "valid confirmation with case insensitive" do
-    validation = Validatable::ValidatesConfirmationOf.new :username
-    validation.case_sensitive = false
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = true
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = true
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = true
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = true
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = false
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = false
+    validation = Validatable::ValidatesConfirmationOf.new :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
-    validation.case_sensitive = false
+    validation = Validatable::ValidatesConfirmationOf.new :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.must_understand(options)
+    Validatable::ValidatesConfirmationOf.new(:test).must_understand(options)
   end
   
 end

data/test/unit/validates_format_of_test.rb

@@ -2,25 +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
-    validation.with = /book/
+    validation = Validatable::ValidatesFormatOf.new :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
-    validation.with = /book/
+    validation = Validatable::ValidatesFormatOf.new :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
-    validation.with = /14/
+    validation = Validatable::ValidatesFormatOf.new :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
+    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)
+  end
+  
   expect true do
-    Validatable::ValidatesFormatOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :with => nil)
+    options = [:with]
+    Validatable::ValidatesFormatOf.new(:name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
   end
   
 end

data/test/unit/validates_length_of_test.rb

@@ -2,46 +2,63 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 module Unit
   class ValidatesLengthOfTest < Test::Unit::TestCase
-  
     test "max length" do
-      validation = Validatable::ValidatesLengthOf.new :username
-      validation.maximum = 8
+      validation = Validatable::ValidatesLengthOf.new :username, :maximum => 8
       instance = stub(:username=>"usernamefdfd")
       assert_equal false, validation.valid?(instance)
     end
     
     test "min length" do
-      validation = Validatable::ValidatesLengthOf.new :username
-      validation.minimum = 2
+      validation = Validatable::ValidatesLengthOf.new :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
+      instance = stub(:username=>"udfgdf")
+      assert_equal true, validation.valid?(instance)
+    end
+    
     test "is length is false" do
-      validation = Validatable::ValidatesLengthOf.new :username
-      validation.is = 2
+      validation = Validatable::ValidatesLengthOf.new :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
-      validation.is = 2
+      validation = Validatable::ValidatesLengthOf.new :username, :is => 2
       instance = stub(:username=>"uu")
       assert_equal true, validation.valid?(instance)
     end
     
-    test "valid length" do
-      validation = Validatable::ValidatesLengthOf.new :username
-      validation.minimum = 2
-      validation.maximum = 8
-      instance = stub(:username=>"udfgdf")
+    test "within lower bound is true" do
+      validation = Validatable::ValidatesLengthOf.new :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
+      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
+      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
+      instance = stub(:username => "aaaaa")
+      assert_equal false, validation.valid?(instance)
+    end
+
     expect true do
-      options = {:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :maximum => nil, :minimum => nil, :is => nil}
-      Validatable::ValidatesLengthOf.must_understand(options)
+      options = [:message, :if, :times, :level, :groups, :maximum, :minimum, :is, :within]
+      Validatable::ValidatesLengthOf.new(:test).must_understand(options.to_blank_options_hash)
     end
     
   end

data/test/unit/validates_numericality_of_test.rb

@@ -21,6 +21,18 @@ module Unit
       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
+      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
+      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
       instance = stub(:some_non_numeric => "50F")
@@ -34,7 +46,8 @@ module Unit
     end
     
     expect true do
-      Validatable::ValidatesNumericalityOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+      options = [:message, :if, :times, :level, :groups, :only_integer]
+      Validatable::ValidatesNumericalityOf.new(:test).must_understand(options.to_blank_options_hash)
     end
     
   end

data/test/unit/validates_presence_of_test.rb

@@ -17,7 +17,7 @@ class ValidatesPresenceOfTest < Test::Unit::TestCase
   end
   
   expect true do
-    Validatable::ValidatesPresenceOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    Validatable::ValidatesPresenceOf.new(:test).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
   end
   
 end

data/test/unit/validates_true_for_test.rb

@@ -2,19 +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
-    validation.logic = lambda { false }
+    validation = Validatable::ValidatesTrueFor.new :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
-    validation.logic = lambda { true }
+    validation = Validatable::ValidatesTrueFor.new :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
+    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)
+  end
+  
   expect true do
-    Validatable::ValidatesTrueFor.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :logic => nil)
+    options = [:logic]
+    Validatable::ValidatesTrueFor.new(:name, options.to_blank_options_hash).requires(options.to_blank_options_hash)
   end
   
 end

data/test/unit/validation_base_test.rb

@@ -35,12 +35,12 @@ class ValidationBaseTest < Test::Unit::TestCase
   
   test "invalid option causes raise" do
     assert_raises ArgumentError do
-      Validatable::ValidationBase.must_understand(:foo => 1, :bar => 2)
+      Validatable::ValidationBase.new(:base).must_understand(:foo => 1, :bar => 2)
     end
   end
   
   expect true do
-    Validatable::ValidationBase.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    Validatable::ValidationBase.new(:base).must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
   end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.2.2
-date: 2007-04-27 00:00:00 -04:00
+  version: 1.3.0
+date: 2007-05-02 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib
@@ -30,10 +30,14 @@ authors:
 files: 
 - lib/child_validation.rb
 - lib/errors.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_format_of.rb
@@ -44,6 +48,7 @@ files:
 - 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
@@ -52,7 +57,9 @@ 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/unit/errors_test.rb
+- test/unit/understandable_test.rb
 - test/unit/validatable_test.rb
 - test/unit/validates_acceptance_of_test.rb
 - test/unit/validates_confirmation_of_test.rb