activerecord 3.0.0.beta4 → 3.0.0.rc

data/lib/active_record/associations/association_collection.rb

@@ -3,6 +3,8 @@ require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
   module Associations
+    # = Active Record Association Collection
+    #
     # AssociationCollection is an abstract class that provides common stuff to
     # ease the implementation of association proxies that represent
     # collections. See the class hierarchy in AssociationProxy.
@@ -24,10 +26,10 @@ module ActiveRecord
 
       delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
 
-      def select(select = nil, &block)
+      def select(select = nil)
         if block_given?
           load_target
-          @target.select(&block)
+          @target.select.each { |e| yield e }
         else
           scoped.select(select)
         end
@@ -121,7 +123,7 @@ module ActiveRecord
         end
       end
 
-      # Add +records+ to this association.  Returns +self+ so method calls may be chained.  
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
         result = true
@@ -166,7 +168,7 @@ module ActiveRecord
         reset_target!
         reset_named_scopes_cache!
       end
-      
+
       # Calculate sum using SQL, not Enumerable
       def sum(*args)
         if block_given?
@@ -181,10 +183,13 @@ module ActiveRecord
       # descendant's +construct_sql+ method will have set :counter_sql automatically.
       # Otherwise, construct options and pass them with scope to the target class's +count+.
       def count(column_name = nil, options = {})
-        if @reflection.options[:counter_sql]
+        column_name, options = nil, column_name if column_name.is_a?(Hash)
+
+        if @reflection.options[:counter_sql] && !options.blank?
+          raise ArgumentError, "If finder_sql/counter_sql is used then options cannot be passed"
+        elsif @reflection.options[:counter_sql]
           @reflection.klass.count_by_sql(@counter_sql)
         else
-          column_name, options = nil, column_name if column_name.is_a?(Hash)
 
           if @reflection.options[:uniq]
             # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
@@ -213,9 +218,9 @@ module ActiveRecord
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        remove_records(records) do |records, old_records|
+        remove_records(records) do |_records, old_records|
           delete_records(old_records) if old_records.any?
-          records.each { |record| @target.delete(record) }
+          _records.each { |record| @target.delete(record) }
         end
       end
 
@@ -226,7 +231,7 @@ module ActiveRecord
       # ignoring the +:dependent+ option.
       def destroy(*records)
         records = find(records) if records.any? {|record| record.kind_of?(Fixnum) || record.kind_of?(String)}
-        remove_records(records) do |records, old_records|
+        remove_records(records) do |_records, old_records|
           old_records.each { |record| record.destroy }
         end
 
@@ -239,7 +244,7 @@ module ActiveRecord
 
         if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
           destroy_all
-        else          
+        else
           delete_all
         end
 
@@ -251,9 +256,10 @@ module ActiveRecord
       # See destroy for more info.
       def destroy_all
         load_target
-        destroy(@target)
-        reset_target!
-        reset_named_scopes_cache!
+        destroy(@target).tap do
+          reset_target!
+          reset_named_scopes_cache!
+        end
       end
 
       def create(attrs = {})
@@ -388,7 +394,17 @@ module ActiveRecord
             begin
               if !loaded?
                 if @target.is_a?(Array) && @target.any?
-                  @target = find_target + @target.find_all {|t| t.new_record? }
+                  @target = find_target.map do |f|
+                    i = @target.index(f)
+                    if i
+                      @target.delete_at(i).tap do |t|
+                        keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
+                        t.attributes = f.attributes.except(*keys)
+                      end
+                    else
+                      f
+                    end
+                  end + @target
                 else
                   @target = find_target
                 end
@@ -403,6 +419,12 @@ module ActiveRecord
         end
 
         def method_missing(method, *args)
+          match = DynamicFinderMatch.match(method)
+          if match && match.creator?
+            attributes = match.attribute_names
+            return send(:"find_by_#{attributes.join('and')}", *args) || create(Hash[attributes.zip(args)])
+          end
+
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
             if block_given?
               super { |*block_args| yield(*block_args) }
