mongomatic 0.1.4 → 0.1.31

data/README.rdoc

@@ -2,23 +2,12 @@
 
 Mongomatic allows you to map your Ruby objects to Mongo documents. It is designed to be fast and simple.
 
-== What's different about Mongomatic?
-
-* Follows Mongo idioms wherever possible.
-* Only strives to do "just enough" and never too much.
-* When possible, we defer to Mongo. For example, there's no Mongomatic query API, instead you use the same query hash syntax you would with the Ruby Mongo driver.
-* No complex relationship management: if you want to model relationships then add your own finder methods.
-* Minimal dependencies.
-
 == Basic Usage
 
   require 'mongomatic'
   
   class User < Mongomatic::Base
-    def validate
-      self.errors << ["Name", "can't be empty"]  if self["name"].blank?
-      self.errors << ["Email", "can't be empty"] if self["email"].blank?
-    end
+    validates_presence_of :name, :email
   end
   
   # set the db for all models:
@@ -35,33 +24,42 @@ Mongomatic allows you to map your Ruby objects to Mongo documents. It is designe
   => true
   u.insert
   => BSON::ObjectID('4c32834f0218236321000001')
-  
+  u
+  => #<User:0x00000100d0cbf8 @doc={"name"=>"Ben", "email"=>"me@somewhere.com", "_id"=>BSON::ObjectID('4c32834f0218236321000001')}, @removed=false, @validation_context=nil, @errors={}, @_initialized_validate_callbacks=true>
   u["name"] = "Ben Myles"
   => "Ben Myles" 
   u.update
-  => 137 
-  
-  found = User.find_one({"name" => "Ben Myles"})
-  => #<User:0x00000101939a48 @doc={"_id"=>BSON::ObjectID('4c32834f0218236321000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false, @is_new=false, @errors=[]>
-  User.find_one(BSON::ObjectID('4c32834f0218236321000001')) == found
-  => true
+  => 142 
   
   cursor = User.find({"name" => "Ben Myles"})
-  => #<Mongomatic::Cursor:0x0000010195b4e0 @obj_class=User, @mongo_cursor=<Mongo::Cursor:0x80cadac0 namespace='mongomatic_test.User' @selector={"name"=>"Ben Myles"}>>
+  => #<Mongomatic::Cursor:0x00000100cf5110 @obj_class=User, @mongo_cursor=DBResponse(flags=, cursor_id=, start=)>  cursor.count
+  cursor.count
+  => 1 
   found = cursor.next
-  => #<User:0x00000101939a48 @doc={"_id"=>BSON::ObjectID('4c32834f0218236321000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false, @is_new=false, @errors=[]>
+  => #<User:0x00000100ccd408 @doc={"_id"=>BSON::ObjectID('4c32c3720218236526000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false>
   found.remove
-  => 67
-  User.count
-  => 0
-  User.find({"name" => "Ben Myles"}).next
+  => 72
+  found
+  => #<User:0x00000101091f80 @doc={"_id"=>BSON::ObjectID('4c32c4480218236538000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=true> 
+  cursor = User.find({"name" => "Ben Myles"})
+  => #<Mongomatic::Cursor:0x00000100d9eb20 @obj_class=User, @mongo_cursor=DBResponse(flags=, cursor_id=, start=)> 
+  cursor.count
+  => 0 
+  cursor.next
   => nil
-    
+  
+  found = User.find_one({"name" => "Ben Myles"})
+  => #<User:0x00000100ccd408 @doc={"_id"=>BSON::ObjectID('4c32c3720218236526000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false>
+  found = User.find_one(BSON::ObjectID('4c32c3720218236526000001'))
+  => #<User:0x00000100ccd408 @doc={"_id"=>BSON::ObjectID('4c32c3720218236526000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false>
+  
 == Indexes
 
 Mongomatic doesn't do anything special to support indexes, but here's the suggested convention:
 
-  class Person < Mongomatic::Base  
+  class Person < Mongomatic::Base
+    validates_presence_of :name, :email
+  
     class << self
       def create_indexes
         collection.create_index("email", :unique => true)
