activerecord 3.1.12 → 3.2.22.1

data/README.rdoc

@@ -197,13 +197,13 @@ Admit the Database:
 
 == Download and installation
 
-The latest version of Active Record can be installed with Rubygems:
+The latest version of Active Record can be installed with RubyGems:
 
   % [sudo] gem install activerecord
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/3-2-stable/activerecord
 
 
 == License
@@ -215,7 +215,7 @@ Active Record is released under the MIT license.
 
 API documentation is at
 
-* http://api.rubyonrails.com
+* http://api.rubyonrails.org
 
 Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
 

data/examples/performance.rb

@@ -31,6 +31,14 @@ class Exhibit < ActiveRecord::Base
   def look; attributes end
   def feel; look; user.name end
 
+  def self.with_name
+    where("name IS NOT NULL")
+  end
+
+  def self.with_notes
+    where("notes IS NOT NULL")
+  end
+
   def self.look(exhibits) exhibits.each { |e| e.look } end
   def self.feel(exhibits) exhibits.each { |e| e.feel } end
 end
@@ -39,7 +47,14 @@ puts 'Generating data...'
 
 module ActiveRecord
   class Faker
-    LOREM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit. Integer consequat tincidunt felis. Etiam non erat dolor. Vivamus imperdiet nibh sit amet diam eleifend id posuere diam malesuada. Mauris at accumsan sem. Donec id lorem neque. Fusce erat lorem, ornare eu congue vitae, malesuada quis neque. Maecenas vel urna a velit pretium fermentum. Donec tortor enim, tempor venenatis egestas a, tempor sed ipsum. Ut arcu justo, faucibus non imperdiet ac, interdum at diam. Pellentesque ipsum enim, venenatis ut iaculis vitae, varius vitae sem. Sed rutrum quam ac elit euismod bibendum. Donec ultricies ultricies magna, at lacinia libero mollis aliquam. Sed ac arcu in tortor elementum tincidunt vel interdum sem. Curabitur eget erat arcu. Praesent eget eros leo. Nam magna enim, sollicitudin vehicula scelerisque in, vulputate ut libero. Praesent varius tincidunt commodo".split
+    LOREM = %Q{Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit.
+     Integer consequat tincidunt felis. Etiam non erat dolor. Vivamus imperdiet nibh sit amet diam eleifend id posuere diam malesuada. Mauris at accumsan sem.
+     Donec id lorem neque. Fusce erat lorem, ornare eu congue vitae, malesuada quis neque. Maecenas vel urna a velit pretium fermentum. Donec tortor enim,
+     tempor venenatis egestas a, tempor sed ipsum. Ut arcu justo, faucibus non imperdiet ac, interdum at diam. Pellentesque ipsum enim, venenatis ut iaculis vitae,
+     varius vitae sem. Sed rutrum quam ac elit euismod bibendum. Donec ultricies ultricies magna, at lacinia libero mollis aliquam. Sed ac arcu in tortor elementum
+     tincidunt vel interdum sem. Curabitur eget erat arcu. Praesent eget eros leo. Nam magna enim, sollicitudin vehicula scelerisque in, vulputate ut libero.
+     Praesent varius tincidunt commodo}.split
+
     def self.name
       LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join ' '
     end
@@ -114,6 +129,10 @@ Benchmark.ips(TIME) do |x|
     Exhibit.look Exhibit.limit(10000)
   end
 
+  x.report 'Model.named_scope' do
+    Exhibit.limit(10).with_name.with_notes
+  end
+
   x.report 'Model.create' do
     Exhibit.create(exhibit)
   end

data/lib/active_record/aggregations.rb

@@ -176,7 +176,7 @@ module ActiveRecord
       #   order in which mappings are defined determines the order in which attributes are sent to the
       #   value class constructor.
       # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
-      #   attributes are +nil+.  Setting the value object to +nil+ has the effect of writing +nil+ to all
+      #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
       #   mapped attributes.
       #   This defaults to +false+.
       # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that

data/lib/active_record/associations/alias_tracker.rb

@@ -5,12 +5,13 @@ module ActiveRecord
     # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
     # ActiveRecord::Associations::ThroughAssociationScope
     class AliasTracker # :nodoc:
-      attr_reader :aliases, :table_joins
+      attr_reader :aliases, :table_joins, :connection
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(table_joins = [])
+      def initialize(connection = ActiveRecord::Model.connection, table_joins = [])
         @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
         @table_joins = table_joins
+        @connection  = connection
       end
 
       def aliased_table_for(table_name, aliased_name = nil)
@@ -70,10 +71,6 @@ module ActiveRecord
         def truncate(name)
           name.slice(0, connection.table_alias_length - 2)
         end