@@ -456,7 +478,11 @@ module ActiveRecord
           callback(:before_add, record)
           yield(record) if block_given?
           @target ||= [] unless loaded?
-          @target << record unless @reflection.options[:uniq] && @target.include?(record)
+          if index = @target.index(record)
+            @target[index] = record
+          else
+             @target << record
+          end
           callback(:after_add, record)
           set_inverse_instance(record, @owner)
           record
@@ -514,8 +540,8 @@ module ActiveRecord
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{@reflection.name}"
           @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
-        end   
-        
+        end
+
         def ensure_owner_is_not_new
           if @owner.new_record?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"

data/lib/active_record/associations/association_proxy.rb

@@ -2,6 +2,8 @@ require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
   module Associations
+    # = Active Record Associations
+    #
     # This is the root class of all association proxies:
     #
     #   AssociationProxy

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Belongs To Associations
   module Associations
     class BelongsToAssociation < AssociationProxy #:nodoc:
       def create(attributes = {})

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Belongs To Polymorphic Association
   module Associations
     class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
       def replace(record)

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Has And Belongs To Many Association
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
       def create(attributes = {})
@@ -44,17 +45,23 @@ module ActiveRecord
           if @reflection.options[:insert_sql]
             @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
           else
-            relation = Arel::Table.new(@reflection.options[:join_table])
+            relation   = Arel::Table.new(@reflection.options[:join_table])
+            timestamps = record_timestamp_columns(record)
+            timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
+
             attributes = columns.inject({}) do |attrs, column|
-              case column.name.to_s
+              name = column.name
+              case name.to_s
                 when @reflection.primary_key_name.to_s
-                  attrs[relation[column.name]] = owner_quoted_id
+                  attrs[relation[name]] = @owner.id
                 when @reflection.association_foreign_key.to_s
-                  attrs[relation[column.name]] = record.quoted_id
+                  attrs[relation[name]] = record.id
+                when *timestamps
+                  attrs[relation[name]] = timezone
                 else
-                  if record.has_attribute?(column.name)
-                    value = @owner.send(:quote_value, record[column.name], column)
-                    attrs[relation[column.name]] = value unless value.nil?
+                  if record.has_attribute?(name)
+                    value = @owner.send(:quote_value, record[name], column)
+                    attrs[relation[name]] = value unless value.nil?
                   end
               end
               attrs
@@ -116,6 +123,14 @@ module ActiveRecord
             build_record(attributes, &block)
           end
         end
+
+        def record_timestamp_columns(record)
+          if record.record_timestamps
+            record.send(:all_timestamp_attributes).map(&:to_s)
+          else
+            []
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Has Many Association
   module Associations
     # This is the proxy that handles a has many association.
     #
@@ -109,7 +110,11 @@ module ActiveRecord
           create_scoping = {}
           set_belongs_to_association_for(create_scoping)
           {
-            :find => { :conditions => @finder_sql, :readonly => false, :order => @reflection.options[:order], :limit => @reflection.options[:limit], :include => @reflection.options[:include]},
+            :find => { :conditions => @finder_sql, 
+                       :readonly => false, 
+                       :order => @reflection.options[:order], 
+                       :limit => @reflection.options[:limit], 
+                       :include => @reflection.options[:include]},
             :create => create_scoping
           }
         end

data/lib/active_record/associations/has_many_through_association.rb

@@ -2,6 +2,7 @@ require "active_record/associations/through_association_scope"
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
+  # = Active Record Has Many Through Association
   module Associations
     class HasManyThroughAssociation < HasManyAssociation #:nodoc:
       include ThroughAssociationScope

data/lib/active_record/associations/has_one_association.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Belongs To Has One Association
   module Associations
     class HasOneAssociation < AssociationProxy #:nodoc:
       def initialize(owner, reflection)

data/lib/active_record/associations/has_one_through_association.rb

@@ -1,6 +1,7 @@
 require "active_record/associations/through_association_scope"
 
 module ActiveRecord
+  # = Active Record Has One Through Association
   module Associations
     class HasOneThroughAssociation < HasOneAssociation
       include ThroughAssociationScope

