activerecord 1.10.1 → 1.11.0

data/lib/active_record/fixtures.rb

@@ -101,8 +101,8 @@ require 'csv'
 #   ...
 #
 # By adding a "fixtures" method to the test case and passing it a list of symbols (only one is shown here tho), we trigger
-# the testing environment to automatically load the appropriate fixtures into the database before each test, and
-# automatically delete them after each test.
+# the testing environment to automatically load the appropriate fixtures into the database before each test.  
+# To ensure consistent data, the environment deletes the fixtures before running the load.
 #
 # In addition to being available in the database, the fixtures are also loaded into a hash stored in an instance variable
 # of the test case.  It is named after the symbol... so, in our example, there would be a hash available called
@@ -129,6 +129,16 @@ require 'csv'
 #   - to keep the fixture instance (@web_sites) available, but do not automatically 'find' each instance:
 #       self.use_instantiated_fixtures = :no_instances 
 #
+# Even if auto-instantiated fixtures are disabled, you can still access them
+# by name via special dynamic methods. Each method has the same name as the
+# model, and accepts the name of the fixture to instantiate:
+#
+#   fixtures :web_sites
+#
+#   def test_find
+#     assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+#   end
+#
 # = Dynamic fixtures with ERb
 #
 # Some times you don't care about the content of the fixtures as much as you care about the volume. In these cases, you can
@@ -159,13 +169,13 @@ require 'csv'
 #     fixtures :foos
 #   
 #     def test_godzilla
-#       assert !Foo.find_all.emtpy?
+#       assert !Foo.find(:all).empty?
 #       Foo.destroy_all
-#       assert Foo.find_all.emtpy?
+#       assert Foo.find(:all).empty?
 #     end
 #   
 #     def test_godzilla_aftermath
-#       assert !Foo.find_all.emtpy?
+#       assert !Foo.find(:all).empty?
 #     end
 #   end
 #   
@@ -278,7 +288,7 @@ class Fixtures < Hash
           yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
           yaml.each { |name, data| self[name] = Fixture.new(data, @class_name) } if yaml
         rescue Exception=>boom
-          raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html"
+          raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{boom.class}: #{boom}"
         end
       elsif File.file?(csv_file_path)
         # CSV fixtures
@@ -400,9 +410,13 @@ module Test #:nodoc:
       self.use_instantiated_fixtures = true
       self.pre_loaded_fixtures = false
 
+      @@already_loaded_fixtures = {}
+
       def self.fixtures(*table_names)
-        self.fixture_table_names |= table_names.flatten
-        require_fixture_classes
+        table_names = table_names.flatten
+        self.fixture_table_names |= table_names
+        require_fixture_classes(table_names)
+        setup_fixture_accessors(table_names)
       end
 
       def self.require_fixture_classes(table_names=nil)
@@ -415,20 +429,53 @@ module Test #:nodoc:
         end
       end
 
+      def self.setup_fixture_accessors(table_names=nil)
+        (table_names || fixture_table_names).each do |table_name|
+          table_name = table_name.to_s.tr('.','_')
+          define_method(table_name) do |fixture, *optionals|
+            force_reload = optionals.shift
+            @fixture_cache[table_name] ||= Hash.new
+            @fixture_cache[table_name][fixture] = nil if force_reload
+            @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
+          end
+        end
+      end
+
+      def self.uses_transaction(*methods)
+        @uses_transaction ||= []
+        @uses_transaction.concat methods.map { |m| m.to_s }
+      end
+
+      def self.uses_transaction?(method)
+        @uses_transaction && @uses_transaction.include?(method.to_s)
+      end
+
+      def use_transactional_fixtures?
+        use_transactional_fixtures &&
+          !self.class.uses_transaction?(method_name)
+      end
+
       def setup_with_fixtures
         if pre_loaded_fixtures && !use_transactional_fixtures
           raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures' 
         end
 
+        @fixture_cache = Hash.new
+
         # Load fixtures once and begin transaction.
-        if use_transactional_fixtures
-          load_fixtures unless @already_loaded_fixtures
-          @already_loaded_fixtures = true
+        if use_transactional_fixtures?
+          if @@already_loaded_fixtures[self.class]
+            @loaded_fixtures = @@already_loaded_fixtures[self.class]
+          else
+            load_fixtures
+            @@already_loaded_fixtures[self.class] = @loaded_fixtures
+          end
           ActiveRecord::Base.lock_mutex
           ActiveRecord::Base.connection.begin_db_transaction
 
         # Load fixtures for every test.
         else
