validatable 1.4.0 → 1.5.0

data/lib/errors.rb

@@ -25,10 +25,16 @@ module Validatable
       self
     end
 
+    # call-seq: replace(attribute)
+    # 
+    # * Replaces the errors value for the given +attribute+
     def replace(attribute, value)
       errors[attribute.to_sym] = value
     end
 
+    # call-seq: raw(attribute)
+    # 
+    # * Returns an array of error messages associated with the specified +attribute+.
     def raw(attribute)
       errors[attribute.to_sym]
     end

data/lib/macros.rb

@@ -0,0 +1,200 @@
+module Validatable
+  module Macros
+    # call-seq: validates_format_of(*args)
+    # 
+    # Validates whether the value of the specified attribute is of the 
+    # correct form by matching it against the regular expression provided.
+    # 
+    #   class Person
+    #     include Validatable    
+    #     validates_format_of :first_name, :with => /[ A-Za-z]/
+    #   end
+    # 
+    # A regular expression must be provided or else an exception will be raised.
+    # 
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * 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)
+    end
+    
+    # call-seq: validates_length_of(*args)
+    # 
+    # Validates that the specified attribute matches the length restrictions supplied.
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_length_of :first_name, :maximum=>30
+    #     validates_length_of :last_name, :minimum=>30
+    #   end
+    # 
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * 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)
+    end
+
+    # call-seq: validates_numericality_of(*args)
+    # 
+    # Validates that the specified attribute is numeric.
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_numericality_of :age
+    #   end
+    # 
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    #     * only_integer - Whether the attribute must be an integer (default is false)
+    def validates_numericality_of(*args)
+      add_validations(args, ValidatesNumericalityOf)
+    end
+
+    # call-seq: validates_acceptance_of(*args)
+    #
+    # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_acceptance_of :terms_of_service
+    #     validates_acceptance_of :eula, :message => "must be abided"
+    #   end
+    #
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    def validates_acceptance_of(*args)
+      add_validations(args, ValidatesAcceptanceOf)
+    end
+
+    # call-seq: validates_confirmation_of(*args)
+    #
+    # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
+    # 
+    #   Class:
+    #     class PersonPresenter
+    #       include Validatable
+    #       validates_confirmation_of :user_name, :password
+    #       validates_confirmation_of :email_address, :message => "should match confirmation"
+    #     end
+    # 
+    #   View:
+    #     <%= password_field "person", "password" %>
+    #     <%= password_field "person", "password_confirmation" %>
+    #
+    # Configuration options:
+    # 
+    #     * case_sensitive - Whether or not to apply case-sensitivity on the comparison.  Defaults to true.
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    def validates_confirmation_of(*args)
+      add_validations(args, ValidatesConfirmationOf)
+    end
+  
+    # call-seq: validates_presence_of(*args)
+    # 
+    # Validates that the specified attributes are not nil or an empty string
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_presence_of :first_name
+    #   end
+    #
+    # The first_name attribute must be in the object and it cannot be nil or empty.
+    #
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    def validates_presence_of(*args)
+      add_validations(args, ValidatesPresenceOf)
+    end
+    
+    # call-seq: validates_true_for(*args)
+    # 
+    # Validates that the logic evaluates to true
+    # 
+    #   class Person
+    #     include Validatable
+    #     validates_true_for :first_name, :logic => lambda { first_name == 'Jamie' }
+    #   end
+    #
+    # The logic option is required.
+    #
+    # Configuration options:
+    # 
+    #     * message - The message to add to the errors collection when the validation fails
+    #     * times - The number of times the validation applies
+    #     * level - The level at which the validation should occur
+    #     * if - A block that when executed must return true of the validation will not occur
+    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+    #     * logic - A block that executes to perform the validation
+    def validates_true_for(*args)
+      add_validations(args, ValidatesTrueFor)
+    end
+    
+    # call-seq: include_validations_for(attribute_to_validate, options = {})
+    # 
+    # Validates the specified attributes.
+    #   class Person
+    #     include Validatable
+    #     validates_presence_of :name
+    #     attr_accessor :name
+    #   end
+    # 
+    #   class PersonPresenter
+    #     include Validatable
+    #     include_validations_for :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
+    #     attr_accessor :person
+    #     
+    #     def initialize(person)
+    #       @person = person
+    #     end
+    #   end
+    #   
+    #   presenter = PersonPresenter.new(Person.new)
+    #   presenter.valid? #=> false
+    #   presenter.errors.on(:namen) #=> "can't be blank"
+    #
+    # The person attribute will be validated.  
+    # If person is invalid the errors will be added to the PersonPresenter errors collection.
+    #
+    # Configuration options:
+    # 
+    #     * map - A hash that maps attributes of the child to attributes of the parent.
+    #     * if - A block that when executed must return true of the validation will not occur.
+    def include_validations_for(attribute_to_validate, options = {})
+      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+    end
+  end
+end