data/lib/active_record/associations/through_association_scope.rb

@@ -1,4 +1,5 @@
 module ActiveRecord
+  # = Active Record Through Association Scope
   module Associations
     module ThroughAssociationScope
 
@@ -34,7 +35,7 @@ module ActiveRecord
               @owner.class.base_class.name.to_s,
               reflection.klass.columns_hash["#{as}_type"]) }
         elsif reflection.macro == :belongs_to
-          { reflection.klass.primary_key => @owner[reflection.primary_key_name] }
+          { reflection.klass.primary_key => @owner.class.quote_value(@owner[reflection.primary_key_name]) }
         else
           { reflection.primary_key_name => owner_quoted_id }
         end
@@ -91,7 +92,7 @@ module ActiveRecord
 
       # Construct attributes for :through pointing to owner and associate.
       def construct_join_attributes(associate)
-        # TODO: revist this to allow it for deletion, supposing dependent option is supported
+        # TODO: revisit this to allow it for deletion, supposing dependent option is supported
         raise ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(@owner, @reflection) if [:has_one, :has_many].include?(@reflection.source_reflection.macro)
 
         join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)

data/lib/active_record/attribute_methods.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/enumerable'
 
 module ActiveRecord
+  # = Active Record Attribute Methods
   module AttributeMethods #:nodoc:
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods

data/lib/active_record/autosave_association.rb

@@ -1,6 +1,8 @@
 require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
+  # = Active Record Autosave Association
+  # 
   # AutosaveAssociation is a module that takes care of automatically saving
   # your associations when the parent is saved. In addition to saving, it
   # also destroys any associations that were marked for destruction.
@@ -145,12 +147,12 @@ module ActiveRecord
       #   add_autosave_association_callbacks(reflect_on_association(name))
       # end
       ASSOCIATION_TYPES.each do |type|
-        module_eval %{
+        module_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{type}(name, options = {})
             super
             add_autosave_association_callbacks(reflect_on_association(name))
           end
-        }
+        CODE
       end
 
       # Adds a validate and save callback for the association as specified by
@@ -375,10 +377,6 @@ module ActiveRecord
           if association.updated?
             association_id = association.send(reflection.options[:primary_key] || :id)
             self[reflection.primary_key_name] = association_id
-            # TODO: Removing this code doesn't seem to matter…
-            if reflection.options[:polymorphic]
-              self[reflection.options[:foreign_type]] = association.class.base_class.name.to_s
-            end
           end
 
           saved if autosave

data/lib/active_record/base.rb

@@ -2,6 +2,7 @@ require 'yaml'
 require 'set'
 require 'active_support/benchmarkable'
 require 'active_support/dependencies'
+require 'active_support/descendants_tracker'
 require 'active_support/time'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/class/attribute_accessors'
@@ -14,12 +15,17 @@ require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/deprecation'
+require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/blank'
 require 'arel'
 require 'active_record/errors'
+require 'active_record/log_subscriber'
 
 module ActiveRecord #:nodoc:
+  # = Active Record
+  #
   # 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
@@ -273,27 +279,17 @@ module ActiveRecord #:nodoc:
     # on to any new database connections made and which can be retrieved on both a class and instance level by calling +logger+.
     cattr_accessor :logger, :instance_writer => false
 
-    def self.inherited(child) #:nodoc:
-      @@subclasses[self] ||= []
-      @@subclasses[self] << child
-      super
-    end
+    class << self
+      def reset_subclasses #:nodoc:
+        ActiveSupport::Deprecation.warn 'ActiveRecord::Base.reset_subclasses no longer does anything in Rails 3. It will be removed in the final release; please update your apps and plugins.', caller
+      end
 
-    def self.reset_subclasses #:nodoc:
-      nonreloadables = []
-      subclasses.each do |klass|
-        unless ActiveSupport::Dependencies.autoloaded? klass
-          nonreloadables << klass
-          next
-        end
-        klass.instance_variables.each { |var| klass.send(:remove_instance_variable, var) }
-        klass.instance_methods(false).each { |m| klass.send :undef_method, m }
+      def subclasses
+        descendants
       end