+          @@already_loaded_fixtures[self.class] = nil
           load_fixtures
         end
 
@@ -440,7 +487,7 @@ module Test #:nodoc:
 
       def teardown_with_fixtures
         # Rollback changes.
-        if use_transactional_fixtures
+        if use_transactional_fixtures?
           ActiveRecord::Base.connection.rollback_db_transaction
           ActiveRecord::Base.unlock_mutex
         end

data/lib/active_record/locking.rb

@@ -32,14 +32,15 @@ module ActiveRecord
         previous_value    = self.lock_version
         self.lock_version = previous_value + 1
         
-        affected_rows = connection.update(
-          "UPDATE #{self.class.table_name} "+
-          "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
-          "WHERE #{self.class.primary_key} = #{quote(id)} AND lock_version = #{quote(previous_value)}",
-          "#{self.class.name} Update with optimistic locking"
-        )
-        
-        raise(ActiveRecord::StaleObjectError, "Attempted to update a stale object") unless affected_rows == 1
+        affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
+          UPDATE #{self.class.table_name}
+          SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))}
+          WHERE #{self.class.primary_key} = #{quote(id)} AND lock_version = #{quote(previous_value)}
+        end_sql
+
+        unless affected_rows == 1
+          raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+        end
       else
         update_without_lock
       end
@@ -54,4 +55,4 @@ module ActiveRecord
       lock_optimistically && respond_to?(:lock_version)
     end
   end
-end
+end

data/lib/active_record/migration.rb

@@ -2,7 +2,113 @@ module ActiveRecord
   class IrreversibleMigration < ActiveRecordError#:nodoc:
   end
   
-  class Migration #:nodoc:
+  # Migrations can manage the evolution of a schema used by several physical databases. It's a solution
+  # to the common problem of adding a field to make a new feature work in your local database, but being unsure of how to
+  # push that change to other developers and to the production server. With migrations, you can describe the transformations
+  # in self-contained classes that can be checked into version control systems and executed against another database that
+  # might be one, two, or five versions behind.
+  #
+  # Example of a simple migration:
+  #
+  #   class AddSsl < ActiveRecord::Migration
+  #     def self.up
+  #       add_column :accounts, :ssl_enabled, :boolean, :default => 1
+  #     end
+  #   
+  #     def self.down
+  #       remove_column :accounts, :ssl_enabled
+  #     end
+  #   end
+  #
+  # This migration will add a boolean flag to the accounts table and remove it again, if you're backing out of the migration.
+  # It shows how all migrations have two class methods +up+ and +down+ that describes the transformations required to implement
+  # or remove the migration. These methods can consist of both the migration specific methods, like add_column and remove_column, 
+  # but may also contain regular Ruby code for generating data needed for the transformations.
+  #
+  # Example of a more complex migration that also needs to initialize data:
+  #
+  #   class AddSystemSettings < ActiveRecord::Migration
+  #     def self.up
+  #       create_table :system_settings do |t|
+  #         t.column :name,     :string
+  #         t.column :label,    :string
+  #         t.column :value,    :text
+  #         t.column :type,     :string
+  #         t.column :position, :integer
+  #       end
+  #   
+  #       SystemSetting.create :name => "notice", :label => "Use notice?", :value => 1
+  #     end
+  #   
+  #     def self.down
+  #       drop_table :system_settings
+  #     end
+  #   end
+  #
+  # This migration first adds the system_settings table, then creates the very first row in it using the Active Record model
+  # that relies on the table. It also uses the more advanced create_table syntax where you can specify a complete table schema
+  # in one block call.
+  #
+  # == Available transformations
+  #
+  # * <tt>create_table(name, options)</tt> Creates a table called +name+ and makes the table object available to a block
+  #   that can then add columns to it, following the same format as add_column. See example above. The options hash is for
+  #   fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create table definition.
+  # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column to the table called +table_name+
+  #   named +column_name+ specified to be one of the following types:
+  #   :string, :text, :integer, :float, :datetime, :timestamp, :time, :date, :binary, :boolean. A default value can be specified
+  #   by passing an +options+ hash like { :default => 11 }.
+  # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames a column but keeps the type and content.
+  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes the column to a different type using the same
+  #   parameters as add_column.
+  # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named +column_name+ from the table called +table_name+.
+  # * <tt>add_index(table_name, column_name)</tt>: Add a new index with the name of the column on the column.
+  # * <tt>remove_index(table_name, column_name)</tt>: Remove the index called the same as the column.
+  #
+  # == Irreversible transformations
+  #
+  # Some transformations are destructive in a manner that cannot be reversed. Migrations of that kind should raise
+  # an <tt>IrreversibleMigration</tt> exception in their +down+ method.
+  #
+  # == Running migrations from within Rails
+  #
+  # The Rails package has support for migrations with the <tt>script/generate migration my_new_migration</tt> command and
+  # with the <tt>rake migrate</tt> command that'll run all the pending migrations. It'll even create the needed schema_info
+  # table automatically if it's missing.
+  #
+  # == Database support
+  #
+  # Migrations are currently only supported in MySQL and PostgreSQL.
+  #
+  # == More examples
+  #
+  # Not all migrations change the schema. Some just fix the data:
+  #
+  #   class RemoveEmptyTags < ActiveRecord::Migration
+  #     def self.up
+  #       Tag.find(:all).each { |tag| tag.destroy if tag.pages.empty? }
+  #     end
+  #   
+  #     def self.down
+  #       # not much we can do to restore deleted data
+  #     end
+  #   end
+  #
+  # Others remove columns when they migrate up instead of down:
+  #
+  #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration
+  #     def self.up
+  #       remove_column :items, :incomplete_items_count
+  #       remove_column :items, :completed_items_count
+  #     end
+  #
+  #     def self.down
+  #       add_column :items, :incomplete_items_count
+  #       add_column :items, :completed_items_count
+  #     end
+  #   end
+  class Migration
     class << self
       def up() end
       def down() end
