activerecord 4.1.8 → 4.2.11.3

data/README.rdoc

@@ -1,4 +1,4 @@
-= Active Record -- Object-relational mapping put on rails
+= Active Record -- Object-relational mapping in Rails
 
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
@@ -20,8 +20,10 @@ A short rundown of some of the major features:
    class Product < ActiveRecord::Base
    end
 
-   The Product class is automatically mapped to the table named "products",
-   which might look like this:
+  {Learn more}[link:classes/ActiveRecord/Base.html]
+
+The Product class is automatically mapped to the table named "products",
+which might look like this:
 
    CREATE TABLE products (
      id int(11) NOT NULL auto_increment,
@@ -29,10 +31,8 @@ A short rundown of some of the major features:
      PRIMARY KEY  (id)
    );
 
-   This would also define the following accessors: `Product#name` and
-   `Product#name=(new_name)`
-
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+This would also define the following accessors: `Product#name` and
+`Product#name=(new_name)`.
 
 
 * Associations between objects defined by simple class methods.
@@ -130,7 +130,7 @@ A short rundown of some of the major features:
   SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[http://log4r.rubyforge.org] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
 
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
     ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
@@ -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-1-stable/activerecord
+* https://github.com/rails/rails/tree/4-2-stable/activerecord
 
 
 == License
@@ -208,6 +208,11 @@ API documentation is at:
 
 * http://api.rubyonrails.org
 
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+Bug reports can be filed for the Ruby on Rails project here:
 
 * https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+

data/lib/active_record/aggregations.rb

@@ -129,10 +129,10 @@ module ActiveRecord
     # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
     # converted to an instance of value class if necessary.
     #
-    # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that
-    # should be aggregated using the NetAddr::CIDR value class (http://netaddr.rubyforge.org). The constructor
-    # for the value class is called +create+ and it expects a CIDR address string as a parameter. New
-    # values can be assigned to the value object using either another NetAddr::CIDR object, a string
+    # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that should be
+    # aggregated using the NetAddr::CIDR value class (http://www.ruby-doc.org/gems/docs/n/netaddr-1.5.0/NetAddr/CIDR.html).
+    # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
+    # New values can be assigned to the value object using either another NetAddr::CIDR object, a string
     # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
     # these requirements:
     #
@@ -230,8 +230,8 @@ module ActiveRecord
       private
         def reader_method(name, class_name, mapping, allow_nil, constructor)
           define_method(name) do
-            if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? {|pair| !read_attribute(pair.first).nil? })
-              attrs = mapping.collect {|pair| read_attribute(pair.first)}
+            if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? {|key, _| !_read_attribute(key).nil? })
+              attrs = mapping.collect {|key, _| _read_attribute(key)}
               object = constructor.respond_to?(:call) ?
                 constructor.call(*attrs) :
                 class_name.constantize.send(constructor, *attrs)
@@ -244,15 +244,22 @@ module ActiveRecord
         def writer_method(name, class_name, mapping, allow_nil, converter)
           define_method("#{name}=") do |part|
             klass = class_name.constantize
+
             unless part.is_a?(klass) || converter.nil? || part.nil?
               part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
             end
 
+            hash_from_multiparameter_assignment = part.is_a?(Hash) &&
+              part.each_key.all? { |k| k.is_a?(Integer) }
+            if hash_from_multiparameter_assignment
+              part = klass.new(*part.values)
+            end
+
             if part.nil? && allow_nil
-              mapping.each { |pair| self[pair.first] = nil }
+              mapping.each { |key, _| self[key] = nil }
               @aggregation_cache[name] = nil
             else
-              mapping.each { |pair| self[pair.first] = part.send(pair.last) }
+              mapping.each { |key, value| self[key] = part.send(value) }
               @aggregation_cache[name] = part.freeze
             end
           end

data/lib/active_record/association_relation.rb

@@ -13,6 +13,19 @@ module ActiveRecord
       other == to_a
     end
 
+    def build(*args, &block)
+      scoping { @association.build(*args, &block) }
+    end
+    alias new build
+
+    def create(*args, &block)
+      scoping { @association.create(*args, &block) }
+    end
+
+    def create!(*args, &block)
+      scoping { @association.create!(*args, &block) }
+    end
+
     private
 
     def exec_queries

