activerecord 4.0.4 → 4.1.16

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2013 David Heinemeier Hansson
+Copyright (c) 2004-2014 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -175,7 +175,7 @@ by relying on a number of conventions that make it easy for Active Record to inf
 complex relations and structures from a minimal amount of explicit direction.
 
 Convention over Configuration:
-* No XML-files!
+* No XML files!
 * Lots of reflection and run-time extension
 * Magic is not inherently a bad word
 
@@ -192,7 +192,7 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/4-0-stable/activerecord
+* https://github.com/rails/rails/tree/4-1-stable/activerecord
 
 
 == License

data/examples/performance.rb

@@ -5,12 +5,12 @@ require 'benchmark/ips'
 TIME    = (ENV['BENCHMARK_TIME'] || 20).to_i
 RECORDS = (ENV['BENCHMARK_RECORDS'] || TIME*1000).to_i
 
-conn = { :adapter => 'sqlite3', :database => ':memory:' }
+conn = { adapter: 'sqlite3', database: ':memory:' }
 
 ActiveRecord::Base.establish_connection(conn)
 
 class User < ActiveRecord::Base
-  connection.create_table :users, :force => true do |t|
+  connection.create_table :users, force: true do |t|
     t.string :name, :email
     t.timestamps
   end
@@ -19,7 +19,7 @@ class User < ActiveRecord::Base
 end
 
 class Exhibit < ActiveRecord::Base
-  connection.create_table :exhibits, :force => true do |t|
+  connection.create_table :exhibits, force: true do |t|
     t.belongs_to :user
     t.string :name
     t.text :notes
@@ -43,6 +43,8 @@ class Exhibit < ActiveRecord::Base
   def self.feel(exhibits) exhibits.each { |e| e.feel } end
 end
 
+def progress_bar(int); print "." if (int%100).zero? ; end
+
 puts 'Generating data...'
 
 module ActiveRecord
@@ -75,30 +77,32 @@ notes = ActiveRecord::Faker::LOREM.join ' '
 today = Date.today
 
 puts "Inserting #{RECORDS} users and exhibits..."
-RECORDS.times do
+RECORDS.times do |record|
   user = User.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :email      => ActiveRecord::Faker.email
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    email: ActiveRecord::Faker.email
   )
 
   Exhibit.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :user       => user,
-    :notes      => notes
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    user: user,
+    notes: notes
   )
+  progress_bar(record)
 end
+puts "Done!\n"
 
 Benchmark.ips(TIME) do |x|
   ar_obj       = Exhibit.find(1)
-  attrs        = { :name => 'sam' }
-  attrs_first  = { :name => 'sam' }
-  attrs_second = { :name => 'tom' }
+  attrs        = { name: 'sam' }
+  attrs_first  = { name: 'sam' }
+  attrs_second = { name: 'tom' }
   exhibit      = {
-    :name       => ActiveRecord::Faker.name,
-    :notes      => notes,
-    :created_at => Date.today
+    name: ActiveRecord::Faker.name,
+    notes: notes,
+    created_at: Date.today
   }
 
   x.report("Model#id") do
@@ -117,10 +121,18 @@ Benchmark.ips(TIME) do |x|
     Exhibit.first.look
   end
 
+  x.report 'Model.take' do 
+    Exhibit.take
+  end
+  
   x.report("Model.all limit(100)") do
     Exhibit.look Exhibit.limit(100)
   end
 
+  x.report("Model.all take(100)") do
+    Exhibit.look Exhibit.take(100)
+  end
+
   x.report "Model.all limit(100) with relationship" do
     Exhibit.feel Exhibit.limit(100).includes(:user)
   end
@@ -167,6 +179,6 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}")
+    ActiveRecord::Base.connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
   end
 end

data/examples/simple.rb

@@ -1,14 +1,14 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require File.expand_path('../../../load_paths', __FILE__)
 require 'active_record'
 
 class Person < ActiveRecord::Base
-  establish_connection :adapter => 'sqlite3', :database => 'foobar.db'
-  connection.create_table table_name, :force => true do |t|
+  establish_connection adapter: 'sqlite3', database: 'foobar.db'
+  connection.create_table table_name, force: true do |t|
     t.string :name
   end
 end
 
-bob = Person.create!(:name => 'bob')
+bob = Person.create!(name: 'bob')
 puts Person.all.inspect
 bob.destroy
 puts Person.all.inspect

data/lib/active_record/aggregations.rb

