activerecord 3.0.0.beta → 3.0.0.beta2

data/CHANGELOG

@@ -1,4 +1,11 @@
-*Edge*
+*Rails 3.0.0 [Beta 2] (pending)*
+
+* To prefix the table names of all models in a module, define self.table_name_prefix on the module.  #4032 [Andrew White]
+
+* Silenced "SHOW FIELDS" and "SET SQL_AUTO_IS_NULL=0" statements from the MySQL driver to improve log signal to noise ration in development [DHH]
+
+
+*Rails 3.0.0 [Beta 1] (February 4th, 2010)*
 
 * PostgreSQLAdapter: set time_zone to UTC when Base.default_timezone == :utc so that Postgres doesn't incorrectly offset-adjust values inserted into TIMESTAMP WITH TIME ZONE columns. #3777 [Jack Christensen]
 

data/lib/active_record.rb

@@ -30,7 +30,6 @@ $:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include
 
 require 'active_support'
 require 'active_model'
-require 'arel'
 
 module ActiveRecord
   extend ActiveSupport::Autoload
@@ -38,8 +37,8 @@ module ActiveRecord
   eager_autoload do
     autoload :VERSION
 
-    autoload :ActiveRecordError, 'active_record/base'
-    autoload :ConnectionNotEstablished, 'active_record/base'
+    autoload :ActiveRecordError, 'active_record/errors'
+    autoload :ConnectionNotEstablished, 'active_record/errors'
 
     autoload :Aggregations
     autoload :AssociationPreload
@@ -55,10 +54,10 @@ module ActiveRecord
       autoload :Calculations
       autoload :PredicateBuilder
       autoload :SpawnMethods
+      autoload :Batches
     end
 
     autoload :Base
-    autoload :Batches
     autoload :Callbacks
     autoload :DynamicFinderMatch
     autoload :DynamicScopeMatch
@@ -106,6 +105,7 @@ module ActiveRecord
 
     eager_autoload do
       autoload :AbstractAdapter
+      autoload :ConnectionManagement, "active_record/connection_adapters/abstract/connection_pool"
     end
   end
 
@@ -113,5 +113,8 @@ module ActiveRecord
   autoload :TestFixtures, 'active_record/fixtures'
 end
 
-Arel::Table.engine = Arel::Sql::Engine.new(ActiveRecord::Base)
-I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+ActiveSupport.on_load(:active_record) do
+  Arel::Table.engine = Arel::Sql::Engine.new(self)
+end
+
+I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'

data/lib/active_record/aggregations.rb

@@ -213,6 +213,11 @@ module ActiveRecord
           module_eval do
             define_method(name) do |*args|
               force_reload = args.first || false
+
+              unless instance_variable_defined?("@#{name}")
+                instance_variable_set("@#{name}", nil)
+              end
+
               if (instance_variable_get("@#{name}").nil? || force_reload) && (!allow_nil || mapping.any? {|pair| !read_attribute(pair.first).nil? })
                 attrs = mapping.collect {|pair| read_attribute(pair.first)}
                 object = case constructor

data/lib/active_record/association_preload.rb

@@ -126,7 +126,7 @@ module ActiveRecord
         parent_records.each do |parent_record|
           association_proxy = parent_record.send(reflection_name)
           association_proxy.loaded
-          association_proxy.target.push *Array.wrap(associated_record)
+          association_proxy.target.push(*Array.wrap(associated_record))
 
           association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
         end
@@ -159,6 +159,11 @@ module ActiveRecord
             association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
           end
         end
+
+        id_to_record_map.each do |id, records|
+          next if seen_keys.include?(id.to_s)
+          records.each {|record| record.send("set_#{reflection_name}_target", nil) }            
+        end
       end
 
       # Given a collection of ActiveRecord objects, constructs a Hash which maps
@@ -324,7 +329,7 @@ module ActiveRecord
           klass = klass_name.constantize
 
           table_name = klass.quoted_table_name