-
-        def connection
-          ActiveRecord::Base.connection
-        end
     end
   end
 end

data/lib/active_record/associations/association.rb

@@ -1,6 +1,5 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/inclusion'
-require 'active_support/deprecation'
 
 module ActiveRecord
   module Associations
@@ -47,6 +46,7 @@ module ActiveRecord
         @loaded = false
         IdentityMap.remove(target) if IdentityMap.enabled? && target
         @target = nil
+        @stale_state = nil
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -129,16 +129,21 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on +find_target+,
       # which is expected to be provided by descendants.
       #
-      # If the \target is already \loaded it is just returned. Thus, you can call
-      # +load_target+ unconditionally to get the \target.
+      # If the \target is stale(the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to.), force reload the \target.
+      #
+      # Otherwise if the \target is already \loaded it is just returned. Thus, you can
+      # call +load_target+ unconditionally to get the \target.
       #
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        if find_target?
+        if (@stale_state && stale_target?) || find_target?
           begin
             if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
               @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
+            elsif @stale_state && stale_target?
+              @target = find_target
             end
           rescue NameError
             nil
@@ -231,48 +236,11 @@ module ActiveRecord
         end
 
         def build_record(attributes, options)
-          reflection.original_build_association_called = false
-
-          record = reflection.build_association(attributes, options) do |r|
-            r.assign_attributes(
-              create_scope.except(*r.changed),
-              :without_protection => true
-            )
+          reflection.build_association(attributes, options) do |record|
+            skip_assign = [reflection.foreign_key, reflection.type].compact
+            attributes = create_scope.except(*(record.changed - skip_assign))
+            record.assign_attributes(attributes, :without_protection => true)
           end
-
-          if !reflection.original_build_association_called &&
-             (record.changed & create_scope.keys) != create_scope.keys
-            # We have detected that there is an overridden AssociationReflection#build_association
-            # method, but it looks like it has not passed through the block above. So try again and
-            # show a noisy deprecation warning.
-
-            record.assign_attributes(
-              create_scope.except(*record.changed),
-              :without_protection => true
-            )
-
-            method = reflection.method(:build_association)
-            if RUBY_VERSION >= '1.9.2'
-              source = method.source_location
-              debug_info = "It looks like the method is defined in #{source[0]} at line #{source[1]}."
-            else
-              debug_info = "This might help you find the method: #{method}. If you run this on Ruby 1.9.2 we can tell you exactly where the method is."
-            end
-
-            ActiveSupport::Deprecation.warn <<-WARN
-It looks like ActiveRecord::Reflection::AssociationReflection#build_association has been redefined, either by you or by a plugin or library that you are using. The signature of this method has changed.
-
-  Before: def build_association(*options)
-  After:  def build_association(*options, &block)
-
-The block argument now needs to be passed through to ActiveRecord::Base#new when this method is overridden, or else your associations will not function correctly in Rails 3.2.
-
-#{debug_info}
-
-            WARN
-          end
-
-          record
         end
     end
   end

data/lib/active_record/associations/association_scope.rb

@@ -10,7 +10,7 @@ module ActiveRecord
 
       def initialize(association)
         @association   = association
-        @alias_tracker = AliasTracker.new
+        @alias_tracker = AliasTracker.new klass.connection
       end
 
       def scope
@@ -20,31 +20,19 @@ module ActiveRecord
         # It's okay to just apply all these like this. The options will only be present if the
         # association supports that option; this is enforced by the association builder.
         scope = scope.apply_finder_options(options.slice(
-          :readonly, :include, :order, :limit, :joins, :group, :having, :offset))
+          :readonly, :include, :order, :limit, :joins, :group, :having, :offset, :select))
 
         if options[:through] && !options[:include]
           scope = scope.includes(source_options[:include])
         end
 
-        if select = select_value
-          scope = scope.select(select)
-        end
+        scope = scope.uniq if options[:uniq]
 
         add_constraints(scope)
       end
 
       private
 
-      def select_value
-        select_value = options[:select]
-
-        if reflection.collection?
-          select_value ||= options[:uniq] && "DISTINCT #{reflection.quoted_table_name}.*"
-        end
-
-        select_value
-      end
-
       def add_constraints(scope)
         tables = construct_tables
 

data/lib/active_record/associations/belongs_to_association.rb

@@ -72,7 +72,7 @@ module ActiveRecord
         end
 
         def stale_state
-          owner[reflection.foreign_key].to_s
+          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -27,7 +27,8 @@ module ActiveRecord
         end
 
         def stale_state
-          [super, owner[reflection.foreign_type].to_s]
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
         end
     end
   end

data/lib/active_record/associations/builder/association.rb

