activerecord 4.1.0.beta2 → 4.1.0.rc1

data/lib/active_record/associations/collection_proxy.rb

@@ -75,7 +75,7 @@ module ActiveRecord
       #   #      #<Pet id: nil, name: "Choo-Choo">
       #   #    ]
       #
-      #   person.pets.select([:id, :name])
+      #   person.pets.select(:id, :name )
       #   # => [
       #   #      #<Pet id: 1, name: "Fancy-Fancy">,
       #   #      #<Pet id: 2, name: "Spook">,
@@ -84,7 +84,7 @@ module ActiveRecord
       #
       # Be careful because this also means you're initializing a model
       # object with only the fields that you've selected. If you attempt
-      # to access a field that is not in the initialized record you'll
+      # to access a field except +id+ that is not in the initialized record you'll
       # receive:
       #
       #   person.pets.select(:name).first.person_id
@@ -106,13 +106,13 @@ module ActiveRecord
       #   #      #<Pet id: 2, name: "Spook">,
       #   #      #<Pet id: 3, name: "Choo-Choo">
       #   #    ]
-      def select(select = nil, &block)
-        @association.select(select, &block)
+      def select(*fields, &block)
+        @association.select(*fields, &block)
       end
 
       # Finds an object in the collection responding to the +id+. Uses the same
       # rules as <tt>ActiveRecord::Base.find</tt>. Returns <tt>ActiveRecord::RecordNotFound</tt>
-      # error if the object can not be found.
+      # error if the object cannot be found.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -170,6 +170,32 @@ module ActiveRecord
         @association.first(*args)
       end
 
+      # Same as +first+ except returns only the second record.
+      def second(*args)
+        @association.second(*args)
+      end
+
+      # Same as +first+ except returns only the third record.
+      def third(*args)
+        @association.third(*args)
+      end
+
+      # Same as +first+ except returns only the fourth record.
+      def fourth(*args)
+        @association.fourth(*args)
+      end
+
+      # Same as +first+ except returns only the fifth record.
+      def fifth(*args)
+        @association.fifth(*args)
+      end
+
+      # Same as +first+ except returns only the forty second record.
+      # Also known as accessing "the reddit".
+      def forty_two(*args)
+        @association.forty_two(*args)
+      end
+
       # Returns the last record, or the last +n+ records, from the collection.
       # If the collection is empty, the first form returns +nil+, and the second
       # form returns an empty array.
@@ -978,6 +1004,28 @@ module ActiveRecord
         proxy_association.reload
         self
       end
+
+      # Unloads the association. Returns +self+.
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :pets
+      #   end
+      #
+      #   person.pets # fetches pets from the database
+      #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
+      #
+      #   person.pets # uses the pets cache
+      #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
+      #
+      #   person.pets.reset # clears the pets cache
+      #
+      #   person.pets  # fetches pets from the database
+      #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
+      def reset
+        proxy_association.reset
+        proxy_association.reset_scope
+        self
+      end
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -111,7 +111,7 @@ module ActiveRecord
             records.each(&:destroy!)
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            if records == :all
+            if records == :all || !reflection.klass.primary_key
               scope = self.scope
             else
               scope = self.scope.where(reflection.klass.primary_key => records)

data/lib/active_record/associations/join_dependency.rb

@@ -93,8 +93,8 @@ module ActiveRecord
       #    joins # =>  []
       #
       def initialize(base, associations, joins)
-        @alias_tracker = AliasTracker.new(base.connection, joins)
-        @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
+        @alias_tracker = AliasTracker.create(base.connection, joins)
+        @alias_tracker.aliased_name_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
         tree = self.class.make_tree associations
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -114,7 +114,7 @@ module ActiveRecord
             walk join_root, oj.join_root
           else
             oj.join_root.children.flat_map { |child|
-              make_outer_joins join_root, child
+              make_outer_joins oj.join_root, child
             }
           end
         }
@@ -163,7 +163,7 @@ module ActiveRecord
 
       def make_outer_joins(parent, child)
         tables    = table_aliases_for(parent, child)