-          primary_key = klass.primary_key
+          primary_key = reflection.options[:primary_key] || klass.primary_key
           column_type = klass.columns.detect{|c| c.name == primary_key}.type
 
           ids = id_map.keys.map do |id|

data/lib/active_record/associations.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
@@ -85,6 +86,15 @@ module ActiveRecord
     end
   end
 
+  # This error is raised when trying to destroy a parent instance in a N:1, 1:1 assosications
+  # (has_many, has_one) when there is at least 1 child assosociated instance.
+  # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
+  class DeleteRestrictionError < ActiveRecordError #:nodoc:
+    def initialize(reflection)
+      super("Cannot delete record because of dependent #{reflection.name}")
+    end
+  end
+
   # See ActiveRecord::Associations::ClassMethods for documentation.
   module Associations # :nodoc:
     extend ActiveSupport::Concern
@@ -111,8 +121,11 @@ module ActiveRecord
     private
       # Gets the specified association instance if it responds to :loaded?, nil otherwise.
       def association_instance_get(name)
-        association = instance_variable_get("@#{name}")
-        association if association.respond_to?(:loaded?)
+        ivar = "@#{name}"
+        if instance_variable_defined?(ivar)
+          association = instance_variable_get(ivar)
+          association if association.respond_to?(:loaded?)
+        end
       end
 
       # Set the specified association instance.
@@ -827,6 +840,8 @@ module ActiveRecord
       #   objects are deleted *without* calling their +destroy+ method.  If set to <tt>:nullify</tt> all associated
       #   objects' foreign keys are set to +NULL+ *without* calling their +save+ callbacks. *Warning:* This option is ignored when also using
       #   the <tt>:through</tt> option.
+      #   the <tt>:through</tt> option. If set to <tt>:restrict</tt>
+      #   this object cannot be deleted if it has any associated object.
       # [:finder_sql]
       #   Specify a complete SQL statement to fetch the association. This is a good way to go for complex
       #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added.
@@ -1207,7 +1222,7 @@ module ActiveRecord
       # * <tt>Developer#projects.empty?</tt>
       # * <tt>Developer#projects.size</tt>
       # * <tt>Developer#projects.find(id)</tt>
-      # * <tt>Developer#clients.exists?(...)</tt>
+      # * <tt>Developer#projects.exists?(...)</tt>
       # * <tt>Developer#projects.build</tt> (similar to <tt>Project.new("project_id" => id)</tt>)
       # * <tt>Developer#projects.create</tt> (similar to <tt>c = Project.new("project_id" => id); c.save; c</tt>)
       # The declaration may include an options hash to specialize the behavior of the association.
@@ -1465,9 +1480,15 @@ module ActiveRecord
 
         # Creates before_destroy callback methods that nullify, delete or destroy
         # has_many associated objects, according to the defined :dependent rule.
+        # If the association is marked as :dependent => :restrict, create a callback
+        # that prevents deleting entirely.
         #
         # See HasManyAssociation#delete_records.  Dependent associations
         # delete children, otherwise foreign key is set to NULL.
+        # See HasManyAssociation#delete_records. Dependent associations
+        # delete children if the option is set to :destroy or :delete_all, set the
+        # foreign key to NULL if the option is set to :nullify, and do not touch the
+        # child records if the option is set to :restrict.
         #
         # The +extra_conditions+ parameter, which is not used within the main
         # Active Record codebase, is meant to allow plugins to define extra
@@ -1527,68 +1548,76 @@ module ActiveRecord
                       %@#{dependent_conditions}@)
                   end
                 CALLBACK
+                when :restrict
+                  method_name = "has_many_dependent_restrict_for_#{reflection.name}".to_sym
+                  define_method(method_name) do
+                    unless send(reflection.name).empty?
+                      raise DeleteRestrictionError.new(reflection)
+                    end
+                  end
+                  before_destroy method_name
               else
