mongomatic 0.0.1 → 0.0.2

data/README.rdoc

@@ -26,13 +26,27 @@ Mongomatic allows you to map your Ruby objects to Mongo documents. It is designe
   => 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
+  => 142 
   
-  cursor = User.find({"name" => "Ben"})
-  => #<Mongomatic::Cursor:0x00000100acd3d8 @obj_class=User, @mongo_cursor=DBResponse(flags=, cursor_id=, start=)> 
+  cursor = User.find({"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:0x00000100ccd408 @doc={"_id"=>BSON::ObjectID('4c32c3720218236526000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false>
+  found.remove
+  => 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
-  => #<User:0x00000100a61e08 @doc={"_id"=>BSON::ObjectID('4c32834f0218236321000001'), "name"=>"Ben", "email"=>"me@somewhere.com"}, @removed=false>
+  => nil 
 
 == Note on Patches/Pull Requests
  

data/lib/mongomatic/base.rb

@@ -1,7 +1,7 @@
 module Mongomatic
   class Base
-    include ActiveModel::Validations
     include Mongomatic::Modifiers
+    include Validatable
     
     class << self
       def settings
@@ -108,10 +108,6 @@ module Mongomatic
     
     protected
     
-    def read_attribute_for_validation(key)
-      @doc[key.to_s]
-    end
-    
     def doc
       @doc
     end

data/lib/mongomatic.rb

@@ -1,11 +1,17 @@
 gem "bson", "= 1.0.3"
 gem "bson_ext", "= 1.0.1"
 gem "mongo", "= 1.0.3"
-gem "activemodel", ">= 3.0.0.beta4"
+gem "activesupport", ">= 2.3.5"
 
 require "bson"
 require "mongo"
-require "active_model"
+
+begin
+  require 'active_support/core_ext/object/blank' # newer versions of active_support (>= 3.0)
+  require 'active_support/core_ext/hash' # newer versions of active_support (>= 3.0)
+rescue LoadError => e
+  require 'active_support/all' # support older versions of active_support (<= 2.3.5)
+end
 
 module Mongomatic
   class << self
@@ -21,6 +27,8 @@ module Mongomatic
   end
 end
 
+require "#{File.dirname(__FILE__)}/validatable"
+
 require "#{File.dirname(__FILE__)}/mongomatic/cursor"
 require "#{File.dirname(__FILE__)}/mongomatic/modifiers"
 require "#{File.dirname(__FILE__)}/mongomatic/base"

data/lib/validatable/child_validation.rb

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

data/lib/validatable/errors.rb

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

data/lib/validatable/included_validation.rb

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

data/lib/validatable/macros.rb

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

data/lib/validatable/object_extension.rb

@@ -0,0 +1,21 @@
+class Object #:nodoc:
+  module InstanceExecHelper #:nodoc:
+  end
+  include InstanceExecHelper
+  def instance_eval_with_params(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/validatable/requireable.rb

@@ -0,0 +1,26 @@
+module Validatable
+  module Requireable #:nodoc:
+    module ClassMethods #:nodoc:
+      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/validatable/understandable.rb

@@ -0,0 +1,31 @@
+module Validatable
+  module Understandable #:nodoc:
+    module ClassMethods #:nodoc:
+      def understands(*args)
+        understandings.concat args
+      end
+
+      def understandings
+        @understandings ||= []
+      end
+
+      def all_understandings
+        return understandings + self.superclass.all_understandings if self.superclass.respond_to? :all_understandings
+        understandings
+      end
+    end
+
+    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 self.class.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/validatable_class_methods.rb

@@ -0,0 +1,87 @@
+module Validatable
+  module ClassMethods #:nodoc:
+    
+    def validate_children(instance, group)
+      self.children_to_validate.each do |child_validation|
+        next unless child_validation.should_validate?(instance)
+        child_or_children = instance.send child_validation.attribute
+        [child_or_children].flatten.each do |child|
+          if (child.respond_to?(:valid_for_group?))
+            child.valid_for_group?(group)
+          else
+            child.valid?
+          end
+          child.errors.each do |attribute, messages|
+            if messages.is_a?(String)
+              add_error(instance, child_validation.map[attribute.to_sym] || attribute, messages)
+            else
+              messages.each do |message|
+                add_error(instance, child_validation.map[attribute.to_sym] || attribute, message)
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def all_before_validations
+      if self.superclass.respond_to? :all_before_validations
+        return before_validations + self.superclass.all_before_validations 
+      end
+      before_validations
+    end
+    
+    def before_validations
+      @before_validations ||= []
+    end
+
+    def all_validations
+      if self.respond_to?(:superclass) && self.superclass.respond_to?(:all_validations)
+        return validations + self.superclass.all_validations 
+      end
+      validations
+    end
+
+    def validations
+      @validations ||= []
+    end
+    
+    def add_error(instance, attribute, msg)
+      instance.errors.add(attribute, msg)
+    end
+    
+    def validation_keys_include?(key)
+      validations.map { |validation| validation.key }.include?(key)
+    end
+    
+    def validations_to_include
+      @validations_to_include ||= []
+    end
+    
+    protected
+    
+    def add_validations(args, klass)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each do |attribute|
+        new_validation = klass.new self, attribute, options
+        self.validations << new_validation
+        self.create_valid_method_for_groups new_validation.groups
+      end
+    end
+    
+    def create_valid_method_for_groups(groups)
+      groups.each do |group|
+        self.class_eval do
+          define_method "valid_for_#{group}?".to_sym do
+            valid_for_group?(group)
+          end
+        end
+      end
+    end
+    
+    def children_to_validate
+      @children_to_validate ||= []
+    end
+    
+  end
+end

data/lib/validatable/validatable_instance_methods.rb

@@ -0,0 +1,106 @@
+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. Only executes validations that have no :groups option specified
+  def valid?
+    valid_for_group?(nil)
+  end
+  
+  # call-seq: errors
+  #
+  # Returns the Errors object that holds all information about attribute error messages.
+  def errors
+    @errors ||= Validatable::Errors.new
+  end
+  
+  def valid_for_group?(group) #:nodoc:
+    errors.clear
+    run_before_validations
+    self.class.validate_children(self, group)
+    self.validate_group(group)
+    errors.empty?
+  end
+  
+  def times_validated(key) #:nodoc:
+    times_validated_hash[key] || 0
+  end
+  
+  def increment_times_validated_for(validation) #:nodoc:
+    if validation.key != nil
+      if times_validated_hash[validation.key].nil?
+        times_validated_hash[validation.key] = 1
+      else
+        times_validated_hash[validation.key] += 1
+      end
+    end
+  end
+
+  # call-seq: validate_only(key)
+  #
+  # Only executes a specified validation. The argument should follow a pattern based on the key of the validation.
+  #   Examples:
+  #     * validates_presence_of :name can be run with obj.validate_only("presence_of/name")
+  #     * validates_presence_of :birthday, :key => "a key" can be run with obj.validate_only("presence_of/a key")
+  def validate_only(key)
+    validation_name, attribute_name = key.split("/")
+    validation_name = validation_name.split("_").collect{|word| word.capitalize}.join
+    validation_key = "#{self.class.name}/Validatable::Validates#{validation_name}/#{attribute_name}"
+    validation = self.class.all_validations.find { |validation| validation.key == validation_key }
+    raise ArgumentError.new("validation with key #{validation_key} could not be found") if validation.nil?
+    errors.clear
+    run_validation(validation)
+  end
+
+  protected
+  def times_validated_hash #:nodoc:
+    @times_validated_hash ||= {}
+  end
+
+  def validate_group(group) #:nodoc:
+    validation_levels.each do |level|
+      validations_for_level_and_group(level, group).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)
+    add_error(validation.attribute, validation.message(self)) unless validation_result
+    increment_times_validated_for(validation)
+    validation.run_after_validate(validation_result, self, validation.attribute)
+  end
+  
+  def run_before_validations #:nodoc:
+    self.class.all_before_validations.each do |block|
+      instance_eval &block
+    end
+  end
+  
+  def add_error(attribute, message) #:nodoc:
+    self.class.add_error(self, attribute, message)
+  end
+  
+  def validations_for_level_and_group(level, group) #:nodoc:
+    validations_for_level = self.all_validations.select { |validation| validation.level == level }
+    return validations_for_level.select { |validation| validation.groups.empty? } if group.nil?
+    validations_for_level.select { |validation| validation.groups.include?(group) }
+  end
+  
+  def all_validations #:nodoc:
+    res = self.class.validations_to_include.inject(self.class.all_validations) do |result, included_validation_class|
+      result += self.send(included_validation_class.attribute).all_validations
+      result
+    end
+  end
+  
+  def validation_levels #:nodoc:
+    self.class.all_validations.inject([1]) { |result, validation| result << validation.level }.uniq.sort
+  end
+end

data/lib/validatable/validations/validates_acceptance_of.rb

@@ -0,0 +1,14 @@
+module Validatable
+  class ValidatesAcceptanceOf < ValidationBase #:nodoc:    
+    def valid?(instance)
+      value = instance[self.attribute.to_s]
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      %w(1 true t).include?(value)
+    end
+    
+    def message(instance)
+      super || "must be accepted"
+    end
+  end
+end

data/lib/validatable/validations/validates_associated.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesAssociated < ValidationBase #:nodoc:
+    def valid?(instance)
+      Array(instance.send(attribute)).compact.map do |child|
+        child.valid?
+      end.all?
+    end
+
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/validatable/validations/validates_confirmation_of.rb

@@ -0,0 +1,23 @@
+module Validatable
+  class ValidatesConfirmationOf < ValidationBase #:nodoc:
+    option :case_sensitive
+    default :case_sensitive => true
+    
+    def initialize(klass, attribute, options={})
+      klass.class_eval { attr_accessor "#{attribute}_confirmation" }
+      super
+    end
+    
+    def valid?(instance)
+      confirmation_value = instance.send("#{self.attribute}_confirmation")
+      return true if allow_nil && confirmation_value.nil?
+      return true if allow_blank && confirmation_value.blank?
+      return instance[self.attribute.to_s] == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
+      instance[self.attribute.to_s].to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
+    end
+    
+    def message(instance)
+      super || "doesn't match confirmation"
+    end
+  end
+end

data/lib/validatable/validations/validates_each.rb

@@ -0,0 +1,14 @@
+module Validatable
+  class ValidatesEach < ValidationBase #:nodoc:
+    required_option :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic)
+      true # return true so no error is added. should look in the future at doing this different.
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/validatable/validations/validates_exclusion_of.rb

@@ -0,0 +1,17 @@
+module Validatable
+  class ValidatesExclusionOf < ValidationBase #:nodoc:
+    required_option :within
+
+    def valid?(instance)
+      value = instance.send(attribute)
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+
+      !within.include?(value)
+    end
+
+    def message(instance)
+      super || "is reserved"
+    end
+  end
+end

data/lib/validatable/validations/validates_format_of.rb

@@ -0,0 +1,16 @@
+module Validatable
+  class ValidatesFormatOf < ValidationBase #:nodoc:
+    required_option :with
+  
+    def valid?(instance)
+      value = instance[self.attribute.to_s]
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      not (value.to_s =~ self.with).nil?
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/validatable/validations/validates_inclusion_of.rb

@@ -0,0 +1,17 @@
+module Validatable
+  class ValidatesInclusionOf < ValidationBase
+    required_option :within
+    
+    def valid?(instance)
+      value = instance.send(attribute)
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      
+      within.include?(value)
+    end
+    
+    def message(instance)
+      super || "is not in the list"
+    end
+  end
+end

data/lib/validatable/validations/validates_length_of.rb

@@ -0,0 +1,30 @@
+module Validatable
+  class ValidatesLengthOf < ValidationBase #:nodoc:
+    option :minimum, :maximum, :is, :within
+    
+    def message(instance)
+      super || "is invalid"
+    end
+    
+    def valid?(instance)
+      valid = true
+      value = instance[self.attribute.to_s]
+      
+      if value.nil?
+        return true if allow_nil
+        value = ''
+      end
+
+      if value.blank?
+        return true if allow_blank
+        value = ''
+      end
+      
+      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
+end

data/lib/validatable/validations/validates_numericality_of.rb

@@ -0,0 +1,27 @@
+module Validatable 
+  class ValidatesNumericalityOf < ValidationBase #:nodoc:
+    option :only_integer
+    
+    def valid?(instance)
+      value = value_for(instance)
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      
+      value = value.to_s
+      regex = self.only_integer ? /\A[+-]?\d+\Z/ : /^\d*\.{0,1}\d+$/
+      not (value =~ regex).nil?
+    end
+    
+    def message(instance)
+      super || "must be a number"
+    end
+    
+    private
+      def value_for(instance)
+        before_typecast_method = "#{self.attribute}_before_typecast"
+        value_method = instance.respond_to?(before_typecast_method.intern) ? before_typecast_method : self.attribute
+        instance.send(value_method)
+      end
+  end
+end
+

data/lib/validatable/validations/validates_presence_of.rb

@@ -0,0 +1,17 @@
+module Validatable 
+  class ValidatesPresenceOf < ValidationBase #:nodoc:
+    def valid?(instance)
+      value = instance[self.attribute.to_s]
+      return true if allow_nil && value.nil?
+      return true if allow_blank && value.blank?
+      
+      return false if instance[self.attribute.to_s].nil?
+      value.respond_to?(:strip) ? instance[self.attribute.to_s].strip.length != 0 : true
+    end
+    
+    def message(instance)
+      super || "can't be empty"
+    end
+  end
+end
+

data/lib/validatable/validations/validates_true_for.rb

@@ -0,0 +1,13 @@
+module Validatable
+  class ValidatesTrueFor < ValidationBase #:nodoc:
+    required_option :logic
+  
+    def valid?(instance)
+      instance.instance_eval(&logic) == true
+    end
+    
+    def message(instance)
+      super || "is invalid"
+    end
+  end
+end

data/lib/validatable/validations/validation_base.rb

@@ -0,0 +1,91 @@
+module Validatable
+  class ValidationBase #:nodoc:
+    def self.required_option(*args)
+      option(*args)
+      requires(*args)
+    end
+    
+    def self.option(*args)
+      attr_accessor(*args)
+      understands(*args)
+    end
+    
+    def self.default(hash)
+      defaults.merge! hash
+    end
+    
+    def self.defaults
+      @defaults ||= {}
+    end
+    
+    def self.all_defaults
+      return defaults.merge(self.superclass.all_defaults) if self.superclass.respond_to? :all_defaults
+      defaults
+    end
+    
+    def self.after_validate(&block)
+      after_validations << block
+    end
+    
+    def self.after_validations
+      @after_validations ||= []
+    end
+    
+    def self.all_after_validations
+      return after_validations + self.superclass.all_after_validations if self.superclass.respond_to? :all_after_validations
+      after_validations
+    end
+
+    include Understandable
+    include Requireable
+    
+    option :message, :if, :times, :level, :groups, :key, :after_validate, :allow_nil, :allow_blank
+    default :level => 1, :groups => []
+    attr_accessor :attribute
+    
+    def initialize(klass, attribute, options={})
+      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)
+      self.key = "#{klass.name}/#{self.class.name}/#{self.key || self.attribute}"
+      raise_error_if_key_is_dup(klass)
+    end
+    
+    def raise_error_if_key_is_dup(klass)
+      message = "key #{self.key} must be unique, provide the :key option to specify a unique key"
+      raise ArgumentError.new(message) if klass.validation_keys_include? self.key
+    end
+    
+    def should_validate?(instance)
+      result = validate_this_time?(instance)
+      case self.if
+        when Proc
+          result &&= instance.instance_eval(&self.if)
+        when Symbol, String
+          result &&= instance.instance_eval(self.if.to_s)
+      end
+      result
+    end
+    
+    def message(instance)
+      @message.respond_to?(:call) ? instance.instance_eval(&@message) : @message
+    end
+    
+    def validate_this_time?(instance)
+      return true if @times.nil?
+      self.times > instance.times_validated(self.key)
+    end
+    
+    def run_after_validate(result, instance, attribute)
+      self.class.all_after_validations.each do |block|
+        block.call result, instance, attribute
+      end
+      instance.instance_eval_with_params result, attribute, &self.after_validate unless self.after_validate.nil?
+    end
+  end
+end