-        join_type = Arel::OuterJoin
+        join_type = Arel::Nodes::OuterJoin
         joins     = make_constraints parent, child, tables, join_type
 
         joins.concat child.children.flat_map { |c| make_outer_joins(child, c) }
@@ -171,7 +171,7 @@ module ActiveRecord
 
       def make_inner_joins(parent, child)
         tables    = child.tables
-        join_type = Arel::InnerJoin
+        join_type = Arel::Nodes::InnerJoin
         joins     = make_constraints parent, child, tables, join_type
 
         joins.concat child.children.flat_map { |c| make_inner_joins(child, c) }

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -25,7 +25,8 @@ module ActiveRecord
           joins         = []
           tables        = tables.reverse
 
-          scope_chain_iter = scope_chain.reverse_each
+          scope_chain_index = 0
+          scope_chain = scope_chain.reverse
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
@@ -44,19 +45,14 @@ module ActiveRecord
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            scope_chain_items = scope_chain_iter.next.map do |item|
+            scope_chain_items = scope_chain[scope_chain_index].map do |item|
               if item.is_a?(Relation)
                 item
               else
                 ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
               end
             end
-
-            if reflection.type
-              scope_chain_items <<
-                ActiveRecord::Relation.create(klass, table)
-                  .where(reflection.type => foreign_klass.base_class.name)
-            end
+            scope_chain_index += 1
 
             scope_chain_items.concat [klass.send(:build_default_scope)].compact
 
@@ -64,6 +60,10 @@ module ActiveRecord
               left.merge right
             end
 
+            if reflection.type
+              constraint = constraint.and table[reflection.type].eq foreign_klass.base_class.name
+            end
+
             if rel && !rel.arel.constraints.empty?
               constraint = constraint.and rel.arel.constraints
             end

data/lib/active_record/associations/preloader.rb

@@ -183,7 +183,7 @@ module ActiveRecord
         def run(preloader); end
 
         def preloaded_records
-          owners.flat_map { |owner| owner.read_attribute reflection.name }
+          owners.flat_map { |owner| owner.association(reflection.name).target }
         end
       end
 

data/lib/active_record/associations/singular_association.rb

@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def find_target
-          if record = scope.first
+          if record = scope.take
             set_inverse_instance record
           end
         end

data/lib/active_record/attribute_methods.rb

@@ -110,16 +110,34 @@ module ActiveRecord
         end
       end
 
-      # A method name is 'dangerous' if it is already defined by Active Record, but
+      # A method name is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
       def dangerous_attribute_method?(name) # :nodoc:
         method_defined_within?(name, Base)
       end
 
-      def method_defined_within?(name, klass, sup = klass.superclass) # :nodoc:
+      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
         if klass.method_defined?(name) || klass.private_method_defined?(name)
-          if sup.method_defined?(name) || sup.private_method_defined?(name)
-            klass.instance_method(name).owner != sup.instance_method(name).owner
+          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
+            klass.instance_method(name).owner != superklass.instance_method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # A class method is 'dangerous' if it is already (re)defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
+      def dangerous_class_method?(method_name)
+        class_method_defined_within?(method_name, Base)
+      end
+
+      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc
+        if klass.respond_to?(name, true)
+          if superklass.respond_to?(name, true)
+            klass.method(name).owner != superklass.method(name).owner
           else
             true
           end
@@ -260,6 +278,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, Date and Time attributes are returned in the
@@ -330,7 +353,7 @@ module ActiveRecord
     end
 
     # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-    # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)). It raises
+    # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
     # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
     #
     # Alias for the <tt>read_attribute</tt> method.

data/lib/active_record/attribute_methods/dirty.rb

@@ -38,11 +38,37 @@ module ActiveRecord
         end
       end
 
+    def initialize_dup(other) # :nodoc:
+      super
+      init_changed_attributes
+    end
+
     private
+      def initialize_internals_callback
+        super
+        init_changed_attributes
+      end
+
+      def init_changed_attributes
+        @changed_attributes = nil
+        # Intentionally avoid using #column_defaults since overridden defaults (as is done in
+        # optimistic locking) won't get written unless they get marked as changed
+        self.class.columns.each do |c|
+          attr, orig_value = c.name, c.default
+          changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
+        end
+      end
+
       # Wrap write_attribute to remember original attribute value.
       def write_attribute(attr, value)
         attr = attr.to_s
 