-                raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, or :nullify (#{reflection.options[:dependent].inspect})"
+                raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, :nullify or :restrict (#{reflection.options[:dependent].inspect})"
             end
           end
         end
 
         # Creates before_destroy callback methods that nullify, delete or destroy
         # has_one associated objects, according to the defined :dependent rule.
+        # If the association is marked as :dependent => :restrict, create a callback
+        # that prevents deleting entirely.
         def configure_dependency_for_has_one(reflection)
           if reflection.options.include?(:dependent)
-            case reflection.options[:dependent]
-              when :destroy
-                method_name = "has_one_dependent_destroy_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  association = send(reflection.name)
-                  association.destroy unless association.nil?
-                end
-                before_destroy method_name
-              when :delete
-                method_name = "has_one_dependent_delete_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  # Retrieve the associated object and delete it. The retrieval
-                  # is necessary because there may be multiple associated objects
-                  # with foreign keys pointing to this object, and we only want
-                  # to delete the correct one, not all of them.
-                  association = send(reflection.name)
-                  association.delete unless association.nil?
-                end
-                before_destroy method_name
+            name = reflection.options[:dependent]
+            method_name = :"has_one_dependent_#{name}_for_#{reflection.name}"
+
+            case name
+              when :destroy, :delete
+                class_eval <<-eoruby, __FILE__, __LINE__ + 1
+                  def #{method_name}
+                    association = #{reflection.name}
+                    association.#{name} if association
+                  end
+                eoruby
               when :nullify
-                method_name = "has_one_dependent_nullify_for_#{reflection.name}".to_sym
+                class_eval <<-eoruby, __FILE__, __LINE__ + 1
+                  def #{method_name}
+                    association = #{reflection.name}
+                    association.update_attribute(#{reflection.primary_key_name.inspect}, nil) if association
+                  end
+                eoruby
+              when :restrict
+                method_name = "has_one_dependent_restrict_for_#{reflection.name}".to_sym
                 define_method(method_name) do
-                  association = send(reflection.name)
-                  association.update_attribute(reflection.primary_key_name, nil) unless association.nil?
+                  unless send(reflection.name).nil?
+                    raise DeleteRestrictionError.new(reflection)
+                  end
                 end
                 before_destroy method_name
               else
-                raise ArgumentError, "The :dependent option expects either :destroy, :delete or :nullify (#{reflection.options[:dependent].inspect})"
+                raise ArgumentError, "The :dependent option expects either :destroy, :delete, :nullify or :restrict (#{reflection.options[:dependent].inspect})"
             end
+
+            before_destroy method_name
           end
         end
 
         def configure_dependency_for_belongs_to(reflection)
           if reflection.options.include?(:dependent)
-            case reflection.options[:dependent]
-              when :destroy
-                method_name = "belongs_to_dependent_destroy_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  association = send(reflection.name)
-                  association.destroy unless association.nil?
-                end
-                after_destroy method_name
-              when :delete
-                method_name = "belongs_to_dependent_delete_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  association = send(reflection.name)
-                  association.delete unless association.nil?
-                end
-                after_destroy method_name
-              else
-                raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{reflection.options[:dependent].inspect})"
+            name = reflection.options[:dependent]
+
+            unless [:destroy, :delete].include?(name)
+              raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{reflection.options[:dependent].inspect})"
             end
+
+            method_name = :"belongs_to_dependent_#{name}_for_#{reflection.name}"
+            class_eval <<-eoruby, __FILE__, __LINE__ + 1
+              def #{method_name}
+                association = #{reflection.name}
+                association.#{name} if association
+              end
+            eoruby
+            after_destroy method_name
           end
         end
 
@@ -1686,15 +1715,6 @@ module ActiveRecord
           reflection
         end
 
-        def using_limitable_reflections?(reflections)
-          reflections.collect(&:collection?).length.zero?
-        end
-
-        def column_aliases(join_dependency)
-          join_dependency.joins.collect{|join| join.column_names_with_alias.collect{|column_name, aliased_name|
-              "#{connection.quote_table_name join.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"}}.flatten.join(", ")
-        end
-
         def add_association_callbacks(association_name, options)
           callbacks = %w(before_add after_add before_remove after_remove)
           callbacks.each do |callback_name|
@@ -2011,7 +2031,7 @@ module ActiveRecord
                   [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
                 end
               when :belongs_to
-                [aliased_table[reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name])]
+                [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name])]
               end
 
               unless klass.descends_from_active_record?

