validatable 1.2.1 → 1.2.2

data/README

@@ -64,6 +64,20 @@ Validations can be given levels. If a validation fails on a level the validation
 	person.errors.on(:name) #=> "name message"
 	person.errors.on(:address) #=> nil
 
+Validations can also be given groups. Groups can be used to validate an object when it can be valid in various states.  For example a mortgage application may be valid for saving (saving a partial application), but that same mortgage application would not be valid for underwriting. In our example a application can be saved as long as a Social Security Number is present; however, an application can not be underwritten unless the name attribute contains a value.
+
+  class MortgageApplication
+    include Validatable
+    validates_presence_of :ssn, :groups => [:saving, :underwriting]
+    validates_presence_of :name, :groups => :underwriting
+    attr_accessor :name, :ssn
+  end
+  
+  application = MortgageApplication.new
+  application.ssn = 377990118
+  application.valid_for_saving? #=> true
+  application.valid_for_underwriting? #=> false
+
 Similar to Rails, Validatable also supports conditional validation.
 
 	class Person
@@ -101,8 +115,10 @@ See the tests for more examples
 == Contributors
 Rick Bradley (Revision 25)
 
-Zak Tamsen (Revision 29)
+Anonymous Z (Revision 29)
 
 Jason Miller (Revision 31)
 
-Ali Aghareza (Revision 45)
+Ali Aghareza (Revision 43)
+
+Xavier Shay (Revision 48 & 49)

data/lib/understandable.rb

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

data/lib/validatable.rb

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

data/lib/{base.rb → validatable_class_methods.rb}

@@ -48,6 +48,7 @@ module Validatable
       add_validations(args, ValidatesLengthOf) do |validation, options|
         validation.minimum = options[:minimum]
         validation.maximum = options[:maximum]
+        validation.is = options[:is]
       end
     end
 
@@ -213,7 +214,7 @@ module Validatable
             instance.errors.add(validation.attribute, validation.message) unless validation.valid?(instance)
           end
         end
-        return unless instance.errors.empty?
+        return if instance.errors.any?
       end
     end
     
@@ -236,72 +237,26 @@ module Validatable
     def add_validations(args, klass) #:nodoc:
       options = args.last.is_a?(Hash) ? args.pop : {}
       args.each do |attribute|
-        new_validation = klass.new(attribute, options)
+        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
       end
     end
     
-    def children_to_validate #:nodoc:
-      @children_to_validate ||= []
-    end
-  end
-  
-  def self.included(klass) #:nodoc:
-    klass.extend Validatable::ClassMethods
-  end
-  
-  # call-seq: valid?
-  #
-  # Returns true if no errors were added otherwise false.
-  def valid?(*groups)
-    errors.clear
-    self.class.validate_children(self, groups)
-    self.validate(groups)
-    errors.empty?
-  end
-  
-  # call-seq: errors
-  #
-  # Returns the Errors object that holds all information about attribute error messages.
-  def errors
-    @errors ||= Validatable::Errors.new
-  end
-  
-  protected
-  def validate(groups) #:nodoc:
-    validations_for_groups(groups).each do |validation|
-      validation_levels.sort.each do |level|
-        validations_for_level(level).each do |validation|
-          if validation.should_validate?(self)
-            run_validation(validation)
+    def create_valid_method_for_groups(groups)
+      groups.each do |group|
+        self.class_eval do
+          define_method :"valid_for_#{group}?" do
+            valid_for_group?(group)
           end
         end
-        return unless self.errors.empty?
       end
     end
-  end
-  
-  def run_validation(validation) #:nodoc:
-    validation_result = validation.valid?(self)
-    self.errors.add(validation.attribute, validation.message) unless validation_result
-    validation.run_after_validate(validation_result, self, validation.attribute)
-  end
-  
-  def validation_levels #:nodoc:
-    self.validations.collect { |validation| validation.level }.uniq
-  end
-  
-  def validations_for_level(level) #:nodoc:
-    self.validations.select { |validation| validation.level == level }
-  end
-  
-  def validations_for_groups(groups) #:nodoc:
-    return self.validations if groups.empty?
-    self.validations.select { |validation|  (groups & validation.groups).any? }
-  end
-  
-  def validations #:nodoc:
-    @validations ||= self.class.validations.collect { |validation| validation.dup }
+    
+    def children_to_validate #:nodoc:
+      @children_to_validate ||= []
+    end
   end
 end

data/lib/validatable_instance_methods.rb