data/lib/requireable.rb

@@ -1,6 +1,6 @@
 module Validatable
   module Requireable #:nodoc:
-    module ClassMethods
+    module ClassMethods #:nodoc:
       def requires(*args)
         required_options.concat args        
       end

data/lib/understandable.rb

@@ -1,6 +1,6 @@
 module Validatable
   module Understandable #:nodoc:
-    module ClassMethods
+    module ClassMethods #:nodoc:
       def understands(*args)
         understandings.concat args
       end

data/lib/validatable.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 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__) + '/child_validation')
 require File.expand_path(File.dirname(__FILE__) + '/understandable')

data/lib/validatable_assertions.rb

@@ -1,51 +1,74 @@
-module ValidatableAssertions
+module Validatable
+  module Assertions
 
-  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_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
-    backtrace = caller
-    backtrace.shift
-    backtrace.shift
-    backtrace
-  end
+    def create_backtrace #:nodoc:
+      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
+    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
-      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.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
-        class_eval do
-          define_method name, &block
+        def self.define_test_method name, &block #:nodoc:
+          class_eval do
+            define_method name, &block
+          end
         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?
+      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

data/lib/validatable_class_methods.rb

@@ -1,201 +1,7 @@
 module Validatable
-  module ClassMethods
-    # call-seq: validates_format_of(*args)
-    # 
-    # Validates whether the value of the specified attribute is of the correct form by matching it against the regular expression provided.
-    # 
-    #   class Person
-    #     include Validatable    
-    #     validates_format_of :first_name, :with => /[ A-Za-z]/
-    #   end
-    # 
-    # A regular expression must be provided or else an exception will be raised.
-    # 
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * 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)
-    end
-    
-    # call-seq: validates_length_of(*args)
-    # 
-    # Validates that the specified attribute matches the length restrictions supplied.
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_length_of :first_name, :maximum=>30
-    #     validates_length_of :last_name, :minimum=>30
-    #   end
-    # 
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * 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)
-    end
-
-    # call-seq: validates_numericality_of(*args)
-    # 
-    # Validates that the specified attribute is numeric.
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_numericality_of :age
-    #   end
-    # 
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    #     * only_integer - Whether the attribute must be an integer (default is false)
-    def validates_numericality_of(*args)
-      add_validations(args, ValidatesNumericalityOf)
-    end
-
-    # call-seq: validates_acceptance_of(*args)
-    #
-    # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_acceptance_of :terms_of_service
-    #     validates_acceptance_of :eula, :message => "must be abided"
-    #   end
-    #
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_acceptance_of(*args)
-      add_validations(args, ValidatesAcceptanceOf)
-    end
-
-    # call-seq: validates_confirmation_of(*args)
-    #
-    # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
-    # 
-    #   Class:
-    #     class PersonPresenter
-    #       include Validatable
-    #       validates_confirmation_of :user_name, :password
-    #       validates_confirmation_of :email_address, :message => "should match confirmation"
-    #     end
-    # 
-    #   View:
-    #     <%= password_field "person", "password" %>
-    #     <%= password_field "person", "password_confirmation" %>
-    #
-    # Configuration options:
-    # 
-    #     * case_sensitive - Whether or not to apply case-sensitivity on the comparison.  Defaults to true.
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_confirmation_of(*args)
-      add_validations(args, ValidatesConfirmationOf)
-    end
-  
-    # call-seq: validates_presence_of(*args)
-    # 
-    # Validates that the specified attributes are not nil or an empty string
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_presence_of :first_name
-    #   end
-    #
-    # The first_name attribute must be in the object and it cannot be nil or empty.
-    #
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    def validates_presence_of(*args)
-      add_validations(args, ValidatesPresenceOf)
-    end
-    
-    # call-seq: validates_true_for(*args)
-    # 
-    # Validates that the logic evaluates to true
-    # 
-    #   class Person
-    #     include Validatable
-    #     validates_true_for :first_name, :logic => lambda { first_name == 'Jamie' }
-    #   end
-    #
-    # The logic option is required.
-    #
-    # Configuration options:
-    # 
-    #     * message - The message to add to the errors collection when the validation fails
-    #     * times - The number of times the validation applies
-    #     * level - The level at which the validation should occur
-    #     * if - A block that when executed must return true of the validation will not occur
-    #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
-    #     * logic - A block that executes to perform the validation
-    def validates_true_for(*args)
-      add_validations(args, ValidatesTrueFor)
-    end
-    
-    # call-seq: include_validations_for(attribute_to_validate, options = {})
-    # 
-    # Validates the specified attributes.
-    #   class Person
-    #     include Validatable
-    #     validates_presence_of :name
-    #     attr_accessor :name
-    #   end
-    # 
-    #   class PersonPresenter
-    #     include Validatable
-    #     include_validations_for :person, :map => { :name => :namen }, :if => lambda { not person.nil? }
-    #     attr_accessor :person
-    #     
-    #     def initialize(person)
-    #       @person = person
-    #     end
-    #   end
-    #   
-    #   presenter = PersonPresenter.new(Person.new)
-    #   presenter.valid? #=> false
-    #   presenter.errors.on(:namen) #=> "can't be blank"
-    #
-    # The person attribute will be validated.  If person is invalid the errors will be added to the PersonPresenter errors collection.
-    #
-    # Configuration options:
-    # 
-    #     * map - A hash that maps attributes of the child to attributes of the parent.
-    #     * if - A block that when executed must return true of the validation will not occur.
-    def include_validations_for(attribute_to_validate, options = {})
-      children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
-    end
+  module ClassMethods #:nodoc:
     