+        save_changed_attribute(attr, value)
+
+        super(attr, value)
+      end
+
+      def save_changed_attribute(attr, value)
         # The attribute already has an unsaved change.
         if attribute_changed?(attr)
           old = changed_attributes[attr]
@@ -51,9 +77,6 @@ module ActiveRecord
           old = clone_attribute_value(:read_attribute, attr)
           changed_attributes[attr] = old if _field_changed?(attr, old, value)
         end
-
-        # Carry on.
-        super(attr, value)
       end
 
       def update_record(*)
@@ -67,7 +90,7 @@ module ActiveRecord
       # Serialized attributes should always be written in case they've been
       # changed in place.
       def keys_for_partial_write
-        changed | (attributes.keys & self.class.serialized_attributes.keys)
+        changed
       end
 
       def _field_changed?(attr, old, value)

data/lib/active_record/attribute_methods/read.rb

@@ -102,7 +102,7 @@ module ActiveRecord
       end
 
       # Returns the value of the attribute identified by <tt>attr_name</tt> after
-      # it has been typecast (for example, "2004-12-12" in a data column is cast
+      # it has been typecast (for example, "2004-12-12" in a date column is cast
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name)
         # If it's cached, just return it

data/lib/active_record/attribute_methods/serialization.rb

@@ -115,6 +115,14 @@ module ActiveRecord
           end
         end
 
+        def should_record_timestamps?
+          super || (self.record_timestamps && (attributes.keys & self.class.serialized_attributes.keys).present?)
+        end
+
+        def keys_for_partial_write
+          super | (attributes.keys & self.class.serialized_attributes.keys)
+        end
+
         def type_cast_attribute_for_write(column, value)
           if column && coder = self.class.serialized_attributes[column.name]
             Attribute.new(coder, value, :unserialized)
@@ -156,6 +164,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

@@ -301,7 +301,7 @@ module ActiveRecord
       def association_valid?(reflection, record)
         return true if record.destroyed? || record.marked_for_destruction?
 
-        unless valid = record.valid?
+        unless valid = record.valid?(self.validation_context)
           if reflection.options[:autosave]
             record.errors.each do |attribute, message|
               attribute = "#{reflection.name}.#{attribute}"

data/lib/active_record/base.rb

@@ -294,6 +294,7 @@ module ActiveRecord #:nodoc:
     extend Enum
     extend Delegation::DelegateCache
 
+    include Core
     include Persistence
     include NoTouching
     include ReadonlyAttributes
@@ -320,7 +321,6 @@ module ActiveRecord #:nodoc:
     include Reflection
     include Serialization
     include Store
-    include Core
   end
 
   ActiveSupport.run_load_hooks(:active_record, Base)

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

@@ -86,7 +86,7 @@ module ActiveRecord
           end
         end
 
-        # Return the number of threads currently waiting on this
+        # Returns the number of threads currently waiting on this
         # queue.
         def num_waiting
           synchronize do
@@ -393,7 +393,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

@@ -20,6 +20,14 @@ module ActiveRecord
 
       # Returns an ActiveRecord::Result instance.
       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
 
@@ -39,13 +47,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)
-        select_rows(to_sql(arel, []), name)
-          .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
 
@@ -286,10 +297,6 @@ module ActiveRecord
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
-        execute fixture_sql(fixture, table_name), 'Fixture Insert'
-      end
-
-      def fixture_sql(fixture, table_name)
         columns = schema_cache.columns_hash(table_name)
 
         key_list   = []
@@ -298,7 +305,7 @@ module ActiveRecord
           quote(value, columns[name])
         end
 
-        "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})"
+        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
       end
 
       def empty_insert_statement_value
@@ -346,7 +353,7 @@ module ActiveRecord
 
       protected
 
-        # Return a subquery for the given key using the join information.
+        # Returns a subquery for the given key using the join information.
         def subquery_for(key, select)
           subselect = select.clone
           subselect.projections = [key]