sequel 2.1.0 → 2.2.0

data/lib/sequel_model/base.rb

@@ -8,6 +8,7 @@ module Sequel
     @allowed_columns = nil
     @dataset_methods = {}
     @primary_key = :id
+    @raise_on_save_failure = true
     @restrict_primary_key = true
     @restricted_columns = nil
     @sti_dataset = nil
@@ -26,6 +27,10 @@ module Sequel
     # The default primary key for classes (default: :id)
     metaattr_reader :primary_key
 
+    # Whether to raise an error instead of returning nil on a failure
+    # to save/create/save_changes/etc.
+    metaattr_accessor :raise_on_save_failure
+
     # Which columns should not be update in a call to set
     # (default: no columns).
     metaattr_reader :restricted_columns
@@ -52,12 +57,13 @@ module Sequel
        insert_multiple intersect interval invert_order join join_table last 
        left_outer_join limit map multi_insert naked order order_by order_more 
        paginate print query range reverse_order right_outer_join select 
-       select_all select_more set set_graph_aliases single_value size to_csv 
-       transform union uniq unordered update where'.map{|x| x.to_sym}
+       select_all select_more set set_graph_aliases single_value size to_csv to_hash
+       transform union uniq unfiltered unordered update where'.map{|x| x.to_sym}
 
     # Instance variables that are inherited in subclasses
-    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup,
-      :@primary_key=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@cache_store=>nil,
+      :@cache_ttl=>nil, :@dataset_methods=>:dup, :@primary_key=>nil, 
+      :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
       :@typecast_on_assignment=>nil}
 
@@ -83,7 +89,7 @@ module Sequel
     # dataset) it will use Dataset#columns to find the columns, which
     # may be empty if the Dataset has no records.
     def self.columns
-      @columns || set_columns(dataset.naked.columns || raise(Error, "Could not fetch columns for #{self}"))
+      @columns || set_columns(dataset.naked.columns)
     end
   
     # Creates new instance with values set to passed-in Hash, saves it
@@ -92,7 +98,7 @@ module Sequel
     # returns false.
     def self.create(values = {}, &block)
       obj = new(values, &block)
-      return false if obj.save == false
+      return unless obj.save
       obj
     end
 
@@ -155,6 +161,17 @@ module Sequel
       db.fetch(*args).set_model(self)
     end
   
+    # Modify and return eager loading dataset based on association options
+    def self.eager_loading_dataset(opts, ds, select, associations)
+      ds = ds.select(*select) if select
+      ds = ds.order(*opts[:order]) if opts[:order]
+      ds = ds.eager(opts[:eager]) if opts[:eager]
+      ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph]
+      ds = ds.eager(associations) unless associations.blank?
+      ds = opts[:eager_block].call(ds) if opts[:eager_block]
+      ds
+    end
+
     # Finds a single record according to the supplied filter, e.g.:
     #
     #   Ticket.find :author => 'Sharon' # => record
@@ -441,7 +458,11 @@ module Sequel
           # Dataset is for a single table with all columns,
           # so set the columns based on the order they were
           # returned by the schema.
-          set_columns(schema_array.collect{|k,v| k})
+          cols = schema_array.collect{|k,v| k}
+          set_columns(cols)
+          # Also set the columns for the dataset, so the dataset
+          # doesn't have to do a query to get them.
+          dataset.instance_variable_set(:@columns, cols)
         end
       else
         # If the dataset uses multiple tables or custom sql or getting

data/lib/sequel_model/eager_loading.rb

@@ -56,8 +56,8 @@ module Sequel::Model::Associations::EagerLoading
   # or join the tables you need to filter on manually. 
   #
   # Each association's order, if definied, is respected. Eager also works
-  # on a limited dataset.  If the association uses a block or has an :eager_block
-  # argument, it is used.
+  # on a limited dataset, but does not use any :limit options for associations.
+  # If the association uses a block or has an :eager_block argument, it is used.
   def eager(*associations)
     model = check_model
     opt = @opts[:eager]
@@ -90,7 +90,7 @@ module Sequel::Model::Associations::EagerLoading
   # This does not respect each association's order, as all associations are loaded in
   # a single query.  If you want to order the results, you must manually call .order.
   #