@@ -223,7 +223,8 @@ module ActiveRecord
         reader_method(name, class_name, mapping, allow_nil, constructor)
         writer_method(name, class_name, mapping, allow_nil, converter)
 
-        create_reflection(:composed_of, part_id, nil, options, self)
+        reflection = ActiveRecord::Reflection.create(:composed_of, part_id, nil, options, self)
+        Reflection.add_aggregate_reflection self, part_id, reflection
       end
 
       private

data/lib/active_record/association_relation.rb

@@ -9,6 +9,10 @@ module ActiveRecord
       @association
     end
 
+    def ==(other)
+      other == to_a
+    end
+
     private
 
     def exec_queries

data/lib/active_record/associations/alias_tracker.rb

@@ -5,16 +5,58 @@ module ActiveRecord
     # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
     # ActiveRecord::Associations::ThroughAssociationScope
     class AliasTracker # :nodoc:
-      attr_reader :aliases, :table_joins, :connection
+      attr_reader :aliases, :connection
+
+      def self.empty(connection)
+        new connection, Hash.new(0)
+      end
+
+      def self.create(connection, table_joins)
+        if table_joins.empty?
+          empty connection
+        else
+          aliases = Hash.new { |h,k|
+            h[k] = initial_count_for(connection, k, table_joins)
+          }
+          new connection, aliases
+        end
+      end
+
+      def self.initial_count_for(connection, name, table_joins)
+        # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+        quoted_name = connection.quote_table_name(name).downcase
+
+        counts = table_joins.map do |join|
+          if join.is_a?(Arel::Nodes::StringJoin)
+            # Table names + table aliases
+            join.left.downcase.scan(
+              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            ).size
+          elsif join.respond_to? :left
+            join.left.table_name == name ? 1 : 0
+          else
+            # this branch is reached by two tests:
+            #
+            # activerecord/test/cases/associations/cascaded_eager_loading_test.rb:37
+            #   with :posts
+            #
+            # activerecord/test/cases/associations/eager_test.rb:1133
+            #   with :comments
+            #
+            0
+          end
+        end
+
+        counts.sum
+      end
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection = Base.connection, table_joins = [])
-        @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
-        @table_joins = table_joins
-        @connection  = connection
+      def initialize(connection, aliases)
+        @aliases    = aliases
+        @connection = connection
       end
 
-      def aliased_table_for(table_name, aliased_name = nil)
+      def aliased_table_for(table_name, aliased_name)
         table_alias = aliased_name_for(table_name, aliased_name)
 
         if table_alias == table_name
@@ -24,9 +66,7 @@ module ActiveRecord
         end
       end
 
-      def aliased_name_for(table_name, aliased_name = nil)
-        aliased_name ||= table_name
-
+      def aliased_name_for(table_name, aliased_name)
         if aliases[table_name].zero?
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
@@ -48,26 +88,6 @@ module ActiveRecord
 
       private
 
-        def initial_count_for(name)
-          return 0 if Arel::Table === table_joins
-
-          # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-          quoted_name = connection.quote_table_name(name).downcase
-
-          counts = table_joins.map do |join|
-            if join.is_a?(Arel::Nodes::StringJoin)
-              # Table names + table aliases
-              join.left.downcase.scan(
-                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-              ).size
-            else
-              join.left.table_name == name ? 1 : 0
-            end
-          end
-
-          counts.sum
-        end
-
         def truncate(name)
           name.slice(0, connection.table_alias_length - 2)
         end

data/lib/active_record/associations/association.rb

@@ -13,7 +13,6 @@ module ActiveRecord
     #       BelongsToAssociation
     #         BelongsToPolymorphicAssociation
     #     CollectionAssociation
-    #       HasAndBelongsToManyAssociation
     #       HasManyAssociation
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
@@ -87,11 +86,6 @@ module ActiveRecord
         target_scope.merge(association_scope)
       end
 
-      def scoped
-        ActiveSupport::Deprecation.warn "#scoped is deprecated. use #scope instead."
-        scope
-      end
-
       # The scope for this association.
       #
       # Note that the association_scope is merged into the target_scope only when the
@@ -100,7 +94,7 @@ module ActiveRecord
       # actually gets built.
       def association_scope
         if klass
-          @association_scope ||= AssociationScope.new(self).scope
+          @association_scope ||= AssociationScope.scope(self, klass.connection)
         end
       end
 
@@ -110,11 +104,12 @@ module ActiveRecord
 
       # Set the inverse association, if possible
       def set_inverse_instance(record)