@@ -16,6 +16,10 @@ module ActiveRecord::Associations::Builder
       @model, @name, @options = model, name, options
     end
 
+    def mixin
+      @model.generated_feature_methods
+    end
+
     def build
       validate_options
       reflection = model.create_reflection(self.class.macro, name, options, model)
@@ -36,16 +40,14 @@ module ActiveRecord::Associations::Builder
 
       def define_readers
         name = self.name
-
-        model.redefine_method(name) do |*params|
+        mixin.redefine_method(name) do |*params|
           association(name).reader(*params)
         end
       end
 
       def define_writers
         name = self.name
-
-        model.redefine_method("#{name}=") do |value|
+        mixin.redefine_method("#{name}=") do |value|
           association(name).writer(value)
         end
       end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -25,16 +25,19 @@ module ActiveRecord::Associations::Builder
         name         = self.name
 
         method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
           record.class.increment_counter(cache_column, record.id) unless record.nil?
         end
         model.after_create(method_name)
 
         method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
-          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+
+          if record && !self.destroyed?
+            record.class.decrement_counter(cache_column, record.id)
+          end
         end
         model.before_destroy(method_name)
 
@@ -48,7 +51,7 @@ module ActiveRecord::Associations::Builder
         method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
         touch       = options[:touch]
 
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
 
           unless record.nil?

data/lib/active_record/associations/builder/collection_association.rb

@@ -58,7 +58,7 @@ module ActiveRecord::Associations::Builder
         super
 
         name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids") do
+        mixin.redefine_method("#{name.to_s.singularize}_ids") do
           association(name).ids_reader
         end
       end
@@ -67,7 +67,7 @@ module ActiveRecord::Associations::Builder
         super
 
         name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
           association(name).ids_writer(ids)
         end
       end

data/lib/active_record/associations/builder/has_many.rb

@@ -28,7 +28,7 @@ module ActiveRecord::Associations::Builder
 
       def define_destroy_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           send(name).each do |o|
             # No point in executing the counter update since we're going to destroy the parent anyway
             counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
@@ -45,21 +45,21 @@ module ActiveRecord::Associations::Builder
 
       def define_delete_all_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           association(name).delete_all_on_destroy
         end
       end
 
       def define_nullify_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           send(name).delete_all
         end
       end
 
       def define_restrict_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
         end
       end

data/lib/active_record/associations/builder/has_one.rb

@@ -44,18 +44,17 @@ module ActiveRecord::Associations::Builder
       end
 
       def define_destroy_dependency_method