-    def validate_children(instance, group) #:nodoc:
+    def validate_children(instance, group)
       self.children_to_validate.each do |child_validation|
         next unless child_validation.should_validate?(instance)
         child = instance.send child_validation.attribute
@@ -216,11 +22,11 @@ module Validatable
       end
     end
 
-    def validations #:nodoc:
+    def validations
       @validations ||= []
     end
     
-    def add_error(instance, attribute, msg) #:nodoc:
+    def add_error(instance, attribute, msg)
       instance.errors.add(attribute, msg)
     end
     
@@ -230,7 +36,7 @@ module Validatable
     
     protected
     
-    def add_validations(args, klass) #:nodoc:
+    def add_validations(args, klass)
       options = args.last.is_a?(Hash) ? args.pop : {}
       args.each do |attribute|
         new_validation = klass.new self, attribute, options
@@ -239,7 +45,7 @@ module Validatable
       end
     end
     
-    def create_valid_method_for_groups(groups) #:nodoc:
+    def create_valid_method_for_groups(groups)
       groups.each do |group|
         self.class_eval do
           define_method "valid_for_#{group}?".to_sym do
@@ -249,7 +55,7 @@ module Validatable
       end
     end
     
-    def children_to_validate #:nodoc:
+    def children_to_validate
       @children_to_validate ||= []
     end
     

data/lib/validatable_instance_methods.rb

@@ -1,13 +1,14 @@
 module Validatable
   def self.included(klass) #:nodoc:
     klass.extend Validatable::ClassMethods
+    klass.extend Validatable::Macros
   end
   
   # call-seq: valid?
   #
-  # Returns true if no errors were added otherwise false.
+  # Returns true if no errors were added otherwise false. Only executes validations that have no :groups option specified
   def valid?
-    valid_for_group?
+    valid_for_group?(nil)
   end
   
   # call-seq: errors
@@ -17,22 +18,18 @@ module Validatable
     @errors ||= Validatable::Errors.new
   end
   
-  def valid_for_group?(group=nil) #:nodoc:
+  def valid_for_group?(group) #:nodoc:
     errors.clear
     self.class.validate_children(self, group)
     self.validate(group)
     errors.empty?
   end
   
-  def times_validated(key)
+  def times_validated(key) #:nodoc:
     times_validated_hash[key] || 0
   end
   
-  def times_validated_hash
-    @times_validated_hash ||= {}
-  end
-  
-  def increment_times_validated_for(validation)
+  def increment_times_validated_for(validation) #:nodoc:
     if validation.key != nil
       if times_validated_hash[validation.key].nil?
         times_validated_hash[validation.key] = 1
@@ -43,6 +40,10 @@ module Validatable
   end
 
   protected
+  def times_validated_hash #:nodoc:
+    @times_validated_hash ||= {}
+  end
+
   def validate(group) #:nodoc:
     validation_levels.each do |level|
       validations_for_level_and_group(level, group).each do |validation|