data/lib/active_record/associations/alias_tracker.rb

@@ -57,20 +57,10 @@ module ActiveRecord
       end
 
       def aliased_table_for(table_name, aliased_name)
-        table_alias = aliased_name_for(table_name, aliased_name)
-
-        if table_alias == table_name
-          Arel::Table.new(table_name)
-        else
-          Arel::Table.new(table_name).alias(table_alias)
-        end
-      end
-
-      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
-          table_name
+          Arel::Table.new(table_name)
         else
           # Otherwise, we need to use an alias
           aliased_name = connection.table_alias_for(aliased_name)
@@ -78,11 +68,12 @@ module ActiveRecord
           # Update the count
           aliases[aliased_name] += 1
 
-          if aliases[aliased_name] > 1
+          table_alias = if aliases[aliased_name] > 1
             "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
           else
             aliased_name
           end
+          Arel::Table.new(table_name).alias(table_alias)
         end
       end
 

data/lib/active_record/associations/association.rb

@@ -179,7 +179,7 @@ module ActiveRecord
         def creation_attributes
           attributes = {}
 
-          if (reflection.macro == :has_one || reflection.macro == :has_many) && !options[:through]
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
             attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
 
             if reflection.options[:as]
@@ -211,9 +211,12 @@ module ActiveRecord
         # the kind of the class of the associated objects. Meant to be used as
         # a sanity check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
-          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
-            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
-            raise ActiveRecord::AssociationTypeMismatch, message
+          unless record.is_a?(reflection.klass)
+            fresh_class = reflection.class_name.safe_constantize
+            unless fresh_class && record.is_a?(fresh_class)
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
           end
         end
 
@@ -248,6 +251,15 @@ module ActiveRecord
             initialize_attributes(record)
           end
         end
+
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?
+          reflection.scope_chain.any?(&:any?) ||
+            scope.eager_loading? ||
+            klass.current_scope ||
+            klass.default_scopes.any? ||
+            reflection.source_reflection.active_record.default_scopes.any?
+        end
     end
   end
 end

data/lib/active_record/associations/association_scope.rb

@@ -1,12 +1,33 @@
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      INSTANCE = new
-
       def self.scope(association, connection)
         INSTANCE.scope association, connection
       end
 
+      class BindSubstitution
+        def initialize(block)
+          @block = block
+        end
+
+        def bind_value(scope, column, value, alias_tracker)
+          substitute = alias_tracker.connection.substitute_at(column)
+          scope.bind_values += [[column, @block.call(value)]]
+          substitute
+        end
+      end
+
+      def self.create(&block)
+        block = block ? block : lambda { |val| val }
+        new BindSubstitution.new(block)
+      end
+
+      def initialize(bind_substitution)
+        @bind_substitution = bind_substitution
+      end
+
+      INSTANCE = create
+
       def scope(association, connection)
         klass         = association.klass
         reflection    = association.reflection
@@ -22,6 +43,23 @@ module ActiveRecord
         Arel::Nodes::InnerJoin
       end
 
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.base_class.name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.base_class.name
+          end
+        end
+        binds
+      end
+
       private
 
       def construct_tables(chain, klass, refl, alias_tracker)
@@ -49,10 +87,7 @@ module ActiveRecord
       end
 
       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
+        @bind_substitution.bind_value scope, column, value, alias_tracker
       end
 
       def bind(scope, table_name, column_name, value, tracker)
@@ -60,47 +95,55 @@ module ActiveRecord
         bind_value scope, column, value, tracker
       end
 
+      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.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, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        else
+          scope
+        end
+      end
+
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        constraint = table[key].eq(foreign_table[foreign_key])
+
+        if reflection.type
+          value    = next_reflection.klass.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        end
+
+        scope = scope.joins(join(foreign_table, constraint))
+      end
+
       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)
 
+        owner_reflection = chain.last
+        table = tables.last
+        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+
         chain.each_with_index do |reflection, i|
           table, foreign_table = tables.shift, tables.first
 
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(assoc_klass)
-            else
-              key = reflection.association_primary_key
-            end
-
-            foreign_key = reflection.foreign_key
-          else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
-
-          if reflection == chain.last
-            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, tracker
-              scope    = scope.where(table[reflection.type].eq(bind_val))
-            end
-          else
-            constraint = table[key].eq(foreign_table[foreign_key])
-
-            if reflection.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))
+          unless reflection == chain.last
+            next_reflection = chain[i + 1]
+            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
           end
 
           is_first_chain = i == 0