-        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-          def #{dependency_method_name}
-            association(#{name.to_sym.inspect}).delete
-          end
-        eoruby
+        name = self.name
+        mixin.redefine_method(dependency_method_name) do
+          association(name).delete
+        end
       end
       alias :define_delete_dependency_method :define_destroy_dependency_method
       alias :define_nullify_dependency_method :define_destroy_dependency_method
 
       def define_restrict_dependency_method
         name = self.name
-        model.redefine_method(dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
         end
       end

data/lib/active_record/associations/builder/singular_association.rb

@@ -13,31 +13,18 @@ module ActiveRecord::Associations::Builder
 
     private
 
-      def define_readers
-        super
-        name = self.name
-
-        model.redefine_method("#{name}_loaded?") do
-          ActiveSupport::Deprecation.warn(
-            "Calling obj.#{name}_loaded? is deprecated. Please use " \
-            "obj.association(:#{name}).loaded? instead."
-          )
-          association(name).loaded?
-        end
-      end
-
       def define_constructors
         name = self.name
 
-        model.redefine_method("build_#{name}") do |*params, &block|
+        mixin.redefine_method("build_#{name}") do |*params, &block|
           association(name).build(*params, &block)
         end
 
-        model.redefine_method("create_#{name}") do |*params, &block|
+        mixin.redefine_method("create_#{name}") do |*params, &block|
           association(name).create(*params, &block)
         end
 
-        model.redefine_method("create_#{name}!") do |*params, &block|
+        mixin.redefine_method("create_#{name}!") do |*params, &block|
           association(name).create!(*params, &block)
         end
       end

data/lib/active_record/associations/collection_association.rb

@@ -43,16 +43,24 @@ module ActiveRecord
 
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
-        if loaded? || options[:finder_sql]
+        if owner.new_record? || loaded? || options[:finder_sql]
           load_target.map do |record|
             record.send(reflection.association_primary_key)
           end
         else
           column  = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+          relation = scoped
 
-          scoped.select(column).except(:includes).map! do |record|
-            record.send(reflection.association_primary_key)
+          including = (relation.eager_load_values + relation.includes_values).uniq
+
+          if including.any?
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(reflection.klass, including, [])
+            relation = join_dependency.join_associations.inject(relation) do |r, association|
+              association.join_relation(r)
+            end
           end
+
+          relation.pluck(column)
         end
       end
 
@@ -115,22 +123,16 @@ module ActiveRecord
         create_record(attributes, options, true, &block)
       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 concat(*records)
-        result = true
         load_target if owner.new_record?
 
-        transaction do
-          records.flatten.each do |record|
-            raise_on_type_mismatch(record)
-            add_to_target(record) do |r|
-              result &&= insert_record(record) unless owner.new_record?
-            end
-          end
+        if owner.new_record?
+          concat_records(records)
+        else
+          transaction { concat_records(records) }
         end
-
-        result && records
       end
 
       # Starts a transaction in the association class's database connection.
@@ -188,6 +190,8 @@ module ActiveRecord
       # association, it will be used for the query. Otherwise, construct options and pass them with
       # scope to the target class's +count+.
       def count(column_name = nil, count_options = {})
+        return 0 if owner.new_record?
+
         column_name, count_options = nil, column_name if column_name.is_a?(Hash)
 
         if options[:counter_sql] || options[:finder_sql]
@@ -248,7 +252,7 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on
       # +count_records+, which is a method descendants have to provide.
       def size
-        if owner.new_record? || (loaded? && !options[:uniq])
+        if !find_target? || (loaded? && !options[:uniq])
           target.size
         elsif !loaded? && options[:group]
           load_target.size
@@ -306,14 +310,10 @@ module ActiveRecord
         other_array.each { |val| raise_on_type_mismatch(val) }
         original_target = load_target.dup
 
-        transaction do
-          delete(target - other_array)
-
-          unless concat(other_array - target)
-            @target = original_target
-            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
-                                  "new records could not be saved."
-          end
+        if owner.new_record?
+          replace_records(other_array, original_target)
+        else
+          transaction { replace_records(other_array, original_target) }
         end
       end
 
@@ -364,7 +364,7 @@ module ActiveRecord
             # replace the SELECT clause with COUNT(SELECTS), preserving any hints within /* ... */
             interpolate(options[:finder_sql]).sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) do
               count_with = $2.to_s
-              count_with = '*' if count_with.blank? || count_with =~ /,/
+              count_with = '*' if count_with.blank? || count_with =~ /,/ || count_with =~ /\.\*/
               "SELECT #{$1}COUNT(#{count_with}) FROM"
             end
           end
@@ -409,7 +409,7 @@ module ActiveRecord
             if mem_index
               mem_record = memory.delete_at(mem_index)
 
-              (record.attribute_names - mem_record.changes.keys).each do |name|
+              ((record.attribute_names & mem_record.attribute_names) - mem_record.changes.keys).each do |name|
                 mem_record[name] = record[name]
               end
 
@@ -453,14 +453,20 @@ module ActiveRecord
           records.each { |record| raise_on_type_mismatch(record) }
           existing_records = records.reject { |r| r.new_record? }
 
-          transaction do
-            records.each { |record| callback(:before_remove, record) }
+          if existing_records.empty?
+            remove_records(existing_records, records, method)
+          else
+            transaction { remove_records(existing_records, records, method) }
+          end
+        end
 
-            delete_records(existing_records, method) if existing_records.any?
-            records.each { |record| target.delete(record) }
+        def remove_records(existing_records, records, method)
+          records.each { |record| callback(:before_remove, record) }
 
-            records.each { |record| callback(:after_remove, record) }
-          end
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
+
+          records.each { |record| callback(:after_remove, record) }
         end
 
         # Delete the given records from the association, using one of the methods :destroy,
@@ -469,6 +475,31 @@ module ActiveRecord
           raise NotImplementedError
         end
 
+        def replace_records(new_target, original_target)
+          delete(target - new_target)
+
+          unless concat(new_target - target)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
+
+          target
+        end
+
+        def concat_records(records)
+          result = true
+
+          records.flatten.each do |record|
+            raise_on_type_mismatch(record)
+            add_to_target(record) do |r|
+              result &&= insert_record(record) unless owner.new_record?
+            end
+          end
+
+          result && records
+        end
+
         def callback(method, record)
           callbacks_for(method).each do |callback|
             case callback
@@ -540,7 +571,9 @@ module ActiveRecord
           args.shift if args.first.is_a?(Hash) && args.first.empty?
 
           collection = fetch_first_or_last_using_find?(args) ? scoped : load_target
-          collection.send(type, *args)
+          collection.send(type, *args).tap do |record|
+            set_inverse_instance record if record.is_a? ActiveRecord::Base
+          end
         end
     end
   end