@@ -65,7 +66,7 @@ module Validatable
   
   def validations_for_level_and_group(level, group) #:nodoc:
     validations_for_level = self.class.validations.select { |validation| validation.level == level }
-    return validations_for_level if group.nil?
+    return validations_for_level.select { |validation| validation.groups.empty? } if group.nil?
     validations_for_level.select { |validation| validation.groups.include?(group) }
   end
   

data/lib/validation_assertion.rb

@@ -1,4 +1,4 @@
-class ValidationAssertion
+class ValidationAssertion #:nodoc:
   attr_accessor :klass, :validation_type, :options, :attribute
   
   def initialize(klass, validation_type, attribute)

data/lib/validation_assertion_collector.rb

@@ -1,4 +1,4 @@
-class ValidationAssertionCollector
+class ValidationAssertionCollector #:nodoc:
   def self.gather(klass, &block)
     collector = self.new(klass)
     collector.instance_eval(&block)
@@ -12,7 +12,7 @@ class ValidationAssertionCollector
     end
   end
 
-  Validatable::ClassMethods.public_instance_methods.sort.grep(/^validates_/).each do |validation_method|
+  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)

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.4.0"
+	s.version = "1.5.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

@@ -1,23 +1,23 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
-class ValidatableAssertionsTest < Test::Unit::TestCase
+class Validatable::AssertionsTest < Test::Unit::TestCase
   expect "Klass does not contain a ValidationType for Attribute" do
     klass = Class.new do
-      include ValidatableAssertions
+      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 ValidatableAssertions
+      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 ValidatableAssertions
+      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)
@@ -26,7 +26,7 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
 
   expect false do
     klass = Class.new do
-      include ValidatableAssertions
+      include Validatable::Assertions
     end
     assertion = stub(:validation_type=>stub(:=== => true), :attribute => "non matching attribute", :options=>{})
     validation = stub(:validation_type=>"validation_type", :attribute => nil)
@@ -35,7 +35,7 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
   
   expect false do
     klass = Class.new do
-      include ValidatableAssertions
+      include Validatable::Assertions
     end
     assertion = stub(:validation_type=>"non matching validation_type", :options=>{})
     validation = stub(:validation_type=>"validation_type")
@@ -44,7 +44,7 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
 
   expect true do
     klass = Class.new do
-      include ValidatableAssertions
+      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)
@@ -53,7 +53,7 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
   
   expect true do
     Class.new do
-      include ValidatableAssertions
+      include Validatable::Assertions
     end
     
     Class.respond_to? :must_validate
@@ -61,14 +61,14 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
   
   expect "test_validates_presence_of_name" do
     test_class = Class.new(Test::Unit::TestCase) do
-      include ValidatableAssertions
+      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 ValidatableAssertions
+      include Validatable::Assertions
     end
     
     test_class.define_test_method :some_test do 
@@ -83,7 +83,7 @@ class ValidatableAssertionsTest < Test::Unit::TestCase
       include Validatable
     end
     test_class = Class.new Test::Unit::TestCase do
-      include ValidatableAssertions
+      include Validatable::Assertions
       
       klass.must_validate do
         presence_of :anything

data/test/functional/validatable_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 module Functional
-  class ValidatableTest < Test::Unit::TestCase
+  class ValidatableTest < Test::Unit::TestCase 
     
     expect ArgumentError do
       Class.new do
@@ -227,7 +227,19 @@ module Functional
       instance.valid_for_group_one?
     end
     
-    expect false do
+    expect true do
+      klass = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        validates_presence_of :address
+        attr_accessor :name, :address
+      end
+      instance = klass.new
+      instance.address = 'anything'
+      instance.valid?
+    end
+    
+    expect true do
       klass = Class.new do
         include Validatable
         validates_presence_of :name, :groups => :group_one

data/test/unit/validatable_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 module Unit
   class ValidatableTest < Test::Unit::TestCase
     expect false do
-      validation = stub_everything(:valid? => false, :should_validate? => true, :attribute => "attribute", :level => 1)
+      validation = stub_everything(:should_validate? => true, :attribute => "attribute", :level => 1, :groups => [])
       klass = Class.new do
         include Validatable
         validations << validation

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
-date: 2007-06-02 00:00:00 -04:00
+  version: 1.5.0
+date: 2007-06-19 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib
@@ -31,6 +31,7 @@ authors:
 files: 
 - lib/child_validation.rb
 - lib/errors.rb
+- lib/macros.rb
 - lib/requireable.rb
 - lib/understandable.rb
 - lib/validatable.rb