-        if record && invertible_for?(record)
+        if invertible_for?(record)
           inverse = record.association(inverse_reflection_for(record).name)
           inverse.target = owner
           inverse.inversed = true
         end
+        record
       end
 
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
@@ -126,11 +121,7 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        all = klass.all
-        scope = AssociationRelation.new(klass, klass.arel_table, self)
-        scope.merge! all
-        scope.default_scoped = all.default_scoped?
-        scope
+        AssociationRelation.create(klass, klass.arel_table, self).merge!(klass.all)
       end
 
       # Loads the \target if needed and returns it.
@@ -169,7 +160,7 @@ module ActiveRecord
       def marshal_load(data)
         reflection_name, ivars = data
         ivars.each { |name, val| instance_variable_set(name, val) }
-        @reflection = @owner.class.reflect_on_association(reflection_name)
+        @reflection = @owner.class._reflect_on_association(reflection_name)
       end
 
       def initialize_attributes(record) #:nodoc:
@@ -204,13 +195,14 @@ module ActiveRecord
           creation_attributes.each { |key, value| record[key] = value }
         end
 
-        # Should be true if there is a foreign key present on the owner which
+        # Returns true if there is a foreign key present on the owner which
         # references the target. This is used to determine whether we can load
         # the target if the owner is currently a new record (and therefore
-        # without a key).
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
         #
         # Currently implemented by belongs_to (vanilla and polymorphic) and
-        # has_one/has_many :through associations which go through a belongs_to
+        # has_one/has_many :through associations which go through a belongs_to.
         def foreign_key_present?
           false
         end

data/lib/active_record/associations/association_scope.rb

@@ -1,64 +1,77 @@
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      include JoinHelper
+      INSTANCE = new
 
-      attr_reader :association, :alias_tracker
+      def self.scope(association, connection)
+        INSTANCE.scope association, connection
+      end
 
-      delegate :klass, :owner, :reflection, :interpolate, :to => :association
-      delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection
+      def scope(association, connection)
+        klass         = association.klass
+        reflection    = association.reflection
+        scope         = klass.unscoped
+        owner         = association.owner
+        alias_tracker = AliasTracker.empty connection
 
-      def initialize(association)
-        @association   = association
-        @alias_tracker = AliasTracker.new klass.connection
+        scope.extending! Array(reflection.options[:extend])
+        add_constraints(scope, owner, klass, reflection, alias_tracker)
       end
 
-      def scope
-        scope = klass.unscoped
-        scope.extending! Array(options[:extend])
-        add_constraints(scope)
+      def join_type
+        Arel::Nodes::InnerJoin
       end
 
       private
 
-      def column_for(table_name, column_name)
+      def construct_tables(chain, klass, refl, alias_tracker)
+        chain.map do |reflection|
+          alias_tracker.aliased_table_for(
+            table_name_for(reflection, klass, refl),
+            table_alias_for(reflection, refl, reflection != refl)
+          )
+        end
+      end
+
+      def table_alias_for(reflection, refl, join = false)
+        name = "#{reflection.plural_name}_#{alias_suffix(refl)}"
+        name << "_join" if join
+        name
+      end
+
+      def join(table, constraint)
+        table.create_join(table, table.create_on(constraint), join_type)
+      end
+
+      def column_for(table_name, column_name, alias_tracker)
         columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
         columns[column_name]
       end
 
-      def bind_value(scope, column, value)
+      def bind_value(scope, column, value, alias_tracker)
         substitute = alias_tracker.connection.substitute_at(
           column, scope.bind_values.length)
         scope.bind_values += [[column, value]]
         substitute
       end
 
-      def bind(scope, table_name, column_name, value)
-        column   = column_for table_name, column_name
-        bind_value scope, column, value
+      def bind(scope, table_name, column_name, value, tracker)
+        column   = column_for table_name, column_name, tracker
+        bind_value scope, column, value, tracker
       end
 
-      def add_constraints(scope)
-        tables = construct_tables
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
 
         chain.each_with_index do |reflection, i|
           table, foreign_table = tables.shift, tables.first
 
-          if reflection.source_macro == :has_and_belongs_to_many
-            join_table = tables.shift
-
-            scope = scope.joins(join(
-              join_table,
-              table[reflection.association_primary_key].
-                eq(join_table[reflection.association_foreign_key])
-            ))
-
-            table, foreign_table = join_table, tables.first
-          end
-
           if reflection.source_macro == :belongs_to
             if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(self.klass)