-  # #eager_graph probably won't work the way you suspect with limit, unless you are
+  # #eager_graph probably won't work correctly on a limited dataset, unless you are
   # only graphing many_to_one associations.
   # 
   # Does not use the block defined for the association, since it does a single query for
@@ -132,18 +132,22 @@ module Sequel::Model::Associations::EagerLoading
     assoc_table_alias = ds.eager_unique_table_alias(ds, assoc_name)
     join_type = r[:graph_join_type]
     conditions = r[:graph_conditions]
+    use_only_conditions = r.include?(:graph_only_conditions)
+    only_conditions = r[:graph_only_conditions]
     select = r[:graph_select]
+    graph_block = r[:graph_block]
     ds = case assoc_type = r[:type]
     when :many_to_one
-      ds.graph(klass, [[klass.primary_key, :"#{ta}__#{r[:key]}"]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      ds.graph(klass, use_only_conditions ? only_conditions : [[klass.primary_key, r[:key].qualify(ta)]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
     when :one_to_many
-      ds = ds.graph(klass, [[r[:key], :"#{ta}__#{model.primary_key}"]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      ds = ds.graph(klass, use_only_conditions ? only_conditions : [[r[:key], model.primary_key.qualify(ta)]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
       # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
       ds.opts[:eager_graph][:reciprocals][assoc_table_alias] = r.reciprocal
       ds
     when :many_to_many
-      ds = ds.graph(r[:join_table], [[r[:left_key], :"#{ta}__#{model.primary_key}"]] + r[:graph_join_table_conditions], :select=>false, :table_alias=>ds.eager_unique_table_alias(ds, r[:join_table]), :join_type=>join_type)
-      ds.graph(klass, [[klass.primary_key, r[:right_key]]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type)
+      use_jt_only_conditions = r.include?(:graph_join_table_only_conditions)
+      ds = ds.graph(r[:join_table], use_jt_only_conditions ? r[:graph_join_table_only_conditions] : [[r[:left_key], model.primary_key.qualify(ta)]] + r[:graph_join_table_conditions], :select=>false, :table_alias=>ds.eager_unique_table_alias(ds, r[:join_table]), :join_type=>r[:graph_join_table_join_type], &r[:graph_join_table_block])
+      ds.graph(klass, use_only_conditions ? only_conditions : [[klass.primary_key, r[:right_key]]] + conditions, :select=>select, :table_alias=>assoc_table_alias, :join_type=>join_type, &graph_block)
     end
     eager_graph = ds.opts[:eager_graph]
     eager_graph[:requirements][assoc_table_alias] = requirements.dup
@@ -358,70 +362,7 @@ module Sequel::Model::Associations::EagerLoading
       end
     end
     
-    # Iterate through eager associations and assign instance variables
-    # for the association for all model objects
-    reflections.each do |reflection|
-      assoc_class = reflection.associated_class
-      assoc_name = reflection[:name]
-      # Proc for setting cascaded eager loading
-      assoc_block = Proc.new do |d|
-        if order = reflection[:order]
-          d = d.order(*order)
-        end
-        if c = eager_assoc[assoc_name]
-          d = d.eager(c)
-        end
-        if c = reflection[:eager]
-          d = d.eager(c)
-        end
-        if b = reflection[:eager_block]
-          d = b.call(d)
-        end
-        d
-      end
-      case rtype = reflection[:type]
-        when :many_to_one
-          key = reflection[:key]
-          h = key_hash[key]
-          keys = h.keys
-          # No records have the foreign key set for this association, so skip it
-          next unless keys.length > 0
-          # Set the instance variable to null by default, so records that
-          # don't have a associated records will cache the negative lookup.
-          a.each do |object|
-            object.associations[assoc_name] = nil
-          end
-          assoc_block.call(assoc_class.select(*reflection.select).filter(assoc_class.primary_key=>keys)).all do |assoc_object|
-            next unless objects = h[assoc_object.pk]
-            objects.each{|object| object.associations[assoc_name] = assoc_object}
-          end
-        when :one_to_many, :many_to_many
-          h = key_hash[model.primary_key]
-          ds = if rtype == :one_to_many
-            fkey = reflection[:key]
-            reciprocal = reflection.reciprocal
-            assoc_class.select(*reflection.select).filter(fkey=>h.keys)
-          else
-            fkey = reflection[:left_key_alias]
-            assoc_class.select(*(Array(reflection.select)+Array(reflection[:left_key_select]))).inner_join(reflection[:join_table], [[reflection[:right_key], reflection.associated_primary_key], [reflection[:left_key], h.keys]])
-          end
-          h.values.each do |object_array|
-            object_array.each{|object| object.associations[assoc_name] = []}
-          end
-          assoc_block.call(ds).all do |assoc_object|
-            fk = if rtype == :many_to_many
-              assoc_object.values.delete(fkey)
-            else
-              assoc_object[fkey]
-            end
-            next unless objects = h[fk]
-            objects.each do |object|
-              object.associations[assoc_name].push(assoc_object)
-              assoc_object.associations[reciprocal] = object if reciprocal
-            end
-          end
-      end
-    end
+    reflections.each{|r| r[:eager_loader].call(key_hash, a, eager_assoc[r[:name]])}
   end
 
   # Build associations from the graph if #eager_graph was used, 

data/lib/sequel_model/record.rb

@@ -2,7 +2,7 @@ module Sequel
   class Model
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via set.
-    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_on_assignment="
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_on_assignment= strict_param_setting= raise_on_save_failure="
 
     # The current cached associations.  A hash with the keys being the
     # association name symbols and the values being the associated object
@@ -13,6 +13,10 @@ module Sequel
     # see Model#[]=.
     attr_reader :changed_columns
     
+    # Whether this model instance should raise an exception instead of
+    # returning nil on a failure to save/save_changes/etc.
+    attr_writer :raise_on_save_failure
+
     # Whether this model instance should raise an error if attempting
     # to call a method through set/update and their variants that either
     # doesn't exist or access to it is denied.
@@ -42,6 +46,7 @@ module Sequel
       @associations = {}
       @db_schema = model.db_schema
       @changed_columns = []
+      @raise_on_save_failure = model.raise_on_save_failure
       @strict_param_setting = model.strict_param_setting
       @typecast_on_assignment = model.typecast_on_assignment
       if from_db
@@ -108,7 +113,7 @@ module Sequel
     # the item from the database and returns self.
     def destroy
       db.transaction do
-        return false if before_destroy == false
+        return save_failure(:destroy) if before_destroy == false
         delete
         after_destroy
       end
@@ -187,12 +192,13 @@ module Sequel
     alias_method :reload, :refresh
 
     # Creates or updates the record, after making sure the record
-    # is valid.  If the record is not valid, returns false.
-    # If before_save, before_create (if new?), or before_update
-    # (if !new?) return false, returns false.  Otherwise,
-    # returns self.
+    # is valid.  If the record is not valid, or before_save,
+    # before_create (if new?), or before_update (if !new?) return
+    # false, returns nil unless raise_on_save_failure is true.
+    # Otherwise, returns self. You can provide an optional list of
+    # columns to update, in which case it only updates those columns.
     def save(*columns)
-      return false unless valid?
+      return save_failure(:save) unless valid?
       save!(*columns)
     end
 
@@ -200,12 +206,12 @@ module Sequel
     # it first. You can provide an optional list of columns to update,
     # in which case it only updates those columns.
     # If before_save, before_create (if new?), or before_update
-    # (if !new?) return false, returns false.  Otherwise,
-    # returns self.
+    # (if !new?) return false, returns nil unless raise_on_save_failure
+    # is true.  Otherwise, returns self.
     def save!(*columns)
-      return false if before_save == false
+      return save_failure(:save) if before_save == false
       if @new
-        return false if before_create == false
+        return save_failure(:create) if before_create == false
         iid = model.dataset.insert(@values)
         # if we have a regular primary key and it's not set in @values,
         # we assume it's the last inserted id
@@ -219,7 +225,7 @@ module Sequel
         @new = false
         after_create
       else
-        return false if before_update == false
+        return save_failure(:update) if before_update == false
         if columns.empty?
           this.update(@values)
           @changed_columns = []
@@ -234,9 +240,10 @@ module Sequel
     end
     
     # Saves only changed columns or does nothing if no columns are marked as 
-    # chanaged.
+    # chanaged.  If no columns have been changed, returns nil.  If unable to
+    # save, returns false unless raise_on_save_failure is true.
     def save_changes
-      save(*@changed_columns) unless @changed_columns.empty?
+      save(*@changed_columns) || false unless @changed_columns.empty?
     end
 
     # Updates the instance with the supplied values with support for virtual
@@ -335,6 +342,128 @@ module Sequel
     
     private
 
+    # Backbone behind association_dataset
+    def _dataset(opts)
+      raise(Sequel::Error, 'model object does not have a primary key') if opts.dataset_need_primary_key? && !pk
+      ds = send(opts._dataset_method)
+      opts[:extend].each{|m| ds.extend(m)}
+      ds = ds.select(*opts.select) if opts.select
+      ds = ds.order(*opts[:order]) if opts[:order]
+      ds = ds.limit(*opts[:limit]) if opts[:limit]
+      ds = ds.eager(*opts[:eager]) if opts[:eager]
+      ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
+      ds = send(opts.dataset_helper_method, ds) if opts[:block]
+      ds
+    end
+
+    # Add the given associated object to the given association
+    def add_associated_object(opts, o)
+      raise(Sequel::Error, 'model object does not have a primary key') unless pk
+      raise(Sequel::Error, 'associated object does not have a primary key') if opts.need_associated_primary_key? && !o.pk
+      return if run_association_callbacks(opts, :before_add, o) == false
+      send(opts._add_method, o)
+      @associations[opts[:name]].push(o) if @associations.include?(opts[:name])
+      add_reciprocal_object(opts, o)
+      run_association_callbacks(opts, :after_add, o)
+      o
+    end
+
+    # Add/Set the current object to/as the given object's reciprocal association.
+    def add_reciprocal_object(opts, o)
+      return unless reciprocal = opts.reciprocal
+      case opts[:type]
+      when :many_to_many, :many_to_one
+        if array = o.associations[reciprocal] and !array.include?(self)
+          array.push(self)
+        end
+      when :one_to_many
+        o.associations[reciprocal] = self
+      end
+    end
+
+    # Load the associated objects using the dataset
+    def load_associated_objects(opts, reload=false)
+      name = opts[:name]
+      if @associations.include?(name) and !reload
+        @associations[name]
+      else
+        objs = if opts.single_associated_object?
+          if !opts[:key]
+            send(opts.dataset_method).all.first
+          elsif send(opts[:key])
+            send(opts.dataset_method).first
+          end
+        else
+          objs = send(opts.dataset_method).all
+        end
+        run_association_callbacks(opts, :after_load, objs)
+        # Only one_to_many associations should set the reciprocal object
+        objs.each{|o| add_reciprocal_object(opts, o)} if opts.set_reciprocal_to_self?
+        @associations[name] = objs
+      end
+    end
+
+    # Remove all associated objects from the given association
+    def remove_all_associated_objects(opts)
+      raise(Sequel::Error, 'model object does not have a primary key') unless pk
+      send(opts._remove_all_method)
+      ret = @associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if @associations.include?(opts[:name])
+      @associations[opts[:name]] = []
+      ret
+    end
+
+    # Remove the given associated object from the given association
+    def remove_associated_object(opts, o)
+      raise(Sequel::Error, 'model object does not have a primary key') unless pk
+      raise(Sequel::Error, 'associated object does not have a primary key') if opts.need_associated_primary_key? && !o.pk
+      return if run_association_callbacks(opts, :before_remove, o) == false
+      send(opts._remove_method, o)
+      @associations[opts[:name]].delete_if{|x| o === x} if @associations.include?(opts[:name])
+      remove_reciprocal_object(opts, o)
+      run_association_callbacks(opts, :after_remove, o)
+      o
+    end
+
+    # Remove/unset the current object from/as the given object's reciprocal association.
+    def remove_reciprocal_object(opts, o)
+      return unless reciprocal = opts.reciprocal
+      case opts[:type]
+      when :many_to_many, :many_to_one
+        if array = o.associations[reciprocal]
+          array.delete_if{|x| self === x}
+        end
+      when :one_to_many
+        o.associations[reciprocal] = nil
+      end
+    end
+
+    # Run the callback for the association with the object.
+    def run_association_callbacks(reflection, callback_type, object)
+      raise_error = @raise_on_save_failure
+      raise_error = true if reflection[:type] == :many_to_one
+      stop_on_false = true if [:before_add, :before_remove].include?(callback_type)
+      reflection[callback_type].each do |cb|
+        res = case cb
+        when Symbol
+          send(cb, object)
+        when Proc
+          cb.call(self, object)
+        else
+          raise Error, "callbacks should either be Procs or Symbols"
+        end
+        if res == false and stop_on_false
+          save_failure("modify association for", raise_error)
+          return false
+        end
+      end
+    end
+
+    # Raise an error if raise_on_save_failure is true
+    def save_failure(action, raise_error = nil)
+      raise_error = @raise_on_save_failure if raise_error.nil?
+      raise(Error, "unable to #{action} record") if raise_error
+    end
+
     # Set the columns, filtered by the only and except arrays.
     def set_restricted(hash, only, except)
       columns_not_set = model.instance_variable_get(:@columns).blank?

data/lib/sequel_model/validations.rb

@@ -1,6 +1,6 @@
 module Sequel
   class Model
-    # The Validation module houses a couple of subclasses used by Sequel's
+    # The Validation module houses a couple of classes used by Sequel's
     # validation code.
     module Validation
       # Validation::Errors represents validation errors, a simple hash subclass
@@ -85,11 +85,21 @@ module Sequel
       end
       validations.each do |att, procs|
         v = o.send(att)
-        procs.each {|p| p[o, att, v]}
+        procs.each {|tag, p| p.call(o, att, v)}
       end
     end
     
-    # Validates acceptance of an attribute.
+    # Validates acceptance of an attribute.  Just checks that the value
+    # is equal to the :accept option.
+    #
+    # Possible Options:
+    # * :accept - The value required for the object to be valid (default: '1')
+    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
+    # * :allow_nil - Whether to skip the validation if the value is nil (default: true)
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is not accepted')
+    # * :tag - The tag to use for this validation (default: :acceptance)
     def self.validates_acceptance_of(*atts)
       opts = {
         :message => 'is not accepted',
@@ -97,21 +107,35 @@ module Sequel
         :accept => '1'
       }.merge!(atts.extract_options!)
       
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:acceptance}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         o.errors[a] << opts[:message] unless v == opts[:accept]
       end
     end
 
-    # Validates confirmation of an attribute.
+    # Validates confirmation of an attribute. Checks that the object has
+    # a _confirmation value matching the current value.  For example:
+    #
+    #   validates_confirmation_of :blah
+    #
+    # Just makes sure that object.blah = object.blah_confirmation.  Often used for passwords
+    # or email addresses on web forms.
+    #
+    # Possible Options:
+    # * :allow_false - Whether to skip the validation if the value is blank (default: false)
+    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is not confirmed')
+    # * :tag - The tag to use for this validation (default: :confirmation)
     def self.validates_confirmation_of(*atts)
       opts = {
         :message => 'is not confirmed',
       }.merge!(atts.extract_options!)
-      
+     
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:confirmation}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         c = o.send(:"#{a}_confirmation")
         o.errors[a] << opts[:message] unless v == c
@@ -125,11 +149,40 @@ module Sequel
     #   validates_each :name, :password do |object, attribute, value|
     #     object.errors[attribute] << 'is not nice' unless value.nice?
     #   end
+    #
+    # Possible Options:
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :tag - The tag to use for this validation (default: nil)
     def self.validates_each(*atts, &block)
-      atts.each{|a| validations[a] << block}
+      opts = atts.extract_options!
+      blk = if opts[:if]
+        proc{|o,a,v| block.call(o,a,v) if o.instance_eval(&if_proc(opts))}
+      else
+        block
+      end
+      tag = opts[:tag]
+      atts.each do |a| 
+        a_vals = validations[a]
+        if tag && (old = a_vals.find{|x| x[0] == tag})
+          old[1] = blk
+        else
+          a_vals << [tag, blk]
+        end
+      end
     end
 
-    # Validates the format of an attribute.
+    # Validates the format of an attribute, checking the string representation of the
+    # value against the regular expression provided by the :with option.
+    #
+    # Possible Options:
+    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
+    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is invalid')
+    # * :tag - The tag to use for this validation (default: :format)
+    # * :with - The regular expression to validate the value with (required).
     def self.validates_format_of(*atts)
       opts = {
         :message => 'is invalid',
@@ -139,14 +192,30 @@ module Sequel
         raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
       end
       
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:format}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
       end
     end
 
     # Validates the length of an attribute.
+    #
+    # Possible Options:
+    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
+    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :is - The exact size required for the value to be valid (no default)
+    # * :maximum - The maximum size allowed for the value (no default)
+    # * :message - The message to use (no default, overrides :too_long, :too_short, and :wrong_length
+    #   options if present)
+    # * :minimum - The minimum size allowed for the value (no default)
+    # * :tag - The tag to use for this validation (default: :length)
+    # * :too_long - The message to use use if it the value is too long (default: 'is too long')
+    # * :too_short - The message to use use if it the value is too short (default: 'is too short')
+    # * :with - The array/range that must include the size of the value for it to be valid (no default)
+    # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
     def self.validates_length_of(*atts)
       opts = {
         :too_long     => 'is too long',
@@ -154,8 +223,8 @@ module Sequel
         :wrong_length => 'is the wrong length'
       }.merge!(atts.extract_options!)
       
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:length}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         if m = opts[:maximum]
           o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
@@ -173,13 +242,22 @@ module Sequel
     end
 
     # Validates whether an attribute is a number.
+    #
+    # Possible Options:
+    # * :allow_blank - Whether to skip the validation if the value is blank (default: false)
+    # * :allow_nil - Whether to skip the validation if the value is nil (default: false)
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is not a number')
+    # * :tag - The tag to use for this validation (default: :numericality)
+    # * :only_integer - Whether only integers are valid values (default: false)
     def self.validates_numericality_of(*atts)
       opts = {
         :message => 'is not a number',
       }.merge!(atts.extract_options!)
       
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:numericality}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         begin
           if opts[:only_integer]
@@ -193,28 +271,41 @@ module Sequel
       end
     end
 
-    # Validates the presence of an attribute.
+    # Validates the presence of an attribute.  Requires the value not be blank,
+    # with false considered present instead of absent.
+    #
+    # Possible Options:
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is not present')
+    # * :tag - The tag to use for this validation (default: :presence)
     def self.validates_presence_of(*atts)
       opts = {
         :message => 'is not present',
       }.merge!(atts.extract_options!)
       
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:presence}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
-        o.errors[a] << opts[:message] unless v && !v.blank?
+        o.errors[a] << opts[:message] if v.blank? && v != false
       end
     end
 
     # Validates only if the fields in the model (specified by atts) are
     # unique in the database.  You should also add a unique index in the
     # database, as this suffers from a fairly obvious race condition.
+    #
+    # Possible Options:
+    # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
+    #   skipping this validation if it returns nil or false.
+    # * :message - The message to use (default: 'is already taken')
+    # * :tag - The tag to use for this validation (default: :uniqueness)
     def self.validates_uniqueness_of(*atts)
       opts = {
         :message => 'is already taken',
       }.merge!(atts.extract_options!)
 
+      atts << {:if=>opts[:if], :tag=>opts[:tag]||:uniqueness}
       validates_each(*atts) do |o, a, v|
-        next unless o.instance_eval(&if_proc(opts))
         next if v.blank? 
         num_dups = o.class.filter(a => v).count
         allow = if num_dups == 0
@@ -244,7 +335,7 @@ module Sequel
     
     ### Private Class Methods ###
 
-    def self.if_proc(opts)
+    def self.if_proc(opts) # :nodoc:
       case opts[:if]
       when Symbol then proc{send opts[:if]}
       when Proc then opts[:if]