-      @@subclasses = {}
-      nonreloadables.each { |klass| (@@subclasses[klass.superclass] ||= []) << klass }
-    end
 
-    @@subclasses = {}
+      deprecate :subclasses => :descendants
+    end
 
     ##
     # :singleton-method:
@@ -402,7 +398,7 @@ module ActiveRecord #:nodoc:
 
       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 :select, :group, :order, :reorder, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
       # Executes a custom SQL query against your database and returns all the results.  The results will
@@ -480,112 +476,16 @@ module ActiveRecord #:nodoc:
         connection.select_value(sql, "#{name} Count").to_i
       end
 
-      # Attributes named in this macro are protected from mass-assignment,
-      # such as <tt>new(attributes)</tt>,
-      # <tt>update_attributes(attributes)</tt>, or
-      # <tt>attributes=(attributes)</tt>.
-      #
-      # Mass-assignment to these attributes will simply be ignored, to assign
-      # to them you can use direct writer methods. This is meant to protect
-      # sensitive attributes from being overwritten by malicious users
-      # tampering with URLs or forms.
-      #
-      #   class Customer < ActiveRecord::Base
-      #     attr_protected :credit_rating
-      #   end
-      #
-      #   customer = Customer.new("name" => David, "credit_rating" => "Excellent")
-      #   customer.credit_rating # => nil
-      #   customer.attributes = { "description" => "Jolly fellow", "credit_rating" => "Superb" }
-      #   customer.credit_rating # => nil
-      #
-      #   customer.credit_rating = "Average"
-      #   customer.credit_rating # => "Average"
-      #
-      # To start from an all-closed default and enable attributes as needed,
-      # have a look at +attr_accessible+.
-      #
-      # If the access logic of your application is richer you can use <tt>Hash#except</tt>
-      # or <tt>Hash#slice</tt> to sanitize the hash of parameters before they are
-      # passed to Active Record.
-      #
-      # For example, it could be the case that the list of protected attributes
-      # for a given model depends on the role of the user:
-      #
-      #   # Assumes plan_id is not protected because it depends on the role.
-      #   params[:account] = params[:account].except(:plan_id) unless admin?
-      #   @account.update_attributes(params[:account])
-      #
-      # Note that +attr_protected+ is still applied to the received hash. Thus,
-      # with this technique you can at most _extend_ the list of protected
-      # attributes for a particular mass-assignment call.
-      def attr_protected(*attributes)
-        write_inheritable_attribute(:attr_protected, Set.new(attributes.map {|a| a.to_s}) + (protected_attributes || []))
-      end
-
-      # Returns an array of all the attributes that have been protected from mass-assignment.
-      def protected_attributes # :nodoc:
-        read_inheritable_attribute(:attr_protected)
+      # Attributes listed as readonly can be set for a new record, but will be ignored in database updates afterwards.
+      def attr_readonly(*attributes)
+        write_inheritable_attribute(:attr_readonly, Set.new(attributes.map(&:to_s)) + (readonly_attributes || []))
       end
 