@@ -17,11 +123,11 @@ module ActiveRecord
   class Migrator#:nodoc:
     class << self
       def up(migrations_path, target_version = nil)
-        new(:up, migrations_path, target_version).migrate
+        self.new(:up, migrations_path, target_version).migrate
       end
       
       def down(migrations_path, target_version = nil)
-        new(:down, migrations_path, target_version).migrate
+        self.new(:down, migrations_path, target_version).migrate
       end
       
       def current_version
@@ -30,6 +136,7 @@ module ActiveRecord
     end
     
     def initialize(direction, migrations_path, target_version = nil)
+      raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
       @direction, @migrations_path, @target_version = direction, migrations_path, target_version
       Base.connection.initialize_schema_information
     end
@@ -59,7 +166,7 @@ module ActiveRecord
       end
     
       def migration_files
-        files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+        files = Dir["#{@migrations_path}/[0-9]*_*.rb"].sort
         down? ? files.reverse : files
       end
       
@@ -91,4 +198,4 @@ module ActiveRecord
         (up? && version.to_i <= current_version) || (down? && version.to_i > current_version)
       end
   end
-end
+end

data/lib/active_record/query_cache.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  class QueryCache #:nodoc:
+    def initialize(connection)
+      @connection = connection
+      @query_cache = {}
+    end
+
+    def clear_query_cache
+      @query_cache = {}
+    end
+
+    def select_all(sql, name = nil)
+      @query_cache[sql] ||= @connection.select_all(sql, name)
+    end
+
+    def select_one(sql, name = nil)
+      @query_cache[sql] ||= @connection.select_one(sql, name)
+    end
+
+    def columns(table_name, name = nil)
+      @query_cache["SHOW FIELDS FROM #{table_name}"] ||= @connection.columns(table_name, name)
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil)
+      clear_query_cache
+      @connection.insert(sql, name, pk, id_value)
+    end
+
+    def update(sql, name = nil)
+      clear_query_cache
+      @connection.update(sql, name)
+    end
+
+    def delete(sql, name = nil)
+      clear_query_cache
+      @connection.delete(sql, name)
+    end
+    
+    private
+      def method_missing(method, *arguments)
+        @connection.send(method, *arguments)
+      end
+  end
+  
+  class Base
+    # Set the connection for the class with caching on
+    def self.connection=(spec)
+      raise ConnectionNotEstablished unless spec
+
+      conn = spec.config[:query_cache] ?
+        QueryCache.new(self.send(spec.adapter_method, spec.config)) :
+        self.send(spec.adapter_method, spec.config)
+      
+      Thread.current['active_connections'] ||= {}
+      Thread.current['active_connections'][self] = conn
+    end
+  end
+  
+  class AbstractAdapter #:nodoc:
+    # Stub method to be able to treat the connection the same whether the query cache has been turned on or not
+    def clear_query_cache
+    end
+  end
+end

data/lib/active_record/timestamp.rb