data/lib/active_record/associations/association_collection.rb

@@ -101,6 +101,7 @@ module ActiveRecord
           Array(@target)
         end
       end
+      alias_method :to_a, :to_ary
 
       def reset
         reset_target!

data/lib/active_record/associations/association_proxy.rb

@@ -49,10 +49,11 @@ module ActiveRecord
       alias_method :proxy_respond_to?, :respond_to?
       alias_method :proxy_extend, :extend
       delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+      instance_methods.each { |m| undef_method m unless m =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
+        @updated = false
         reflection.check_validity!
         Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
         reset

data/lib/active_record/associations/has_many_association.rb

@@ -5,6 +5,10 @@ module ActiveRecord
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
     class HasManyAssociation < AssociationCollection #:nodoc:
+      def initialize(owner, reflection)
+        @finder_sql = nil
+        super
+      end
       protected
         def owner_quoted_id
           if @reflection.options[:primary_key]

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,4 +1,5 @@
 require "active_record/associations/through_association_scope"
+require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   module Associations

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActiveRecord
   module AttributeMethods
     module Dirty
@@ -18,7 +20,7 @@ module ActiveRecord
       def save_with_dirty(*args) #:nodoc:
         if status = save_without_dirty(*args)
           @previously_changed = changes
-          changed_attributes.clear
+          @changed_attributes.clear
         end
         status
       end
@@ -26,16 +28,16 @@ module ActiveRecord
       # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
       def save_with_dirty!(*args) #:nodoc:
         save_without_dirty!(*args).tap do
-          @previously_changed = changes 
-          changed_attributes.clear 
+          @previously_changed = changes
+          @changed_attributes.clear
         end
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
       def reload_with_dirty(*args) #:nodoc:
         reload_without_dirty(*args).tap do
-          previously_changed_attributes.clear
-          changed_attributes.clear
+          @previously_changed.clear
+          @changed_attributes.clear
         end
       end
 
@@ -45,12 +47,12 @@ module ActiveRecord
           attr = attr.to_s
 
           # The attribute already has an unsaved change.
-          if changed_attributes.include?(attr)
-            old = changed_attributes[attr]
-            changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+          if attribute_changed?(attr)
+            old = @changed_attributes[attr]
+            @changed_attributes.delete(attr) unless field_changed?(attr, old, value)
           else
             old = clone_attribute_value(:read_attribute, attr)
-            changed_attributes[attr] = old if field_changed?(attr, old, value)
+            @changed_attributes[attr] = old if field_changed?(attr, old, value)
           end
 
           # Carry on.

data/lib/active_record/attribute_methods/primary_key.rb

@@ -3,6 +3,12 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
+      # Returns this record's primary key value wrapped in an Array
+      # or nil if the record is a new_record?
+      def to_key
+        new_record? ? nil : [ send(self.class.primary_key) ]
+      end
+
       module ClassMethods
         # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
         # primary_key_prefix_type setting, though.

data/lib/active_record/attribute_methods/query.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActiveRecord
   module AttributeMethods
     module Query

data/lib/active_record/base.rb

@@ -11,174 +11,14 @@ require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string/behavior'
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/object/blank'
+require 'arel'
+require 'active_record/errors'
 
 module ActiveRecord #:nodoc:
-  # Generic Active Record exception class.
-  class ActiveRecordError < StandardError
-  end
-
-  # Raised when the single-table inheritance mechanism fails to locate the subclass
-  # (for example due to improper usage of column that +inheritance_column+ points to).
-  class SubclassNotFound < ActiveRecordError #:nodoc:
-  end
-
-  # Raised when an object assigned to an association has an incorrect type.
-  #
-  #   class Ticket < ActiveRecord::Base
-  #     has_many :patches
-  #   end
-  #
-  #   class Patch < ActiveRecord::Base
-  #     belongs_to :ticket
-  #   end
-  #
-  #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
-  #   @ticket.patches << Comment.new(:content => "Please attach tests to your patch.")
-  class AssociationTypeMismatch < ActiveRecordError
-  end
-
-  # Raised when unserialized object's type mismatches one specified for serializable field.
-  class SerializationTypeMismatch < ActiveRecordError
-  end
-
-  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt> misses adapter field).
-  class AdapterNotSpecified < ActiveRecordError
-  end
-
-  # Raised when Active Record cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
-  class AdapterNotFound < ActiveRecordError
-  end
-
-  # Raised when connection to the database could not been established (for example when <tt>connection=</tt> is given a nil object).
-  class ConnectionNotEstablished < ActiveRecordError
-  end
-
-  # Raised when Active Record cannot find record by given id or set of ids.
-  class RecordNotFound < ActiveRecordError
-  end
-
-  # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
-  # saved because record is invalid.
-  class RecordNotSaved < ActiveRecordError
-  end
-
-  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for MySQL when Ruby driver used is too old).
-  class StatementInvalid < ActiveRecordError
-  end
-
-  # Raised when SQL statement is invalid and the application gets a blank result.
-  class ThrowResult < ActiveRecordError
-  end
-
-  # Parent class for all specific exceptions which wrap database driver exceptions
-  # provides access to the original exception also.
-  class WrappedDatabaseException < StatementInvalid
-    attr_reader :original_exception
-
-    def initialize(message, original_exception)
-      super(message)
-      @original_exception = original_exception
-    end
-  end
-
-  # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
-  class RecordNotUnique < WrappedDatabaseException
-  end
-
-  # Raised when a record cannot be inserted or updated because it references a non-existent record.
-  class InvalidForeignKey < WrappedDatabaseException
-  end
-
-  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example, when using +find+ method)
-  # does not match number of expected variables.
-  #
-  # For example, in
-  #
-  #   Location.find :all, :conditions => ["lat = ? AND lng = ?", 53.7362]
-  #
-  # two placeholders are given but only one variable to fill them.
-  class PreparedStatementInvalid < ActiveRecordError
-  end
-
-  # Raised on attempt to save stale record. Record is stale when it's being saved in another query after
-  # instantiation, for example, when two users edit the same wiki page and one starts editing and saves
-  # the page before the other.
-  #
-  # Read more about optimistic locking in ActiveRecord::Locking module RDoc.
-  class StaleObjectError < ActiveRecordError
-  end
-
-  # Raised when association is being configured improperly or
-  # user tries to use offset and limit together with has_many or has_and_belongs_to_many associations.
-  class ConfigurationError < ActiveRecordError
-  end
-
-  # Raised on attempt to update record that is instantiated as read only.
-  class ReadOnlyRecord < ActiveRecordError
-  end
-
-  # ActiveRecord::Transactions::ClassMethods.transaction uses this exception
-  # to distinguish a deliberate rollback from other exceptional situations.
-  # Normally, raising an exception will cause the +transaction+ method to rollback
-  # the database transaction *and* pass on the exception. But if you raise an
-  # ActiveRecord::Rollback exception, then the database transaction will be rolled back,
-  # without passing on the exception.
-  #
-  # For example, you could do this in your controller to rollback a transaction:
-  #
-  #   class BooksController < ActionController::Base
-  #     def create
-  #       Book.transaction do
-  #         book = Book.new(params[:book])
-  #         book.save!
-  #         if today_is_friday?
-  #           # The system must fail on Friday so that our support department
-  #           # won't be out of job. We silently rollback this transaction
-  #           # without telling the user.
-  #           raise ActiveRecord::Rollback, "Call tech support!"
-  #         end
-  #       end
-  #       # ActiveRecord::Rollback is the only exception that won't be passed on
-  #       # by ActiveRecord::Base.transaction, so this line will still be reached
-  #       # even on Friday.
-  #       redirect_to root_url
-  #     end
-  #   end
-  class Rollback < ActiveRecordError
-  end
-
-  # Raised when attribute has a name reserved by Active Record (when attribute has name of one of Active Record instance methods).
-  class DangerousAttributeError < ActiveRecordError
-  end
-
-  # Raised when unknown attributes are supplied via mass assignment.
-  class UnknownAttributeError < NoMethodError
-  end
-
-  # Raised when an error occurred while doing a mass assignment to an attribute through the
-  # <tt>attributes=</tt> method. The exception has an +attribute+ property that is the name of the
-  # offending attribute.
-  class AttributeAssignmentError < ActiveRecordError
-    attr_reader :exception, :attribute
-    def initialize(message, exception, attribute)
-      @exception = exception
-      @attribute = attribute
-      @message = message
-    end
-  end
-
-  # Raised when there are multiple errors while doing a mass assignment through the +attributes+
-  # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
-  # objects, each corresponding to the error while assigning to an attribute.
-  class MultiparameterAssignmentErrors < ActiveRecordError
-    attr_reader :errors
-    def initialize(errors)
-      @errors = errors
-    end
-  end
-
   # Active Record objects don't specify their attributes directly, but rather infer them from the table definition with
   # which they're linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change
   # is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain
@@ -498,6 +338,9 @@ module ActiveRecord #:nodoc:
     # Accessor for the name of the prefix string to prepend to every table name. So if set to "basecamp_", all
     # table names will be named like "basecamp_projects", "basecamp_people", etc. This is a convenient way of creating a namespace
     # for tables in a shared database. By default, the prefix is the empty string.
+    #
+    # If you are organising your models within modules you can add a prefix to the models within a namespace by defining
+    # a singleton method in the parent module called table_name_prefix which returns your chosen prefix.
     cattr_accessor :table_name_prefix, :instance_writer => false
     @@table_name_prefix = ""
 
@@ -551,12 +394,13 @@ module ActiveRecord #:nodoc:
     class << self # Class methods
       def colorize_logging(*args)
         ActiveSupport::Deprecation.warn "ActiveRecord::Base.colorize_logging and " <<
-          "config.active_record.colorize_logging are deprecated. Please use " << 
-          "Rails::Subscriber.colorize_logging or config.colorize_logging instead", caller
+          "config.active_record.colorize_logging are deprecated. Please use " <<
+          "Rails::LogSubscriber.colorize_logging or config.colorize_logging instead", caller
       end
       alias :colorize_logging= :colorize_logging
 
       delegate :find, :first, :last, :all, :destroy, :destroy_all, :exists?, :delete, :delete_all, :update, :update_all, :to => :scoped