@@ -0,0 +1,56 @@
+module Validatable
+  def self.included(klass) #:nodoc:
+    klass.extend Validatable::ClassMethods
+  end
+  
+  # call-seq: valid?
+  #
+  # Returns true if no errors were added otherwise false.
+  def valid?
+    valid_for_group?
+  end
+  
+  # call-seq: errors
+  #
+  # Returns the Errors object that holds all information about attribute error messages.
+  def errors
+    @errors ||= Validatable::Errors.new
+  end
+  
+  protected
+  def valid_for_group?(*groups)
+    errors.clear
+    self.class.validate_children(self, groups)
+    self.validate(groups)
+    errors.empty?
+  end
+
+  def validate(groups) #:nodoc:
+    validation_levels.each do |level|
+      validations_for_level_and_groups(level, groups).each do |validation|
+        run_validation(validation) if validation.should_validate?(self)
+      end
+      return unless self.errors.empty?
+    end
+  end
+
+  def run_validation(validation) #:nodoc:
+    validation_result = validation.valid?(self)
+    self.errors.add(validation.attribute, validation.message) unless validation_result
+    validation.run_after_validate(validation_result, self, validation.attribute)
+  end
+  
+  def validations_for_level_and_groups(level, groups)
+    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
+  end
+  
+  def validations #:nodoc:
+    @validations ||= self.class.validations.collect { |validation| validation.dup }
+  end
+end

data/lib/validations/validates_confirmation_of.rb

@@ -1,6 +1,7 @@
 module Validatable
   class ValidatesConfirmationOf < ValidationBase #:nodoc:
     attr_accessor :case_sensitive
+    understands :case_sensitive
     
     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,9 +1,10 @@
 module Validatable
   class ValidatesFormatOf < ValidationBase #:nodoc:
     attr_accessor :with
+    understands :with
   
     def valid?(instance)
-      instance.send(self.attribute) =~ self.with && true
+      not (instance.send(self.attribute).to_s =~ self.with).nil?
     end
     
     def message

data/lib/validations/validates_length_of.rb

@@ -1,6 +1,7 @@
 module Validatable
   class ValidatesLengthOf < ValidationBase #:nodoc:
-    attr_accessor :minimum, :maximum
+    attr_accessor :minimum, :maximum, :is
+    understands :minimum, :maximum, :is
     
     def message
       super || "is invalid"
@@ -11,6 +12,7 @@ module Validatable
       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
     end
   end

data/lib/validations/validates_true_for.rb

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

data/lib/validations/validation_base.rb

@@ -1,5 +1,8 @@
 module Validatable
   class ValidationBase #:nodoc:
+    extend Understandable
+    understands :message, :if, :times, :level, :groups
+  
     attr_accessor :attribute, :message, :times
     attr_reader :level, :groups
     
@@ -9,7 +12,11 @@ module Validatable
       @conditional = options[:if] || Proc.new { true }
       @times = options[:times]
       @level = options[:level] || 1
-      @groups = options[:groups].is_a?(Array) ? options[:groups] : [options[:groups]]
+      @groups = case options[:groups]
+        when nil then []
+        when Array then options[:groups]
+        else [options[:groups]]
+      end
     end
     
     def should_validate?(instance)

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.1"
+	s.version = "1.2.2"
 	s.author = 'Jay Fields'
 	s.description = "Validatable is a library for adding validations."
 	s.email = 'validatable-developer@rubyforge.org'

data/test/functional/validatable_test.rb

@@ -2,6 +2,19 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 module Functional
   class ValidatableTest < Test::Unit::TestCase
+    test "validations are only executed once" do
+      if_condition = mock
+      if_condition.expects(:where?).times 2
+      klass = Class.new do
+        include Validatable
+        attr_accessor :name, :address
+        validates_presence_of :name, :if => lambda { if_condition.where? }
+        validates_presence_of :address, :if => lambda { if_condition.where? }
+      end
+      instance = klass.new
+      instance.valid?
+    end
+    
     test "given a child class with validations, when parent class is validated, then the error is in the parent objects error collection" do
       child_class = Class.new do
         include Validatable
@@ -75,14 +88,30 @@ module Functional
       assert_equal true, instance.valid?
     end
     
+    test "classes only have valid_for_* methods for groups that appear in their validations" do
+      class_with_group_one = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_one
+        attr_accessor :name
+      end
+      class_with_group_two = Class.new do
+        include Validatable
+        validates_presence_of :name, :groups => :group_two
+        attr_accessor :name
+      end
+      assert_equal false, class_with_group_one.public_instance_methods.include?(:valid_for_group_two?)
+      assert_equal false, class_with_group_two.public_instance_methods.include?(:valid_for_group_one?)
+    end
+    
     test "nonmatching groups are not used as validations" do
       klass = Class.new do
         include Validatable
         validates_presence_of :name, :groups => :group_one
-        attr_accessor :name
+        validates_presence_of :address, :groups => :group_two
+        attr_accessor :name, :address
       end
       instance = klass.new
-      assert_equal true, instance.valid?(:group_two)
+      assert_equal nil, instance.errors.on(:name)
     end
     
     test "after validate is called following a validation" do
@@ -116,7 +145,7 @@ module Functional
         attr_accessor :name
       end
       instance = klass.new
-      assert_equal false, instance.valid?(:group_one)
+      assert_equal false, instance.valid_for_group_one?
     end
     
     test "matching groups are used as validations when validations are part of multiple groups" do
@@ -126,7 +155,7 @@ module Functional
         attr_accessor :name
       end
       instance = klass.new
-      assert_equal false, instance.valid?(:group_one)
+      assert_equal false, instance.valid_for_group_one?
     end
     
     test "no group given then all validations are used" do