@@ -71,69 +69,7 @@ Mongomatic doesn't do anything special to support indexes, but here's the sugges
   
 You can run Person.create_indexes whenever you add new indexes, it won't throw an error if they already exist.
 
-If you have defined a unique index and want Mongomatic to raise an exception on a duplicate insert you need to use insert! or update!. The error thrown will be Mongo::OperationFailure. See the test suite for examples.
-
-== Validations
-
-You can add validations to your model by creating a validate method. If your validate method pushes anything into the self.errors object your model will fail to validate, otherwise if self.errors remains empty the validations will be taken to have passed.
-
-  class Person < Mongomatic::Base  
-    def validate
-      self.errors << ["name", "blank"]  if self["name"].blank?
-      self.errors << ["email", "blank"] if self["email"].blank?
-      self.errors << ["address.zip", "blank"] if (self["address"] || {})["zip"].blank?
-    end
-  end
-  
-  p = Person.new
-  => #<Person:0x000001018c2d58 @doc={}, @removed=false, @is_new=true, @errors=[]>
-  p.valid?
-  => false
-  p.errors
-  => [["name", "blank"], ["email", "blank"], ["address.zip", "blank"]]
-  p.errors.full_messages
-  => ["name blank", "email blank", "address.zip blank"]
-  p["name"] = "Ben"
-  p["email"] = "Myles"
-  p["address"] = { "zip" => 94107 }
-  p.valid?
-  => true
-
-== Relationships
-
-Mongomatic doesn't have any kind of special support for relationship management but it's easy to add this to your models where you need it. Here's an example that models Twitter-like followers on a User model:
-
-  class User < Mongomatic::Base  
-    class << self
-      def create_indexes
-        self.collection.create_index("following_ids")
-      end
-    end
-  
-    def follow(user)
-      self.push("following_ids", user["_id"])
-    end
-  
-    def unfollow(user)
-      self.pull("following_ids", user["_id"])
-    end
-  
-    def following
-      return nil if new?
-      self.class.find( { "_id" => { "$in" => (self["following_ids"] || []) } } )
-    end
-  
-    def followers
-      return nil if new?
-      self.class.find( { "following_ids" => self["_id"] } )
-    end
-  
-    def friends
-      return nil if new?
-      self.class.find( { "following_ids" => self["_id"], 
-                         "_id" => { "$in" => (self["following_ids"] || []) } } )
-    end
-  end
+If you have defined a unique index and want Mongomatic to raise an exception on a duplicate insert you need to use insert_safe or update_safe. The error thrown will be Mongo::OperationFailure. See the test suite for examples.
 
 == Note on Patches/Pull Requests
  

data/lib/mongomatic.rb

@@ -27,7 +27,8 @@ module Mongomatic
   end
 end
 
+require "#{File.dirname(__FILE__)}/mongomatic/validatable"
+
 require "#{File.dirname(__FILE__)}/mongomatic/cursor"
 require "#{File.dirname(__FILE__)}/mongomatic/modifiers"
-require "#{File.dirname(__FILE__)}/mongomatic/errors"
 require "#{File.dirname(__FILE__)}/mongomatic/base"

data/lib/mongomatic/base.rb

@@ -1,6 +1,7 @@
 module Mongomatic
   class Base
     include Mongomatic::Modifiers
+    include Mongomatic::Validatable
     
     class << self
       def db
@@ -47,25 +48,12 @@ module Mongomatic
       end
     end
 
-    attr_accessor :removed, :is_new, :errors
+    attr_accessor :removed, :is_new
 
     def initialize(doc={}, is_new=true)
       @doc = doc.stringify_keys
       self.removed = false
       self.is_new  = is_new
-      self.errors  = Mongomatic::Errors.new
-    end
-    
-    def validate
-      true
-    end
-    
-    def valid?
-      self.errors = Mongomatic::Errors.new
-      self.send(:before_validate) if self.respond_to?(:before_validate)
-      validate
-      self.send(:after_validate) if self.respond_to?(:after_validate)
-      self.errors.empty?
     end
     
     def is_new?