+      delegate :find_each, :find_in_batches, :to => :scoped
       delegate :select, :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
@@ -924,7 +768,7 @@ module ActiveRecord #:nodoc:
               contained = contained.singularize if parent.pluralize_table_names
               contained << '_'
             end
-            name = "#{table_name_prefix}#{contained}#{undecorated_table_name(base.name)}#{table_name_suffix}"
+            name = "#{full_table_name_prefix}#{contained}#{undecorated_table_name(base.name)}#{table_name_suffix}"
           end
 
         @quoted_table_name = nil
@@ -932,6 +776,10 @@ module ActiveRecord #:nodoc:
         name
       end
 
+      def full_table_name_prefix #:nodoc:
+        (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+      end
+
       # Defines the column name for use with single table inheritance
       # -- can be set in subclasses like so: self.inheritance_column = "type_id"
       def inheritance_column
@@ -1202,6 +1050,12 @@ module ActiveRecord #:nodoc:
 
           object.instance_variable_set(:'@attributes', record)
           object.instance_variable_set(:'@attributes_cache', {})
+          object.instance_variable_set(:@new_record, false)
+          object.instance_variable_set(:@readonly, false)
+          object.instance_variable_set(:@destroyed, false)
+          object.instance_variable_set(:@marked_for_destruction, false)
+          object.instance_variable_set(:@previously_changed, {})
+          object.instance_variable_set(:@changed_attributes, {})
 
           object.send(:_run_find_callbacks)
           object.send(:_run_initialize_callbacks)
@@ -1443,7 +1297,7 @@ module ActiveRecord #:nodoc:
         # <tt>options</tt> argument is the same as in find.
         #
         #   class Person < ActiveRecord::Base
-        #     default_scope :order => 'last_name, first_name'
+        #     default_scope order('last_name, first_name')
         #   end
         def default_scope(options = {})
           self.default_scoping << construct_finder_arel(options)
@@ -1667,13 +1521,19 @@ module ActiveRecord #:nodoc:
         @attributes = attributes_from_column_definition
         @attributes_cache = {}
         @new_record = true
+        @readonly = false
+        @destroyed = false
+        @marked_for_destruction = false
+        @previously_changed = {}
+        @changed_attributes = {}
+
         ensure_proper_type
-        self.attributes = attributes unless attributes.nil?
 
         if scope = self.class.send(:current_scoped_methods)
           create_with = scope.scope_for_create
           create_with.each { |att,value| self.send("#{att}=", value) } if create_with
         end
+        self.attributes = attributes unless attributes.nil?
 
         result = yield self if block_given?
         _run_initialize_callbacks
@@ -1731,7 +1591,7 @@ module ActiveRecord #:nodoc:
       #   user_path(user)  # => "/users/Phusion"
       def to_param
         # We can't use alias_method here, because method 'id' optimizes itself on the fly.
-        (id = self.id) ? id.to_s : nil # Be sure to stringify the id for routes
+        id && id.to_s # Be sure to stringify the id for routes
       end
 
       # Returns a cache key that can be used to identify this record.
@@ -1758,12 +1618,17 @@ module ActiveRecord #:nodoc:
 
       # Returns true if this object hasn't been saved yet -- that is, a record for the object doesn't exist yet; otherwise, returns false.
       def new_record?
-        @new_record || false
+        @new_record
       end
 
       # Returns true if this object has been destroyed, otherwise returns false.
       def destroyed?
-        @destroyed || false
+        @destroyed
+      end
+
+      # Returns if the record is persisted, i.e. it's not a new record and it was not destroyed.
+      def persisted?
+        !(new_record? || destroyed?)
       end
 
       # :call-seq:
@@ -1815,7 +1680,7 @@ module ActiveRecord #:nodoc:
       # callbacks, Observer methods, or any <tt>:dependent</tt> association
       # options, use <tt>#destroy</tt>.
       def delete
-        self.class.delete(id) unless new_record?
+        self.class.delete(id) if persisted?
         @destroyed = true
         freeze
       end
@@ -1823,7 +1688,7 @@ module ActiveRecord #:nodoc:
       # Deletes the record in the database and freezes this instance to reflect that no changes should
       # be made (since they can't be persisted).
       def destroy
-        unless new_record?
+        if persisted?
           self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
         end
 
@@ -1843,6 +1708,7 @@ module ActiveRecord #:nodoc:
         became.instance_variable_set("@attributes", @attributes)
         became.instance_variable_set("@attributes_cache", @attributes_cache)
         became.instance_variable_set("@new_record", new_record?)
+        became.instance_variable_set("@destroyed", destroyed?)
         became
       end
 
@@ -1850,7 +1716,7 @@ module ActiveRecord #:nodoc:
       # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
       # in Base is replaced with this when the validations module is mixed in, which it is by default.
       def update_attribute(name, value)
-        send(name.to_s + '=', value)
+        send("#{name}=", value)
         save(:validate => false)
       end
 
@@ -1925,7 +1791,7 @@ module ActiveRecord #:nodoc:
       def reload(options = nil)
         clear_aggregation_cache
         clear_association_cache
-        @attributes.update(self.class.find(self.id, options).instance_variable_get('@attributes'))
+        @attributes.update(self.class.send(:with_exclusive_scope) { self.class.find(self.id, options) }.instance_variable_get('@attributes'))
         @attributes_cache = {}
         self
       end
@@ -1994,10 +1860,9 @@ module ActiveRecord #:nodoc:
 
       # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
       def attributes
-        self.attribute_names.inject({}) do |attrs, name|
-          attrs[name] = read_attribute(name)
-          attrs
-        end
+        attrs = {}
+        attribute_names.each { |name| attrs[name] = read_attribute(name) }
+        attrs
       end
 
       # Returns an <tt>#inspect</tt>-like string for the value of the
@@ -2041,8 +1906,7 @@ module ActiveRecord #:nodoc:
       def ==(comparison_object)
         comparison_object.equal?(self) ||
           (comparison_object.instance_of?(self.class) &&
-            comparison_object.id == id &&
-            !comparison_object.new_record?)
+            comparison_object.id == id && !comparison_object.new_record?)
       end
 
       # Delegates to ==
