activerecord 3.1.11 → 3.2.0

data/README.rdoc

@@ -197,7 +197,7 @@ 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
 
@@ -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

@@ -1,9 +1,7 @@
+TIMES = (ENV['N'] || 10000).to_i
+
 require File.expand_path('../../../load_paths', __FILE__)
 require "active_record"
-require 'benchmark/ips'
-
-TIME    = (ENV['BENCHMARK_TIME'] || 20).to_i
-RECORDS = (ENV['BENCHMARK_RECORDS'] || TIME*1000).to_i
 
 conn = { :adapter => 'sqlite3', :database => ':memory:' }
 
@@ -31,6 +29,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 +45,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
@@ -59,8 +72,8 @@ end
 notes = ActiveRecord::Faker::LOREM.join ' '
 today = Date.today
 
-puts "Inserting #{RECORDS} users and exhibits..."
-RECORDS.times do
+puts 'Inserting 10,000 users and exhibits...'
+10_000.times do
   user = User.create(
     :created_at => today,
     :name       => ActiveRecord::Faker.name,
@@ -75,7 +88,9 @@ RECORDS.times do
   )
 end
 
-Benchmark.ips(TIME) do |x|
+require 'benchmark'
+
+Benchmark.bm(46) do |x|
   ar_obj       = Exhibit.find(1)
   attrs        = { :name => 'sam' }
   attrs_first  = { :name => 'sam' }
@@ -86,68 +101,77 @@ Benchmark.ips(TIME) do |x|
     :created_at => Date.today
   }
 
-  x.report("Model#id") do
-    ar_obj.id
+  x.report("Model#id (x#{(TIMES * 100).ceil})") do
+    (TIMES * 100).ceil.times { ar_obj.id }
   end
 
   x.report 'Model.new (instantiation)' do
-    Exhibit.new
+    TIMES.times { Exhibit.new }
   end
 
   x.report 'Model.new (setting attributes)' do
-    Exhibit.new(attrs)
+    TIMES.times { Exhibit.new(attrs) }
   end
 
   x.report 'Model.first' do
-    Exhibit.first.look
+    TIMES.times { Exhibit.first.look }
+  end
+
+  x.report 'Model.named_scope' do
+    TIMES.times { Exhibit.limit(10).with_name.with_notes }
   end
 
-  x.report("Model.all limit(100)") do
-    Exhibit.look Exhibit.limit(100)
+  x.report("Model.all limit(100) (x#{(TIMES / 10).ceil})") do
+    (TIMES / 10).ceil.times { Exhibit.look Exhibit.limit(100) }
   end
 
-  x.report "Model.all limit(100) with relationship" do
-    Exhibit.feel Exhibit.limit(100).includes(:user)
+  x.report "Model.all limit(100) with relationship (x#{(TIMES / 10).ceil})" do
+    (TIMES / 10).ceil.times { Exhibit.feel Exhibit.limit(100).includes(:user) }
   end
 
-  x.report "Model.all limit(10,000)" do
-    Exhibit.look Exhibit.limit(10000)
+  x.report "Model.all limit(10,000) x(#{(TIMES / 1000).ceil})" do
+    (TIMES / 1000).ceil.times { Exhibit.look Exhibit.limit(10000) }
   end
 
   x.report 'Model.create' do
-    Exhibit.create(exhibit)
+    TIMES.times { Exhibit.create(exhibit) }
   end
 
   x.report 'Resource#attributes=' do
-    e = Exhibit.new(attrs_first)
-    e.attributes = attrs_second
+    TIMES.times {
+      exhibit = Exhibit.new(attrs_first)
+      exhibit.attributes = attrs_second
+    }
   end
 
   x.report 'Resource#update' do
-    Exhibit.first.update_attributes(:name => 'bob')
+    TIMES.times { Exhibit.first.update_attributes(:name => 'bob') }
   end
 
   x.report 'Resource#destroy' do
-    Exhibit.first.destroy
+    TIMES.times { Exhibit.first.destroy }
   end
 
   x.report 'Model.transaction' do
-    Exhibit.transaction { Exhibit.new }
+    TIMES.times { Exhibit.transaction { Exhibit.new } }
   end
 
   x.report 'Model.find(id)' do
-    User.find(1)
+    id = Exhibit.first.id
+    TIMES.times { Exhibit.find(id) }
   end
 
   x.report 'Model.find_by_sql' do
-    Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
+    TIMES.times {
+      Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
+    }
   end
 
-  x.report "Model.log" do
-    Exhibit.connection.send(:log, "hello", "world") {}
+  x.report "Model.log x(#{TIMES * 10})" do
+    (TIMES * 10).times { Exhibit.connection.send(:log, "hello", "world") {} }
   end
 
-  x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}")
+  x.report "AR.execute(query) (#{TIMES / 2})" do
+    (TIMES / 2).times { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
   end
 end

data/lib/active_record/aggregations.rb

@@ -46,7 +46,7 @@ module ActiveRecord
     #
     #    def <=>(other_money)
     #      if currency == other_money.currency
-    #        amount <=> other_money.amount
+    #        amount <=> amount
     #      else
     #        amount <=> other_money.exchange_to(currency).amount
     #      end
@@ -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/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
@@ -231,48 +230,9 @@ 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
-            )
-          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
+          reflection.build_association(attributes, options) do |record|
+            record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
           end
-
-          record
         end
     end
   end

data/lib/active_record/associations/association_scope.rb

@@ -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
 
@@ -87,7 +75,7 @@ module ActiveRecord
 
             conditions.each do |condition|
               if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
+                condition = { table.name => condition }
               end
 
               scope = scope.where(interpolate(condition))
@@ -126,21 +114,6 @@ module ActiveRecord
         end
       end
 
-      def disambiguate_condition(table, condition)
-        if condition.is_a?(Hash)
-          Hash[
-            condition.map do |k, v|
-              if v.is_a?(Hash)
-                [k, v]
-              else
-                [table.table_alias || table.name, { k => v }]
-              end
-            end
-          ]
-        else
-          condition
-        end
-      end
     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,14 +25,14 @@ 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?
         end
@@ -48,7 +48,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

@@ -49,10 +49,18 @@ module ActiveRecord
           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.uniq.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.
@@ -248,7 +250,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 +308,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
 
@@ -453,14 +451,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
+
+        def remove_records(existing_records, records, method)
+          records.each { |record| callback(:before_remove, record) }
 
-            delete_records(existing_records, method) if existing_records.any?
-            records.each { |record| target.delete(record) }
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
 
-            records.each { |record| callback(:after_remove, record) }
-          end
+          records.each { |record| callback(:after_remove, record) }
         end
 
         # Delete the given records from the association, using one of the methods :destroy,
@@ -469,6 +473,29 @@ 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
+        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