+              key = reflection.association_primary_key(assoc_klass)
             else
               key = reflection.association_primary_key
             end
@@ -70,35 +83,36 @@ module ActiveRecord
           end
 
           if reflection == chain.last
-            bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key]
+            bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
             scope    = scope.where(table[key].eq(bind_val))
 
             if reflection.type
               value    = owner.class.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type.to_s, value
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
               scope    = scope.where(table[reflection.type].eq(bind_val))
             end
           else
             constraint = table[key].eq(foreign_table[foreign_key])
 
             if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
+              value    = chain[i + 1].klass.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
             end
 
             scope = scope.joins(join(foreign_table, constraint))
           end
 
           is_first_chain = i == 0
-          klass = is_first_chain ? self.klass : reflection.klass
+          klass = is_first_chain ? assoc_klass : reflection.klass
 
           # Exclude the scope of the association itself, because that
           # was already merged in the #scope method.
           scope_chain[i].each do |scope_chain_item|
-            item  = eval_scope(klass, scope_chain_item)
+            item  = eval_scope(klass, scope_chain_item, owner)
 
-            if scope_chain_item == self.reflection.scope
-              scope.merge! item.except(:where, :includes)
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
             end
 
             if is_first_chain
@@ -113,12 +127,12 @@ module ActiveRecord
         scope
       end
 
-      def alias_suffix
-        reflection.name
+      def alias_suffix(refl)
+        refl.name
       end
 
-      def table_name_for(reflection)
-        if reflection == self.reflection
+      def table_name_for(reflection, klass, refl)
+        if reflection == refl
           # If this is a polymorphic belongs_to, we want to get the klass from the
           # association because it depends on the polymorphic_type attribute of
           # the owner
@@ -128,12 +142,8 @@ module ActiveRecord
         end
       end
 
-      def eval_scope(klass, scope)
-        if scope.is_a?(Relation)
-          scope
-        else
-          klass.unscoped.instance_exec(owner, &scope)
-        end
+      def eval_scope(klass, scope, owner)
+        klass.unscoped.instance_exec(owner, &scope)
       end
     end
   end

data/lib/active_record/associations/belongs_to_association.rb

@@ -8,13 +8,16 @@ module ActiveRecord
       end
 
       def replace(record)
-        raise_on_type_mismatch!(record) if record
-
-        update_counters(record)
-        replace_keys(record)
-        set_inverse_instance(record)
-
-        @updated = true if record
+        if record
+          raise_on_type_mismatch!(record)
+          update_counters(record)
+          replace_keys(record)
+          set_inverse_instance(record)
+          @updated = true
+        else
+          decrement_counters
+          remove_keys
+        end
 
         self.target = record
       end
@@ -34,35 +37,41 @@ module ActiveRecord
           !loaded? && foreign_key_present? && klass
         end
 
-        def update_counters(record)
+        def with_cache_name
           counter_cache_name = reflection.counter_cache_column
+          return unless counter_cache_name && owner.persisted?
+          yield counter_cache_name
+        end
+
+        def update_counters(record)
+          with_cache_name do |name|
+            return unless different_target? record
+            record.class.increment_counter(name, record.id)
+            decrement_counter name
+          end
+        end
 
-          if counter_cache_name && owner.persisted? && different_target?(record)
-            if record
-              record.class.increment_counter(counter_cache_name, record.id)
-            end
+        def decrement_counters
+          with_cache_name { |name| decrement_counter name }
+        end
 
-            if foreign_key_present?
-              klass.decrement_counter(counter_cache_name, target_id)
-            end
+        def decrement_counter counter_cache_name
+          if foreign_key_present?
+            klass.decrement_counter(counter_cache_name, target_id)
           end
         end
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          if record.nil? 
-            owner[reflection.foreign_key] 
-          else
-            record.id != owner[reflection.foreign_key]
-          end
+          record.id != owner[reflection.foreign_key]
         end
 
         def replace_keys(record)
-          if record
-            owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
-          else
-            owner[reflection.foreign_key] = nil
-          end
+          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+        end
+
+        def remove_keys
+          owner[reflection.foreign_key] = nil
         end
 
         def foreign_key_present?

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -11,7 +11,12 @@ module ActiveRecord
 
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record && record.class.base_class.name
+          owner[reflection.foreign_type] = record.class.base_class.name
+        end
+
+        def remove_keys
+          super
+          owner[reflection.foreign_type] = nil
         end
 
         def different_target?(record)