@@ -19,21 +19,23 @@ module ActiveRecord
     end    
       
     def create_with_timestamps #:nodoc:
+      if record_timestamps
       t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
-      write_attribute("created_at", t) if record_timestamps && respond_to?(:created_at) && created_at.nil?
-      write_attribute("created_on", t) if record_timestamps && respond_to?(:created_on) && created_on.nil?
-
-      write_attribute("updated_at", t) if record_timestamps && respond_to?(:updated_at)
-      write_attribute("updated_on", t) if record_timestamps && respond_to?(:updated_on)
+        write_attribute('created_at', t) if respond_to?(:created_at) && created_at.nil?
+        write_attribute('created_on', t) if respond_to?(:created_on) && created_on.nil?
       
+        write_attribute('updated_at', t) if respond_to?(:updated_at)
+        write_attribute('updated_on', t) if respond_to?(:updated_on)
+      end
       create_without_timestamps
     end
 
     def update_with_timestamps #:nodoc:
+      if record_timestamps
       t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
-      write_attribute("updated_at", t) if record_timestamps && respond_to?(:updated_at)
-      write_attribute("updated_on", t) if record_timestamps && respond_to?(:updated_on)
-
+        write_attribute('updated_at', t) if respond_to?(:updated_at)
+        write_attribute('updated_on', t) if respond_to?(:updated_on)
+      end
       update_without_timestamps
     end
   end 

data/lib/active_record/validations.rb

@@ -11,10 +11,12 @@ module ActiveRecord
     
     @@default_error_messages = {
       :inclusion => "is not included in the list",
+      :exclusion => "is reserved",
       :invalid => "is invalid",
       :confirmation => "doesn't match confirmation",
       :accepted  => "must be accepted",
       :empty => "can't be empty",
+      :blank => "can't be blank",
       :too_long => "is too long (max is %d characters)", 
       :too_short => "is too short (min is %d characters)", 
       :wrong_length => "is the wrong length (should be %d characters)", 
@@ -43,7 +45,7 @@ module ActiveRecord
       @errors[attribute.to_s] << msg
     end
 
-    # Will add an error message to each of the attributes in +attributes+ that is empty (defined by <tt>attribute_present?</tt>).
+    # Will add an error message to each of the attributes in +attributes+ that is empty.
     def add_on_empty(attributes, msg = @@default_error_messages[:empty])
       for attr in [attributes].flatten
         value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
@@ -51,6 +53,14 @@ module ActiveRecord
         add(attr, msg) unless !value.nil? && !is_empty
       end
     end
+    
+    # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
+    def add_on_blank(attributes, msg = @@default_error_messages[:blank])
+      for attr in [attributes].flatten
+        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+        add(attr, msg) if value.blank?
+      end
+    end
 
     # Will add an error message to each of the attributes in +attributes+ that has a length outside of the passed boundary +range+. 
     # If the length is above the boundary, the too_long_msg message will be used. If below, the too_short_msg.
@@ -203,12 +213,6 @@ module ActiveRecord
         :message => nil
       }.freeze
 
-      DEFAULT_SIZE_VALIDATION_OPTIONS = DEFAULT_VALIDATION_OPTIONS.merge(
-        :too_long => ActiveRecord::Errors.default_error_messages[:too_long],
-        :too_short => ActiveRecord::Errors.default_error_messages[:too_short],
-        :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]
-      ).freeze
-
       ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
 
       def validate(*methods, &block)
@@ -226,6 +230,29 @@ module ActiveRecord
         write_inheritable_set(:validate_on_update, methods)
       end
 
+      def condition_block?(condition)
+        condition.respond_to?("call") && (condition.arity == 1 || condition.arity == -1)
+      end
+
+      # Determine from the given condition (whether a block, procedure, method or string)
+      # whether or not to validate the record.  See #validates_each.
+      def evaluate_condition(condition, record)
+        case condition
+          when Symbol: record.send(condition)
+          when String: eval(condition, binding)
+          else
+            if condition_block?(condition)
+              condition.call(record)
+            else
+              raise(
+                ActiveRecordError,
+                "Validations need to be either a symbol, string (to be eval'ed), proc/method, or " +
+                "class implementing a static validation method"
+              )
+            end
+          end
+      end
+
       # Validates each attribute against a block.
       #
       #   class Person < ActiveRecord::Base