@@ -139,18 +168,6 @@ module Functional
       assert_equal false, instance.valid?
     end
     
-    test "matching multiple groups for validations" do
-      klass = Class.new do
-        include Validatable
-        validates_presence_of :name, :groups => :group_one
-        validates_presence_of :address, :groups => :group_two
-        attr_accessor :name, :address
-      end
-      instance = klass.new
-      instance.valid?(:group_one, :group_two)
-      assert_equal 2, instance.errors.size
-    end
-    
     expect true do
       klass = Class.new do
         include Validatable

data/test/functional/validates_length_of_test.rb

@@ -12,5 +12,27 @@ module Functional
       instance.valid?
       assert_equal "is invalid", instance.errors.on(:name)
     end
+    
+    test "given exact value, 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
+      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
   end
 end

data/test/unit/validatable_test.rb

@@ -21,7 +21,7 @@ module Unit
       instance.expects(:errors).returns(errors=mock).times 3
       errors.expects(:add).with('attribute', 'message')
       errors.expects(:add).with('attribute2', 'message2')
-      errors.expects(:empty?).returns true
+      errors.expects(:any?).returns false
       klass.validate(instance)
     end
 

data/test/unit/validates_acceptance_of_test.rb

@@ -12,4 +12,9 @@ class ValidatesAcceptanceOfTest < Test::Unit::TestCase
     instance = stub(:acceptance=>'false')
     assert_equal false, validation.valid?(instance)
   end
+  
+  expect true do
+    Validatable::ValidatesAcceptanceOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+  end
+  
 end

data/test/unit/validates_confirmation_of_test.rb

@@ -62,4 +62,10 @@ class ValidatesConfirmationOfTest < Test::Unit::TestCase
     validation.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)
+  end
+  
 end

data/test/unit/validates_format_of_test.rb

@@ -12,4 +12,15 @@ class ValidatesFormatOfTest < Test::Unit::TestCase
     validation.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/
+    assert_equal true, validation.valid?(stub(:age=>14))
+  end
+  
+  expect true do
+    Validatable::ValidatesFormatOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :with => nil)
+  end
+  
 end

data/test/unit/validates_length_of_test.rb

@@ -17,6 +17,20 @@ module Unit
       assert_equal false, validation.valid?(instance)
     end
   
+    test "is length is false" do
+      validation = Validatable::ValidatesLengthOf.new :username
+      validation.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
+      instance = stub(:username=>"uu")
+      assert_equal true, validation.valid?(instance)
+    end
+    
     test "valid length" do
       validation = Validatable::ValidatesLengthOf.new :username
       validation.minimum = 2
@@ -24,5 +38,11 @@ module Unit
       instance = stub(:username=>"udfgdf")
       assert_equal true, 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)
+    end
+    
   end
 end

data/test/unit/validates_numericality_of_test.rb

@@ -32,5 +32,10 @@ module Unit
       instance = stub(:multiple_dots => "50.0.0")
       assert_equal false, validation.valid?(instance)
     end
+    
+    expect true do
+      Validatable::ValidatesNumericalityOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+    end
+    
   end
 end

data/test/unit/validates_presence_of_test.rb

@@ -16,4 +16,8 @@ class ValidatesPresenceOfTest < Test::Unit::TestCase
     assert_equal true, validation.valid?(stub(:employee => stub(:nil? => false)))
   end
   
+  expect true do
+    Validatable::ValidatesPresenceOf.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil)
+  end
+  
 end

data/test/unit/validates_true_for_test.rb

@@ -13,4 +13,8 @@ class ValidatesTrueForTest < Test::Unit::TestCase
     assert_equal true, validation.valid?(stub_everything)
   end
   
+  expect true do
+    Validatable::ValidatesTrueFor.must_understand(:message => nil, :if => nil, :times => nil, :level => nil, :groups => nil, :logic => nil)
+  end
+  
 end

data/test/unit/validation_base_test.rb

@@ -32,4 +32,15 @@ class ValidationBaseTest < Test::Unit::TestCase
     validation = Validatable::ValidationBase.new :base
     validation.level
   end
+  
+  test "invalid option causes raise" do
+    assert_raises ArgumentError do
+      Validatable::ValidationBase.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)
+  end
+
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.8.11
 specification_version: 1
 name: validatable
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
-date: 2007-04-26 00:00:00 -04:00
+  version: 1.2.2
+date: 2007-04-27 00:00:00 -04:00
 summary: Validatable is a library for adding validations.
 require_paths: 
 - lib
@@ -25,14 +25,15 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
-post_install_message: 
 authors: 
 - Jay Fields
 files: 
-- lib/base.rb
 - lib/child_validation.rb
 - lib/errors.rb
+- lib/understandable.rb
 - lib/validatable.rb
+- lib/validatable_class_methods.rb
+- lib/validatable_instance_methods.rb
 - lib/validations/validates_acceptance_of.rb
 - lib/validations/validates_confirmation_of.rb
 - lib/validations/validates_format_of.rb