@@ -2069,14 +1933,14 @@ module ActiveRecord #:nodoc:
       # Returns duplicated record with unfreezed attributes.
       def dup
         obj = super
-        obj.instance_variable_set('@attributes', instance_variable_get('@attributes').dup)
+        obj.instance_variable_set('@attributes', @attributes.dup)
         obj
       end
 
       # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
       # attributes will be marked as read only since they cannot be saved.
       def readonly?
-        defined?(@readonly) && @readonly == true
+        @readonly
       end
 
       # Marks this record as read only.
@@ -2096,10 +1960,10 @@ module ActiveRecord #:nodoc:
 
     protected
       def clone_attributes(reader_method = :read_attribute, attributes = {})
-        self.attribute_names.inject(attributes) do |attrs, name|
-          attrs[name] = clone_attribute_value(reader_method, name)
-          attrs
+        attribute_names.each do |name|
+          attributes[name] = clone_attribute_value(reader_method, name)
         end
+        attributes
       end
 
       def clone_attribute_value(reader_method, attribute_name)
@@ -2198,26 +2062,6 @@ module ActiveRecord #:nodoc:
         default
       end
 
-      # Returns a copy of the attributes hash where all the values have been safely quoted for use in
-      # an SQL statement.
-      def attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
-        quoted = {}
-        connection = self.class.connection
-        attribute_names.each do |name|
-          if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
-            value = read_attribute(name)
-
-            # We need explicit to_yaml because quote() does not properly convert Time/Date fields to YAML.
-            if value && self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))
-              value = value.to_yaml
-            end
-
-            quoted[name] = connection.quote(value, column)
-          end
-        end
-        include_readonly_attributes ? quoted : remove_readonly_attributes(quoted)
-      end
-
       # Returns a copy of the attributes hash where all the values have been safely quoted for use in
       # an Arel insert/update method.
       def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