@@ -237,16 +264,22 @@ module ActiveRecord
       # Options:
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>allow_nil</tt> - Skip validation if attribute is nil.
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_each(*attrs)
         options = attrs.last.is_a?(Hash) ? attrs.pop.symbolize_keys : {}
         attrs = attrs.flatten
 
         # Declare the validation.
         send(validation_method(options[:on] || :save)) do |record|
-          attrs.each do |attr|
-            value = record.send(attr)
-            next if value.nil? && options[:allow_nil]
-            yield record, attr, value
+          # Don't validate when there is an :if condition and that condition is false
+          unless options[:if] && !evaluate_condition(options[:if], record)
+            attrs.each do |attr|
+              value = record.send(attr)
+              next if value.nil? && options[:allow_nil]
+              yield record, attr, value
+            end
           end
         end
       end
@@ -270,6 +303,9 @@ module ActiveRecord
       # Configuration options:
       # * <tt>message</tt> - A custom error message (default is: "doesn't match confirmation")
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_confirmation_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:confirmation], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
@@ -292,12 +328,13 @@ module ActiveRecord
       # terms_of_service is not nil and by default on save.
       #
       # Configuration options:
-      # * <tt>message</tt> - A custom error message (default is: "can't be empty")
+      # * <tt>message</tt> - A custom error message (default is: "must be accepted")
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>accept</tt> - Specifies value that is considered accepted.  The default value is a string "1", which
       # makes it easy to relate to an HTML checkbox.
-      #
-
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_acceptance_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true, :accept => "1" }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
@@ -309,20 +346,25 @@ module ActiveRecord
         end
       end
 
-      # Validates that the specified attributes are neither nil nor empty. Happens by default on save.
+      # Validates that the specified attributes are not blank (as defined by Object#blank?). Happens by default on save.
       #
       # Configuration options:
-      # * <tt>message</tt> - A custom error message (default is: "has already been taken")
+      # * <tt>message</tt> - A custom error message (default is: "can't be blank")
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_presence_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:empty], :on => :save }
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:blank], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         # can't use validates_each here, because it cannot cope with non-existant attributes,
         # while errors.add_on_empty can	
         attr_names.each do |attr_name|
           send(validation_method(configuration[:on])) do |record|
-            record.errors.add_on_empty(attr_name,configuration[:message])
+            unless configuration[:if] and not evaluate_condition(configuration[:if], record)
+              record.errors.add_on_blank(attr_name,configuration[:message])
+            end
           end
         end
       end
@@ -351,9 +393,14 @@ module ActiveRecord
       # * <tt>wrong_length</tt> - The error message if using the :is method and the attribute is the wrong size (default is: "is the wrong length (should be %d characters)")
       # * <tt>message</tt> - The error message to use for a :minimum, :maximum, or :is violation.  An alias of the appropriate too_long/too_short/wrong_length message
       # * <tt>on</tt> - Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_length_of(*attrs)
         # Merge given options with defaults.
-        options = DEFAULT_SIZE_VALIDATION_OPTIONS.dup
+        options = {:too_long     => ActiveRecord::Errors.default_error_messages[:too_long],
+                   :too_short    => ActiveRecord::Errors.default_error_messages[:too_short],
+                   :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]}.merge(DEFAULT_VALIDATION_OPTIONS)
         options.update(attrs.pop.symbolize_keys) if attrs.last.is_a?(Hash)
 
         # Ensure that one and only one range option is specified.
@@ -372,15 +419,17 @@ module ActiveRecord
         option_value = options[range_options.first]
 
         # Declare different validations per option.
-        
         validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
         message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
 
         case option
         when :within, :in
           raise ArgumentError, ':within must be a Range' unless option_value.is_a?(Range) # '
-          validates_length_of attrs, :minimum => option_value.begin, :allow_nil => options[:allow_nil]
-          validates_length_of attrs, :maximum => option_value.end, :allow_nil => options[:allow_nil]
+          (options_without_range = options.dup).delete(option)
+          (options_with_minimum = options_without_range.dup).store(:minimum, option_value.begin)
+          validates_length_of attrs, options_with_minimum
+          (options_with_maximum = options_without_range.dup).store(:maximum, option_value.end)
+          validates_length_of attrs, options_with_maximum
         when :is, :minimum, :maximum
           raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0 # '
           message = options[:message] || options[message_options[option]]
@@ -407,17 +456,20 @@ module ActiveRecord
       # Configuration options:
       # * <tt>message</tt> - Specifies a custom error message (default is: "has already been taken")
       # * <tt>scope</tt> - Ensures that the uniqueness is restricted to a condition of "scope = record.scope"
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_uniqueness_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken] }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
         if scope = configuration[:scope]
           validates_each(attr_names,configuration) do |record, attr_name, value|