@@ -119,7 +162,9 @@ module ActiveRecord
               scope.includes! item.includes_values
             end
 
+            scope.unscope!(*item.unscope_values)
             scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
             scope.order_values |= item.order_values
           end
         end
@@ -143,11 +188,7 @@ module ActiveRecord
       end
 
       def eval_scope(klass, scope, owner)
-        if scope.is_a?(Relation)
-          scope
-        else
-          klass.unscoped.instance_exec(owner, &scope)
-        end
+        klass.unscoped.instance_exec(owner, &scope)
       end
     end
   end

data/lib/active_record/associations/belongs_to_association.rb

@@ -31,6 +31,14 @@ module ActiveRecord
         @updated
       end
 
+      def decrement_counters # :nodoc:
+        with_cache_name { |name| decrement_counter name }
+      end
+
+      def increment_counters # :nodoc:
+        with_cache_name { |name| increment_counter name }
+      end
+
       private
 
         def find_target?
@@ -51,23 +59,28 @@ module ActiveRecord
           end
         end
 
-        def decrement_counters
-          with_cache_name { |name| decrement_counter name }
+        def decrement_counter(counter_cache_name)
+          if foreign_key_present?
+            klass.decrement_counter(counter_cache_name, target_id)
+          end
         end
 
-        def decrement_counter counter_cache_name
+        def increment_counter(counter_cache_name)
           if foreign_key_present?
-            klass.decrement_counter(counter_cache_name, target_id)
+            klass.increment_counter(counter_cache_name, target_id)
+            if target && !stale_target? && counter_cache_available_in_memory?(counter_cache_name)
+              target.increment(counter_cache_name)
+            end
           end
         end
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          record.id != owner[reflection.foreign_key]
+          record.id != owner._read_attribute(reflection.foreign_key)
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
         end
 
         def remove_keys
@@ -75,26 +88,31 @@ module ActiveRecord
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
         # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.macro == :has_one
+          inverse && inverse.has_one?
         end
 
         def target_id
           if options[:primary_key]
             owner.send(reflection.name).try(:id)
           else
-            owner[reflection.foreign_key]
+            owner._read_attribute(reflection.foreign_key)
           end
         end
 
         def stale_state
-          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key)
+          result && result.to_s
+        end
+
+        def counter_cache_available_in_memory?(counter_cache_name)
+          target.respond_to?(counter_cache_name)
         end
     end
   end

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

@@ -21,7 +21,7 @@ module ActiveRecord::Associations::Builder
     end
     self.extensions = []
 
-    self.valid_options = [:class_name, :class, :foreign_key, :validate]
+    self.valid_options = [:class_name, :anonymous_class, :foreign_key, :validate]
 
     attr_reader :name, :scope, :options
 
@@ -36,6 +36,7 @@ module ActiveRecord::Associations::Builder
       reflection = builder.build(model)
       define_accessors model, reflection
       define_callbacks model, reflection
+      define_validations model, reflection
       builder.define_extensions model
       reflection
     end
@@ -85,7 +86,11 @@ module ActiveRecord::Associations::Builder
     end
 
     def self.define_callbacks(model, reflection)
-      add_before_destroy_callbacks(model, reflection) if reflection.options[:dependent]
+      if dependent = reflection.options[:dependent]
+        check_dependent_options(dependent)
+        add_destroy_callbacks(model, reflection)
+      end
+
       Association.extensions.each do |extension|
         extension.build model, reflection
       end
@@ -120,17 +125,23 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
+    def self.define_validations(model, reflection)
+      # noop
+    end
+
     def self.valid_dependent_options
       raise NotImplementedError
     end
 
     private
 
-    def self.add_before_destroy_callbacks(model, reflection)
-      unless valid_dependent_options.include? reflection.options[:dependent]
-        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{reflection.options[:dependent]}"
+    def self.check_dependent_options(dependent)
+      unless valid_dependent_options.include? dependent
+        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
+    end
 
+    def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
       model.before_destroy lambda { |o| o.association(name).handle_dependency }
     end

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