-      # Specifies a white list of model attributes that can be set via
-      # mass-assignment, such as <tt>new(attributes)</tt>,
-      # <tt>update_attributes(attributes)</tt>, or
-      # <tt>attributes=(attributes)</tt>
-      #
-      # This is the opposite of the +attr_protected+ macro: Mass-assignment
-      # will only set attributes in this list, to assign to the rest of
-      # attributes you can use direct writer methods. This is meant to protect
-      # sensitive attributes from being overwritten by malicious users
-      # tampering with URLs or forms. If you'd rather start from an all-open
-      # default and restrict attributes as needed, have a look at
-      # +attr_protected+.
-      #
-      #   class Customer < ActiveRecord::Base
-      #     attr_accessible :name, :nickname
-      #   end
-      #
-      #   customer = Customer.new(:name => "David", :nickname => "Dave", :credit_rating => "Excellent")
-      #   customer.credit_rating # => nil
-      #   customer.attributes = { :name => "Jolly fellow", :credit_rating => "Superb" }
-      #   customer.credit_rating # => nil
-      #
-      #   customer.credit_rating = "Average"
-      #   customer.credit_rating # => "Average"
-      #
-      # If the access logic of your application is richer you can use <tt>Hash#except</tt>
-      # or <tt>Hash#slice</tt> to sanitize the hash of parameters before they are
-      # passed to Active Record.
-      #
-      # For example, it could be the case that the list of accessible attributes
-      # for a given model depends on the role of the user:
-      #
-      #   # Assumes plan_id is accessible because it depends on the role.
-      #   params[:account] = params[:account].except(:plan_id) unless admin?
-      #   @account.update_attributes(params[:account])
-      #
-      # Note that +attr_accessible+ is still applied to the received hash. Thus,
-      # with this technique you can at most _narrow_ the list of accessible
-      # attributes for a particular mass-assignment call.
-      def attr_accessible(*attributes)
-        write_inheritable_attribute(:attr_accessible, Set.new(attributes.map(&:to_s)) + (accessible_attributes || []))
+      # Returns an array of all the attributes that have been specified as readonly.
+      def readonly_attributes
+        read_inheritable_attribute(:attr_readonly) || []
       end
 
-      # Returns an array of all the attributes that have been made accessible to mass-assignment.
-      def accessible_attributes # :nodoc:
-        read_inheritable_attribute(:attr_accessible)
-      end
-
-       # Attributes listed as readonly can be set for a new record, but will be ignored in database updates afterwards.
-       def attr_readonly(*attributes)
-         write_inheritable_attribute(:attr_readonly, Set.new(attributes.map(&:to_s)) + (readonly_attributes || []))
-       end
-
-       # Returns an array of all the attributes that have been specified as readonly.
-       def readonly_attributes
-         read_inheritable_attribute(:attr_readonly) || []
-       end
-
       # If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object,
       # then specify the name of that attribute using this method and it will be handled automatically.
       # The serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that
@@ -647,29 +547,14 @@ module ActiveRecord #:nodoc:
         reset_table_name
       end
 
+      # Returns a quoted version of the table name, used to construct SQL statements.
       def quoted_table_name
         @quoted_table_name ||= connection.quote_table_name(table_name)
       end
 
+      # Computes the table name, (re)sets it internally, and returns it.
       def reset_table_name #:nodoc:
-        base = base_class
-
-        name =
-          # STI subclasses always use their superclass' table.
-          unless self == base
-            base.table_name
-          else
-            # Nested classes are prefixed with singular parent table name.
-            if parent < ActiveRecord::Base && !parent.abstract_class?
-              contained = parent.table_name
-              contained = contained.singularize if parent.pluralize_table_names
-              contained << '_'
-            end
-            name = "#{full_table_name_prefix}#{contained}#{undecorated_table_name(base.name)}#{table_name_suffix}"
-          end
-
-        set_table_name(name)
-        name
+        self.table_name = compute_table_name
       end
 
       def full_table_name_prefix #:nodoc:
@@ -739,14 +624,6 @@ module ActiveRecord #:nodoc:
       end
       alias :sequence_name= :set_sequence_name
 
-      # Turns the +table_name+ back into a class name following the reverse rules of +table_name+.
-      def class_name(table_name = table_name) # :nodoc:
-        # remove any prefix and/or suffix from the table name
-        class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].camelize
-        class_name = class_name.singularize if pluralize_table_names
-        class_name
-      end
-
       # Indicates whether the table associated with this class exists
       def table_exists?
         connection.table_exists?(table_name)
@@ -820,11 +697,11 @@ module ActiveRecord #:nodoc:
       def reset_column_information
         undefine_attribute_methods
         @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = @inheritance_column = nil
-        @arel_engine = @unscoped = @arel_table = nil
+        @arel_engine = @relation = @arel_table = nil
       end
 
       def reset_column_information_and_inheritable_attributes_for_all_subclasses#:nodoc:
-        subclasses.each { |klass| klass.reset_inheritable_attributes; klass.reset_column_information }
+        descendants.each { |klass| klass.reset_inheritable_attributes; klass.reset_column_information }
       end
 
       def attribute_method?(attribute)
@@ -896,6 +773,9 @@ module ActiveRecord #:nodoc:
       # Returns the base AR subclass that this class descends from. If A
       # extends AR::Base, A.base_class will return A. If B descends from A
       # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
       def base_class
         class_of_active_record_descendant(self)
       end
@@ -903,8 +783,7 @@ module ActiveRecord #:nodoc:
       # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
       attr_accessor :abstract_class
 
-      # Returns whether this class is a base AR class.  If A is a base class and
-      # B descends from A, then B.base_class will return B.
+      # Returns whether this class is an abstract class or not.
       def abstract_class?
         defined?(@abstract_class) && @abstract_class == true
       end
@@ -923,11 +802,6 @@ module ActiveRecord #:nodoc:
         store_full_sti_class ? name : name.demodulize
       end
 
-      def unscoped
-        @unscoped ||= Relation.new(self, arel_table)
-        finder_needs_type_condition? ? @unscoped.where(type_condition) : @unscoped
-      end
-
       def arel_table
         @arel_table ||= Arel::Table.new(table_name, :engine => arel_engine)
       end
@@ -942,15 +816,46 @@ module ActiveRecord #:nodoc:
         end
       end
 
+      # Returns a scope for this class without taking into account the default_scope.
+      #
+      #   class Post < ActiveRecord::Base
+      #     default_scope :published => true
+      #   end
+      #
+      #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
+      #   Post.unscoped.all # Fires "SELECT * FROM posts"
+      #
+      # This method also accepts a block meaning that all queries inside the block will
+      # not use the default_scope:
+      #
+      #   Post.unscoped {
+      #     limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+      #   }
+      #
+      def unscoped
+        block_given? ? relation.scoping { yield } : relation
+      end
+
+      def scoped_methods #:nodoc:
+        key = :"#{self}_scoped_methods"
+        Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
+      end
+
       private
+
+        def relation #:nodoc:
+          @relation ||= Relation.new(self, arel_table)
+          finder_needs_type_condition? ? @relation.where(type_condition) : @relation
+        end
+
         # Finder methods must instantiate through this method to work with the
         # single-table inheritance model that makes it possible to create
         # objects of different types from the same table.
         def instantiate(record)
           object = find_sti_class(record[inheritance_column]).allocate
 
-          object.instance_variable_set(:'@attributes', record)
-          object.instance_variable_set(:'@attributes_cache', {})
+          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)
@@ -989,7 +894,7 @@ module ActiveRecord #:nodoc:
         def type_condition
           sti_column = arel_table[inheritance_column]
           condition = sti_column.eq(sti_name)
-          subclasses.each{|subclass| condition = condition.or(sti_column.eq(subclass.sti_name)) }
+          descendants.each { |subclass| condition = condition.or(sti_column.eq(subclass.sti_name)) }
 
           condition
         end
@@ -1001,6 +906,23 @@ module ActiveRecord #:nodoc:
           table_name
         end
 
+        # Computes and returns a table name according to default conventions.
+        def compute_table_name
+          base = base_class
+          if self == base
+            # Nested classes are prefixed with singular parent table name.
+            if parent < ActiveRecord::Base && !parent.abstract_class?
+              contained = parent.table_name
+              contained = contained.singularize if parent.pluralize_table_names
+              contained << '_'
+            end
+            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{table_name_suffix}"
+          else
+            # STI subclasses always use their superclass' table.
+            base.table_name
+          end
+        end
+
         # Enables dynamic finders like <tt>find_by_user_name(user_name)</tt> and <tt>find_by_user_name_and_password(user_name, password)</tt>
         # that are turned into <tt>where(:user_name => user_name).first</tt> and <tt>where(:user_name => user_name, :password => :password).first</tt>
         # respectively. Also works for <tt>all</tt> by using <tt>find_all_by_amount(50)</tt> that is turned into <tt>where(:amount => 50).all</tt>.