data/lib/mongomatic/validatable.rb

@@ -0,0 +1,31 @@
+# gem "activesupport", "2.3.5"
+
+require "forwardable"
+
+require "#{File.dirname(__FILE__)}/validatable/object_extension"
+require "#{File.dirname(__FILE__)}/validatable/errors"
+require "#{File.dirname(__FILE__)}/validatable/validatable_class_methods"
+require "#{File.dirname(__FILE__)}/validatable/macros"
+require "#{File.dirname(__FILE__)}/validatable/validatable_instance_methods"
+require "#{File.dirname(__FILE__)}/validatable/included_validation"
+require "#{File.dirname(__FILE__)}/validatable/child_validation"
+require "#{File.dirname(__FILE__)}/validatable/understandable"
+require "#{File.dirname(__FILE__)}/validatable/requireable"
+require "#{File.dirname(__FILE__)}/validatable/validations/validation_base"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_format_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_presence_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_acceptance_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_confirmation_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_length_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_true_for"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_numericality_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_exclusion_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_inclusion_of"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_each"
+require "#{File.dirname(__FILE__)}/validatable/validations/validates_associated"
+
+module Mongomatic
+  module Validatable
+    Version = "1.8.4"
+  end
+end

data/lib/mongomatic/validatable/child_validation.rb

@@ -0,0 +1,17 @@
+module Mongomatic
+  module Validatable
+    class ChildValidation #:nodoc:
+      attr_accessor :attribute, :map, :should_validate_proc
+    
+      def initialize(attribute, map, should_validate_proc)
+        @attribute = attribute
+        @map = map
+        @should_validate_proc = should_validate_proc
+      end
+    
+      def should_validate?(instance)
+        instance.instance_eval &should_validate_proc
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/errors.rb

@@ -0,0 +1,108 @@
+module Mongomatic
+  module Validatable
+    class Errors
+      extend Forwardable
+      include Enumerable
+
+      def_delegators :errors, :clear, :each, :each_pair, :empty?, :length, :size
+
+      # Returns true if the specified +attribute+ has errors associated with it.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.invalid?(:name)      # => true
+      #   company.errors.invalid?(:address)   # => false
+      def invalid?(attribute)
+        !@errors[attribute.to_sym].nil?
+      end
+
+      # Adds an error to the base object instead of any particular attribute. This is used
+      # to report errors that don't tie to any specific attribute, but rather to the object
+      # as a whole. These error messages don't get prepended with any field name when iterating
+      # with +each_full+, so they should be complete sentences.
+      def add_to_base(msg)
+        add(:base, msg)
+      end
+
+      # Returns errors assigned to the base object through +add_to_base+ according to the normal rules of <tt>on(attribute)</tt>.
+      def on_base
+        on(:base)
+      end    
+
+      # call-seq: on(attribute)
+      #
+      # * Returns nil, if no errors are associated with the specified +attribute+.
+      # * Returns the error message, if one error is associated with the specified +attribute+.
+      # * Returns an array of error messages, if more than one error is associated with the specified +attribute+.
+      def on(attribute)
+        return nil if errors[attribute.to_sym].nil?
+        errors[attribute.to_sym].size == 1 ? errors[attribute.to_sym].first : errors[attribute.to_sym]
+      end
+
+      # Rails 3 API for errors, always return array.
+      def [](attribute)
+        errors[attribute.to_sym] || []
+      end
+
+      def add(attribute, message) #:nodoc:
+        errors[attribute.to_sym] = [] if errors[attribute.to_sym].nil?
+        errors[attribute.to_sym] << message
+      end
+
+      def merge!(errors) #:nodoc:
+        errors.each_pair{|k, v| add(k,v)}
+        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
+
+      def errors #:nodoc:
+        @errors ||= {}
+      end
+
+      def count #:nodoc:
+        errors.values.flatten.size
+      end
+
+      # call-seq: full_messages -> an_array_of_messages
+      #
+      # Returns an array containing the full list of error messages.
+      def full_messages
+        full_messages = []
+
+        errors.each_key do |attribute|
+          errors[attribute].each do |msg|
+            next if msg.nil?
+
+            if attribute.to_s == "base"
+              full_messages << msg
+            else
+              full_messages << humanize(attribute.to_s) + " " + msg
+            end
+          end
+        end
+        full_messages
+      end
+
+      def humanize(lower_case_and_underscored_word) #:nodoc:
+        lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+      end
+    end
+  end
+end

