activerecord 4.0.3 → 4.0.4.rc1

data/lib/active_record/associations/association_scope.rb

@@ -89,17 +89,22 @@ module ActiveRecord
             scope = scope.joins(join(foreign_table, constraint))
           end
 
+          is_first_chain = i == 0
+          klass = is_first_chain ? self.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|
-            klass = i == 0 ? self.klass : reflection.klass
             item  = eval_scope(klass, scope_chain_item)
 
             if scope_chain_item == self.reflection.scope
               scope.merge! item.except(:where, :includes)
             end
 
-            scope.includes! item.includes_values
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
             scope.where_values += item.where_values
             scope.order_values |= item.order_values
           end

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

@@ -5,7 +5,7 @@ module ActiveRecord::Associations::Builder
     end
 
     def valid_options
-      super + [:foreign_type, :polymorphic, :touch]
+      super + [:foreign_type, :polymorphic, :touch, :counter_cache]
     end
 
     def constructable?
@@ -73,7 +73,13 @@ module ActiveRecord::Associations::Builder
           old_foreign_id    = changed_attributes[foreign_key_field]
 
           if old_foreign_id
-            klass      = association(#{name.inspect}).klass
+            association = association(:#{name})
+            reflection = association.reflection
+            if reflection.polymorphic?
+              klass = send("#{reflection.foreign_type}_was").constantize
+            else
+              klass = association.klass
+            end
             old_record = klass.find_by(klass.primary_key => old_foreign_id)
 
             if old_record
@@ -82,7 +88,7 @@ module ActiveRecord::Associations::Builder
           end
 
           record = #{name}
-          unless record.nil? || record.new_record?
+          if record && record.persisted?
             record.touch #{options[:touch].inspect if options[:touch] != true}
           end
         end

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

@@ -1,7 +1,7 @@
 module ActiveRecord::Associations::Builder
   class SingularAssociation < Association #:nodoc:
     def valid_options
-      super + [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+      super + [:remote, :dependent, :primary_key, :inverse_of]
     end
 
     def constructable?

data/lib/active_record/associations/collection_association.rb

@@ -193,7 +193,7 @@ module ActiveRecord
             relation = relation.distinct
           end
 
-          value = relation.count(column_name)
+          value = relation.count(column_name, count_options)
 
           limit  = options[:limit]
           offset = options[:offset]

data/lib/active_record/associations/collection_proxy.rb

@@ -282,7 +282,7 @@ module ActiveRecord
       # so method calls may be chained.
       #
       #   class Person < ActiveRecord::Base
-      #     pets :has_many
+      #     has_many :pets
       #   end
       #
       #   person.pets.size # => 0

data/lib/active_record/associations/has_many_through_association.rb

@@ -149,7 +149,7 @@ module ActiveRecord
 
           delete_through_records(records)
 
-          if source_reflection.options[:counter_cache]
+          if source_reflection.options[:counter_cache] && method != :destroy
             counter = source_reflection.counter_cache_column
             klass.decrement_counter counter, records.map(&:id)
           end

data/lib/active_record/associations/has_one_association.rb

@@ -26,11 +26,13 @@ module ActiveRecord
         load_target
 
         return self.target if !(target || record)
-        if (target != record) || record.changed?
+
+        assigning_another_record = target != record
+        if assigning_another_record || record.changed?
           save &&= owner.persisted?
 
           transaction_if(save) do
-            remove_target!(options[:dependent]) if target && !target.destroyed?
+            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
 
             if record
               set_owner_attributes(record)

data/lib/active_record/associations/singular_association.rb

@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def find_target
-          scope.first.tap { |record| set_inverse_instance(record) }
+          scope.take.tap { |record| set_inverse_instance(record) }
         end
 
         # Implemented by subclasses

data/lib/active_record/attribute_methods.rb

@@ -48,20 +48,19 @@ module ActiveRecord
         # Use a mutex; we don't want two thread simultaneously trying to define
         # attribute methods.
         generated_attribute_methods.synchronize do
-          return if attribute_methods_generated?
+          return false if @attribute_methods_generated
           superclass.define_attribute_methods unless self == base_class
           super(column_names)
           @attribute_methods_generated = true
         end
-      end
-
-      def attribute_methods_generated? # :nodoc:
-        @attribute_methods_generated
+        true
       end
 
       def undefine_attribute_methods # :nodoc:
-        super if attribute_methods_generated?
-        @attribute_methods_generated = false
+        generated_attribute_methods.synchronize do
+          super if @attribute_methods_generated
+          @attribute_methods_generated = false
+        end
       end
 
       # Raises a <tt>ActiveRecord::DangerousAttributeError</tt> exception when an
@@ -88,7 +87,8 @@ module ActiveRecord
         else
           # If B < A and A defines its own attribute method, then we don't want to overwrite that.
           defined = method_defined_within?(method_name, superclass, superclass.generated_attribute_methods)
-          defined && !ActiveRecord::Base.method_defined?(method_name) || super
+          base_defined = Base.method_defined?(method_name) || Base.private_method_defined?(method_name)
+          defined && !base_defined || super
         end
       end
 
@@ -110,6 +110,16 @@ module ActiveRecord
         end
       end
 
+      def find_generated_attribute_method(method_name) # :nodoc:
+        klass = self
+        until klass == Base
+          gen_methods = klass.generated_attribute_methods
+          return gen_methods.instance_method(method_name) if method_defined_within?(method_name, gen_methods, Object)
+          klass = klass.superclass
+        end
+        nil
+      end
+
       # Returns +true+ if +attribute+ is an attribute method and table exists,
       # +false+ otherwise.
       #
@@ -143,13 +153,15 @@ module ActiveRecord
     # If we haven't generated any methods yet, generate them, then
     # see if we've created the method we're looking for.
     def method_missing(method, *args, &block) # :nodoc:
-      unless self.class.attribute_methods_generated?
-        self.class.define_attribute_methods
-
-        if respond_to_without_attributes?(method)
-          send(method, *args, &block)
+      self.class.define_attribute_methods
+      if respond_to_without_attributes?(method)
+        # make sure to invoke the correct attribute method, as we might have gotten here via a `super`
+        # call in a overwritten attribute method
+        if attribute_method = self.class.find_generated_attribute_method(method)
+          # this is probably horribly slow, but should only happen at most once for a given AR class
+          attribute_method.bind(self).call(*args, &block)
         else
-          super
+          send(method, *args, &block)
         end
       else
         super
@@ -188,7 +200,7 @@ module ActiveRecord
     #   person.respond_to(:nothing) # => false
     def respond_to?(name, include_private = false)
       name = name.to_s
-      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
+      self.class.define_attribute_methods
       result = super
 
       # If the result is false the answer is false.
@@ -244,6 +256,11 @@ module ActiveRecord
       }
     end
 
+    # Placeholder so it can be overriden when needed by serialization
+    def attributes_for_coder # :nodoc:
+      attributes
+    end
+
     # Returns an <tt>#inspect</tt>-like string for the value of the
     # attribute +attr_name+. String attributes are truncated upto 50
     # characters, and Date and Time attributes are returned in the

data/lib/active_record/attribute_methods/serialization.rb

@@ -156,6 +156,16 @@ module ActiveRecord
             super
           end
         end
+
+        def attributes_for_coder
+          attribute_names.each_with_object({}) do |name, attrs|
+            attrs[name] = if self.class.serialized_attributes.include?(name)
+                            @attributes[name].serialized_value
+                          else
+                            read_attribute(name)
+                          end
+          end
+        end
       end
     end
   end

data/lib/active_record/autosave_association.rb

@@ -382,9 +382,10 @@ module ActiveRecord
 
         if autosave && record.marked_for_destruction?
           record.destroy
-        else
+        elsif autosave != false
           key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          if autosave != false && (new_record? || record.new_record? || record[reflection.foreign_key] != key || autosave)
+
+          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
             unless reflection.through_reflection
               record[reflection.foreign_key] = key
             end
@@ -397,6 +398,11 @@ module ActiveRecord
       end
     end
 
+    # If the record is new or it has changed, returns true.
+    def record_changed?(reflection, record, key)
+      record.new_record? || record[reflection.foreign_key] != key || record.changed_attributes.include?(reflection.foreign_key)
+    end
+
     # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
     #
     # In addition, it will destroy the association if it was marked for destruction.

data/lib/active_record/callbacks.rb

@@ -128,7 +128,7 @@ module ActiveRecord
   #       record.credit_card_number = decrypt(record.credit_card_number)
   #     end
   #
-  #     alias_method :after_find, :after_save
+  #     alias_method :after_initialize, :after_save
   #
   #     private
   #       def encrypt(value)
@@ -163,7 +163,7 @@ module ActiveRecord
   #       record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
   #     end
   #
-  #     alias_method :after_find, :after_save
+  #     alias_method :after_initialize, :after_save
   #
   #     private
   #       def encrypt(value)

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -398,7 +398,7 @@ module ActiveRecord
         synchronize do
           stale = Time.now - @dead_connection_timeout
           connections.dup.each do |conn|
-            if conn.in_use? && stale > conn.last_use && !conn.active?
+            if conn.in_use? && stale > conn.last_use && !conn.active_threadsafe?
               remove conn
             end
           end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -21,6 +21,14 @@ module ActiveRecord
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
       def select_all(arel, name = nil, binds = [])
+        if arel.is_a?(Relation)
+          relation = arel
+          arel = relation.arel
+          if !binds || binds.empty?
+            binds = relation.bind_values
+          end
+        end
+
         select(to_sql(arel, binds), name, binds)
       end
 
@@ -41,13 +49,16 @@ module ActiveRecord
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       def select_values(arel, name = nil)
-        result = select_rows(to_sql(arel, []), name)
-        result.map { |v| v[0] }
+        binds = []
+        if arel.is_a?(Relation)
+          arel, binds = arel.arel, arel.bind_values
+        end
+        select_rows(to_sql(arel, binds), name, binds).map(&:first)
       end
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(sql, name = nil)
+      def select_rows(sql, name = nil, binds = [])
       end
       undef_method :select_rows
 

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -44,7 +44,9 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column)
-        return value.id if value.respond_to?(:quoted_id)
+        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
+          return value.id
+        end
 
         case value
         when String, ActiveSupport::Multibyte::Chars

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -120,9 +120,9 @@ module ActiveRecord
       #   The name of the primary key, if one is to be added automatically.
       #   Defaults to +id+. If <tt>:id</tt> is false this option is ignored.
       #
-      #   Also note that this just sets the primary key in the table. You additionally
-      #   need to configure the primary key in the model via +self.primary_key=+.
-      #   Models do NOT auto-detect the primary key from their table definition.
+      #   Note that Active Record models will automatically detect their
+      #   primary key. This can be avoided by using +self.primary_key=+ on the model
+      #   to define the key explicitly.
       #
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
@@ -690,7 +690,7 @@ module ActiveRecord
 
           column_type_sql
         else
-          type
+          type.to_s
         end
       end
 
@@ -719,7 +719,7 @@ module ActiveRecord
       # require the order columns appear in the SELECT.
       #
       #   columns_for_distinct("posts.id", ["posts.created_at desc"])
-      def columns_for_distinct(columns, orders) # :nodoc:
+      def columns_for_distinct(columns, orders) #:nodoc:
         columns
       end
 
@@ -741,6 +741,10 @@ module ActiveRecord
         remove_column table_name, :created_at
       end
 
+      def update_table_definition(table_name, base) #:nodoc:
+        Table.new(table_name, base)
+      end
+
       protected
         def add_index_sort_order(option_strings, column_names, options = {})
           if options.is_a?(Hash) && order = options[:order]
@@ -873,10 +877,6 @@ module ActiveRecord
       def create_alter_table(name)
         AlterTable.new create_table_definition(name, false, {})
       end
-
-      def update_table_definition(table_name, base)
-        Table.new(table_name, base)
-      end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -23,6 +23,10 @@ module ActiveRecord
         @parent = nil
       end
 
+      def finalized?
+        @state
+      end
+
       def committed?
         @state == :committed
       end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -39,6 +39,7 @@ module ActiveRecord
       autoload :ClosedTransaction
       autoload :RealTransaction
       autoload :SavepointTransaction
+      autoload :TransactionState
     end
 
     # Active Record supports multiple database systems. AbstractAdapter and
@@ -325,6 +326,12 @@ module ActiveRecord
       def active?
       end
 
+      # Adapter should redefine this if it needs a threadsafe way to approximate
+      # if the connection is active
+      def active_threadsafe?
+        active?
+      end
+
       # Disconnects from the database if already connected, and establishes a
       # new connection with the database. Implementors should call super if they
       # override the default implementation.

data/lib/active_record/connection_adapters/column.rb

@@ -238,11 +238,19 @@ module ActiveRecord
             end
           end
 
-          def new_time(year, mon, mday, hour, min, sec, microsec)
+          def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
             # Treat 0000-00-00 00:00:00 as nil.
             return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
 
-            Time.send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            if offset
+              time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+              return nil unless time
+
+              time -= offset
+              Base.default_timezone == :utc ? time : time.getlocal
+            else
+              Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            end
           end
 
           def fast_string_to_date(string)
@@ -267,7 +275,7 @@ module ActiveRecord
             time_hash = Date._parse(string)
             time_hash[:sec_fraction] = microseconds(time_hash)
 
-            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
           end
       end