@@ -2342,7 +2186,7 @@ module ActiveRecord #:nodoc:
 
       # Returns a comma-separated pair list, like "key1 = val1, key2 = val2".
       def comma_pair_list(hash)
-        hash.inject([]) { |list, pair| list << "#{pair.first} = #{pair.last}" }.join(", ")
+        hash.map { |k,v| "#{k} = #{v}" }.join(", ")
       end
 
       def quote_columns(quoter, hash)
@@ -2379,6 +2223,7 @@ module ActiveRecord #:nodoc:
     extend QueryCache::ClassMethods
     extend ActiveSupport::Benchmarkable
 
+    include ActiveModel::Conversion
     include Validations
     include Locking::Optimistic, Locking::Pessimistic
     include AttributeMethods
@@ -2388,16 +2233,16 @@ module ActiveRecord #:nodoc:
     include AttributeMethods::Dirty
     include Callbacks, ActiveModel::Observing, Timestamp
     include Associations, AssociationPreload, NamedScope
-    include ActiveModel::Conversion
 
     # AutosaveAssociation needs to be included before Transactions, because we want
     # #save_with_autosave_associations to be wrapped inside a transaction.
     include AutosaveAssociation, NestedAttributes
+    include Aggregations, Transactions, Reflection, Serialization
 
-    include Aggregations, Transactions, Reflection, Batches, Serialization
-
+    NilClass.add_whiner(self) if NilClass.respond_to?(:add_whiner)
   end
 end
 
 # TODO: Remove this and make it work with LAZY flag
 require 'active_record/connection_adapters/abstract_adapter'
+ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)