data/lib/mongomatic/validatable/included_validation.rb

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

data/lib/mongomatic/validatable/macros.rb

@@ -0,0 +1,316 @@
+module Mongomatic
+  module Validatable
+    module Macros
+      # call-seq: validates_each(*args)
+      # 
+      # Validates that the logic evaluates to true
+      # 
+      #   class Address
+      #     include Validatable
+      #     validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") if ZipCodeService.allows(zip_code) }
+      #   end
+      #
+      # The logic option is required.
+      #
+      # Configuration options:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * group - The group that this validation belongs to.  A validation can belong to multiple groups
+      #     * if - A block that when executed must return true of the validation will not occur
+      #     * level - The level at which the validation should occur
+      #     * logic - A block that executes to perform the validation
+      #     * message - The message to add to the errors collection when the validation fails
+      #     * times - The number of times the validation applies
+      def validates_each(*args)
+        add_validations(args, ValidatesEach)
+      end
+    
+      # 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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:
+      # 
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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
+    
+      def validates_exclusion_of(*args)
+        add_validations(args, ValidatesExclusionOf)
+      end
+
+      def validates_inclusion_of(*args)
+        add_validations(args, ValidatesInclusionOf)
+      end
+
+      # call-seq: validates_associated(*args)
+      #
+      # Checks the validity of an associated object or objects and adds a single
+      # error if validation fails.
+      #
+      #   class Person
+      #     include Validatable
+      #     attr_accessor :addresses
+      #     validates_associated :addresses
+      #   end
+      #
+      # Configuration options:
+      #
+      #     * after_validate - A block that executes following the run of a validation
+      #     * 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_associated(*args)
+        add_validations(args, ValidatesAssociated)
+      end
+
+      # call-seq: include_validations_from(attribute)
+      # 
+      # Includes all the validations that are defined on the attribute.
+      #   class Person
+      #     include Validatable
+      #     validates_presence_of :name
+      #   end
+      # 
+      #   class PersonPresenter
+      #     include Validatable
+      #     include_validataions_from :person
+      #     attr_accessor :person
+      #     def name
+      #       person.name
+      #     end
+      #
+      #     def initialize(person)
+      #       @person = person
+      #     end
+      #   end
+      #   
+      #   presenter = PersonPresenter.new(Person.new)
+      #   presenter.valid? #=> false
+      #   presenter.errors.on(:name) #=> "can't be blank"
+      #
+      # The name attribute whose validations should be added.
+      def include_validations_from(attribute_to_validate, options = {})
+        validations_to_include << IncludedValidation.new(attribute_to_validate)
+      end
+
+      # call-seq: include_errors_from(attribute_to_validate, options = {})
+      # 
+      # Validates the specified attributes.
+      #   class Person
+      #     include Validatable
+      #     validates_presence_of :name
+      #     attr_accessor :name
+      #   end
+      # 
+      #   class PersonPresenter
+      #     include Validatable
+      #     include_errors_from :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_errors_from(attribute_to_validate, options = {})
+        children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+      end
+    
+      def include_validations_for(attribute_to_validate, options = {}) #:nodoc:
+        puts "include_validations_for is deprecated; use include_errors_from instead"
+        children_to_validate << ChildValidation.new(attribute_to_validate, options[:map] || {}, options[:if] || lambda { true })
+      end
+    
+      # call-seq: before_validation(&block)
+      # 
+      # Is called before valid? or valid_for_*?
+      # 
+      #   class Person
+      #     include Validatable
+      #     before_validation do
+      #       self.name = "default name"
+      #     end
+      # 
+      #     attr_accessor :name
+      #   end
+      # 
+      def before_validation(&block)
+        before_validations << block
+      end
+    end
+  end
+end