data/lib/validatable.rb

@@ -0,0 +1,29 @@
+# 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 Validatable
+  Version = "1.8.4"
+end

data/test/test_meta_mongo.rb

@@ -7,7 +7,7 @@ class TestMongomatic < Test::Unit::TestCase
     p = Person.new
     
     assert !p.valid?
-    assert_equal({:name=>["can't be blank"]}, p.errors)
+    assert_equal(["Name can't be empty"], p.errors.full_messages)
     
     p["name"] = "Ben Myles"
     p["birth_year"] = 1984

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ben Myles
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-05 00:00:00 -07:00
+date: 2010-07-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,7 +78,7 @@ dependencies:
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: activemodel
+  name: activesupport
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -86,11 +86,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
+        - 2
         - 3
-        - 0
-        - 0
-        - beta4
-        version: 3.0.0.beta4
+        - 5
+        version: 2.3.5
   type: :runtime
   version_requirements: *id005
 description: Mongomatic is a simple Ruby object mapper for Mongo
@@ -107,6 +106,28 @@ files:
 - lib/mongomatic/base.rb
 - lib/mongomatic/cursor.rb
 - lib/mongomatic/modifiers.rb
+- lib/validatable.rb
+- lib/validatable/child_validation.rb
+- lib/validatable/errors.rb
+- lib/validatable/included_validation.rb
+- lib/validatable/macros.rb
+- lib/validatable/object_extension.rb
+- lib/validatable/requireable.rb
+- lib/validatable/understandable.rb
+- lib/validatable/validatable_class_methods.rb
+- lib/validatable/validatable_instance_methods.rb
+- lib/validatable/validations/validates_acceptance_of.rb
+- lib/validatable/validations/validates_associated.rb
+- lib/validatable/validations/validates_confirmation_of.rb
+- lib/validatable/validations/validates_each.rb
+- lib/validatable/validations/validates_exclusion_of.rb
+- lib/validatable/validations/validates_format_of.rb
+- lib/validatable/validations/validates_inclusion_of.rb
+- lib/validatable/validations/validates_length_of.rb
+- lib/validatable/validations/validates_numericality_of.rb
+- lib/validatable/validations/validates_presence_of.rb
+- lib/validatable/validations/validates_true_for.rb
+- lib/validatable/validations/validation_base.rb
 - LICENSE
 - README.rdoc
 - test/helper.rb