@@ -1068,19 +990,6 @@ module ActiveRecord #:nodoc:
           attribute_names.all? { |name| column_methods_hash.include?(name.to_sym) }
         end
 
-        def attribute_condition(quoted_column_name, argument)
-          case argument
-            when nil   then "#{quoted_column_name} IS ?"
-            when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope then "#{quoted_column_name} IN (?)"
-            when Range then if argument.exclude_end?
-                              "#{quoted_column_name} >= ? AND #{quoted_column_name} < ?"
-                            else
-                              "#{quoted_column_name} BETWEEN ? AND ?"
-                            end
-            else            "#{quoted_column_name} = ?"
-          end
-        end
-
       protected
         # Scope parameters to method calls within the block.  Takes a hash of method_name => parameters hash.
         # method_name may be <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
@@ -1121,7 +1030,7 @@ module ActiveRecord #:nodoc:
         #   class Article < ActiveRecord::Base
         #     def self.find_with_exclusive_scope
         #       with_scope(:find => where(:blog_id => 1).limit(1)) do
-        #         with_exclusive_scope(:find => limit(10))
+        #         with_exclusive_scope(:find => limit(10)) do
         #           all # => SELECT * from articles LIMIT 10
         #         end
         #       end
@@ -1172,16 +1081,22 @@ module ActiveRecord #:nodoc:
 
         # Works like with_scope, but discards any nested properties.
         def with_exclusive_scope(method_scoping = {}, &block)
-          with_scope(method_scoping, :overwrite, &block)
-        end
+          if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
+            raise ArgumentError, <<-MSG
+New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
 
-        # Returns a list of all subclasses of this class, meaning all descendants.
-        def subclasses
-          @@subclasses[self] ||= []
-          @@subclasses[self] + @@subclasses[self].inject([]) {|list, subclass| list + subclass.subclasses }
-        end
+  User.unscoped.where(:active => true)
 
-        public :subclasses
+Or call unscoped with a block:
+
+  User.unscoped do
+    User.where(:active => true).all
+  end
+
+MSG
+          end
+          with_scope(method_scoping, :overwrite, &block)
+        end
 
         # Sets the default options for the model. The format of the
         # <tt>options</tt> argument is the same as in find.
@@ -1193,11 +1108,6 @@ module ActiveRecord #:nodoc:
           self.default_scoping << construct_finder_arel(options, default_scoping.pop)
         end
 
-        def scoped_methods #:nodoc:
-          key = :"#{self}_scoped_methods"
-          Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
-        end
-
         def current_scoped_methods #:nodoc:
           scoped_methods.last
         end
@@ -1242,11 +1152,6 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        # Returns the name of the class descending directly from Active Record in the inheritance hierarchy.
-        def class_name_of_active_record_descendant(klass) #:nodoc:
-          klass.base_class.name
-        end
-
         # Accepts an array, hash, or string of SQL conditions and sanitizes
         # them into a valid SQL fragment for a WHERE clause.
         #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
@@ -1350,6 +1255,8 @@ module ActiveRecord #:nodoc:
             replace_named_bind_variables(statement, values.first)
           elsif statement.include?('?')
             replace_bind_variables(statement, values)
+          elsif statement.blank?
+            statement
           else
             statement % values.collect { |value| connection.quote_string(value.to_s) }
           end
@@ -1450,14 +1357,6 @@ module ActiveRecord #:nodoc:
       # as it copies the object's attributes only, not its associations. The extent of a "deep" clone is
       # application specific and is therefore left to the application to implement according to its need.
       def initialize_copy(other)