@@ -26,28 +26,9 @@ module ActiveRecord::Associations::Builder
     private
 
     def self.add_counter_cache_methods(mixin)
-      return if mixin.method_defined? :belongs_to_counter_cache_after_create
+      return if mixin.method_defined? :belongs_to_counter_cache_after_update
 
       mixin.class_eval do
-        def belongs_to_counter_cache_after_create(reflection)
-          if record = send(reflection.name)
-            cache_column = reflection.counter_cache_column
-            record.class.increment_counter(cache_column, record.id)
-            @_after_create_counter_called = true
-          end
-        end
-
-        def belongs_to_counter_cache_before_destroy(reflection)
-          foreign_key = reflection.foreign_key.to_sym
-          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-            record = send reflection.name
-            if record && !self.destroyed?
-              cache_column = reflection.counter_cache_column
-              record.class.decrement_counter(cache_column, record.id)
-            end
-          end
-        end
-
         def belongs_to_counter_cache_after_update(reflection)
           foreign_key  = reflection.foreign_key
           cache_column = reflection.counter_cache_column
@@ -73,14 +54,6 @@ module ActiveRecord::Associations::Builder
     def self.add_counter_cache_callbacks(model, reflection)
       cache_column = reflection.counter_cache_column
 
-      model.after_create lambda { |record|
-        record.belongs_to_counter_cache_after_create(reflection)
-      }
-
-      model.before_destroy lambda { |record|
-        record.belongs_to_counter_cache_before_destroy(reflection)
-      }
-
       model.after_update lambda { |record|
         record.belongs_to_counter_cache_after_update(reflection)
       }
@@ -130,9 +103,14 @@ module ActiveRecord::Associations::Builder
         BelongsTo.touch_record(record, foreign_key, n, touch)
       }
 
-      model.after_save    callback
+      model.after_save    callback, if: :changed?
       model.after_touch   callback
       model.after_destroy callback
     end
+
+    def self.add_destroy_callbacks(model, reflection)
+      name = reflection.name
+      model.after_destroy lambda { |o| o.association(name).handle_dependency }
+    end
   end
 end

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

@@ -82,7 +82,11 @@ module ActiveRecord::Associations::Builder
 
     def wrap_scope(scope, mod)
       if scope
-        proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
+        end
       else
         proc { extending(mod) }
       end

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

@@ -11,7 +11,7 @@ module ActiveRecord::Associations::Builder
         end
 
         def join_table
-          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", "_")
+          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
         end
 
         private
@@ -46,7 +46,7 @@ module ActiveRecord::Associations::Builder
 
       join_model = Class.new(ActiveRecord::Base) {
         class << self;
-          attr_accessor :class_resolver
+          attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
           attr_accessor :left_reflection
@@ -58,7 +58,7 @@ module ActiveRecord::Associations::Builder
         end
 
         def self.compute_type(class_name)
-          class_resolver.compute_type class_name
+          left_model.compute_type class_name
         end
 
         def self.add_left_association(name, options)
@@ -72,22 +72,17 @@ module ActiveRecord::Associations::Builder
           self.right_reflection = _reflect_on_association(rhs_name)
         end
 
-        def hash
-          object_id.hash
+        def self.retrieve_connection
+          left_model.retrieve_connection
         end
 
-        def ==(other)
-          equal?(other)
-        end
-        alias :eql? :==
-
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
       join_model.table_name_resolver = habtm
-      join_model.class_resolver      = lhs_model
+      join_model.left_model          = lhs_model
 
-      join_model.add_left_association :left_side, class: lhs_model
+      join_model.add_left_association :left_side, anonymous_class: lhs_model
       join_model.add_right_association association_name, belongs_to_options(options)
       join_model
     end
@@ -107,7 +102,7 @@ module ActiveRecord::Associations::Builder
 
     def middle_options(join_model)
       middle_options = {}
-      middle_options[:class] = join_model
+      middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
       middle_options[:source] = join_model.left_reflection.name
       if options.key? :foreign_key
         middle_options[:foreign_key] = options[:foreign_key]
@@ -119,7 +114,7 @@ module ActiveRecord::Associations::Builder
       rhs_options = {}
 
       if options.key? :class_name
-        rhs_options[:foreign_key] = options[:class_name].foreign_key
+        rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
         rhs_options[:class_name] = options[:class_name]
       end