-            record.errors.add(attr_name, configuration[:message]) if record.class.find_first(record.new_record? ? ["#{attr_name} = ? AND #{scope} = ?", record.send(attr_name), record.send(scope)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ? AND #{scope} = ?", record.send(attr_name), record.send(:id), record.send(scope)])
+            record.errors.add(attr_name, configuration[:message]) if record.class.find(:first, :conditions => (record.new_record? ? ["#{attr_name} = ? AND #{scope} = ?", record.send(attr_name), record.send(scope)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ? AND #{scope} = ?", record.send(attr_name), record.send(:id), record.send(scope)]))
           end
         else
           validates_each(attr_names,configuration) do |record, attr_name, value|
-            record.errors.add(attr_name, configuration[:message]) if record.class.find_first(record.new_record? ? ["#{attr_name} = ?", record.send(attr_name)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ?", record.send(attr_name), record.send(:id) ] )
+            record.errors.add(attr_name, configuration[:message]) if record.class.find(:first, :conditions => (record.new_record? ? ["#{attr_name} = ?", record.send(attr_name)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ?", record.send(attr_name), record.send(:id) ] ))
           end
         end
       end
@@ -435,6 +487,9 @@ module ActiveRecord
       # * <tt>message</tt> - A custom error message (default is: "is invalid")
       # * <tt>with</tt> - The regular expression used to validate the format with (note: must be supplied!)
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_format_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save, :with => nil }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
@@ -457,6 +512,9 @@ module ActiveRecord
       # * <tt>in</tt> - An enumerable object of available items
       # * <tt>message</tt> - Specifies a customer error message (default is: "is not included in the list")
       # * <tt>allow_nil</tt> - If set to true, skips this validation if the attribute is null (default is: false)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_inclusion_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
@@ -470,6 +528,33 @@ module ActiveRecord
         end
       end
 
+      # Validates that the value of the specified attribute is not in a particular enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
+      #     validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
+      #   end
+      #
+      # Configuration options:
+      # * <tt>in</tt> - An enumerable object of items that the value shouldn't be part of
+      # * <tt>message</tt> - Specifies a customer error message (default is: "is reserved")
+      # * <tt>allow_nil</tt> - If set to true, skips this validation if the attribute is null (default is: false)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
+      def validates_exclusion_of(*attr_names)
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:exclusion], :on => :save }
+        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+        enum = configuration[:in] || configuration[:within]
+
+        raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?("include?")
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) if enum.include?(value)
+        end
+      end
+
       # Validates whether the associated object or objects are all themselves valid. Works with any kind of association.
       #
       #   class Book < ActiveRecord::Base
@@ -487,10 +572,16 @@ module ActiveRecord
       #     validates_associated :book
       #   end
       #
-      # this would specify a circular dependency and cause infinite recursion. The Rails team recommends against this practice.
+      # ...this would specify a circular dependency and cause infinite recursion.
+      #
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to ensure that the association
+      # is both present and guaranteed to be valid, you also need to use validates_presence_of.
       #
       # Configuration options:
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_associated(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
@@ -514,6 +605,9 @@ module ActiveRecord
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>only_integer</tt> Specifies whether the value has to be an integer, e.g. an integral value (default is false)
       # * <tt>allow_nil</tt> Skip validation if attribute is nil (default is false). Notice that for fixnum and float columsn empty strings are converted to nil
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      # occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }).  The
+      # method, proc or string should return or evaluate to a true or false value.
       def validates_numericality_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:not_a_number], :on => :save,
                            :only_integer => false, :allow_nil => false }
@@ -525,6 +619,7 @@ module ActiveRecord
           end
         else
           validates_each(attr_names,configuration) do |record, attr_name,value|
+           next if configuration[:allow_nil] and record.send("#{attr_name}_before_type_cast").nil?
             begin
               Kernel.Float(record.send("#{attr_name}_before_type_cast").to_s)
             rescue ArgumentError, TypeError
@@ -558,7 +653,7 @@ module ActiveRecord
     # Attempts to save the record just like Base.save but will raise a RecordInvalid exception instead of returning false
     # if the record is not valid.
     def save!
-      valid? ? save_without_validation : raise(RecordInvalid)
+      valid? ? save(false) : raise(RecordInvalid)
     end
 
     # Updates a single attribute and saves the record without going through the normal validation procedure.