-        # Think the assertion which fails if the after_initialize callback goes at the end of the method is wrong. The
-        # deleted clone method called new which therefore called the after_initialize callback. It then went on to copy
-        # over the attributes. But if it's copying the attributes afterwards then it hasn't finished initializing right?
-        # For example in the test suite the topic model's after_initialize method sets the author_email_address to
-        # test@test.com. I would have thought this would mean that all cloned models would have an author email address
-        # of test@test.com. However the test_clone test method seems to test that this is not the case. As a result the
-        # after_initialize callback has to be run *before* the copying of the atrributes rather than afterwards in order
-        # for all tests to pass. This makes no sense to me.
         callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
         cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
         cloned_attributes.delete(self.class.primary_key)
@@ -1470,6 +1369,7 @@ module ActiveRecord #:nodoc:
         end
 
         clear_aggregation_cache
+        clear_association_cache
         @attributes_cache = {}
         @new_record = true
         ensure_proper_type
@@ -1573,11 +1473,11 @@ module ActiveRecord #:nodoc:
       #   user.send(:attributes=, { :username => 'Phusion', :is_admin => true }, false)
       #   user.is_admin?  # => true
       def attributes=(new_attributes, guard_protected_attributes = true)
-        return if new_attributes.nil?
+        return unless new_attributes.is_a?(Hash)
         attributes = new_attributes.stringify_keys
 
         multi_parameter_attributes = []
-        attributes = remove_attributes_protected_from_mass_assignment(attributes) if guard_protected_attributes
+        attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
 
         attributes.each do |k, v|
           if k.include?("(")
@@ -1717,46 +1617,10 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      def remove_attributes_protected_from_mass_assignment(attributes)
-        safe_attributes =
-          if self.class.accessible_attributes.nil? && self.class.protected_attributes.nil?
-            attributes.reject { |key, value| attributes_protected_by_default.include?(key.gsub(/\(.+/, "")) }
-          elsif self.class.protected_attributes.nil?
-            attributes.reject { |key, value| !self.class.accessible_attributes.include?(key.gsub(/\(.+/, "")) || attributes_protected_by_default.include?(key.gsub(/\(.+/, "")) }
-          elsif self.class.accessible_attributes.nil?
-            attributes.reject { |key, value| self.class.protected_attributes.include?(key.gsub(/\(.+/,"")) || attributes_protected_by_default.include?(key.gsub(/\(.+/, "")) }
-          else
-            raise "Declare either attr_protected or attr_accessible for #{self.class}, but not both."
-          end
-
-        removed_attributes = attributes.keys - safe_attributes.keys
-
-        if removed_attributes.any?
-          log_protected_attribute_removal(removed_attributes)
-        end
-
-        safe_attributes
-      end
-
-      # Removes attributes which have been marked as readonly.
-      def remove_readonly_attributes(attributes)
-        unless self.class.readonly_attributes.nil?
-          attributes.delete_if { |key, value| self.class.readonly_attributes.include?(key.gsub(/\(.+/,"")) }
-        else
-          attributes
-        end
-      end
-
-      def log_protected_attribute_removal(*attributes)
-        if logger
-          logger.debug "WARNING: Can't mass-assign these protected attributes: #{attributes.join(', ')}"
-        end
-      end
-
       # The primary key and inheritance column can never be set by mass-assignment for security reasons.
-      def attributes_protected_by_default
-        default = [ self.class.primary_key, self.class.inheritance_column ]
-        default << 'id' unless self.class.primary_key.eql? 'id'
+      def self.attributes_protected_by_default
+        default = [ primary_key, inheritance_column ]
+        default << 'id' unless primary_key.eql? 'id'
         default
       end
 
@@ -1910,6 +1774,7 @@ module ActiveRecord #:nodoc:
     extend ActiveModel::Naming
     extend QueryCache::ClassMethods
     extend ActiveSupport::Benchmarkable
+    extend ActiveSupport::DescendantsTracker
 
     include ActiveModel::Conversion
     include Validations
@@ -1920,6 +1785,7 @@ module ActiveRecord #:nodoc:
     include AttributeMethods::PrimaryKey
     include AttributeMethods::TimeZoneConversion
     include AttributeMethods::Dirty
+    include ActiveModel::MassAssignmentSecurity
     include Callbacks, ActiveModel::Observing, Timestamp
     include Associations, AssociationPreload, NamedScope