activerecord 1.15.5 → 1.15.6

data/CHANGELOG

@@ -1,3 +1,12 @@
+*1.15.6* (November 24th, 2007)
+
+* Allow association redefinition in subclasses.  #9346 [wildchild]
+
+* Fix has_many :through delete with custom foreign keys.  #6466 [naffis]
+
+* Fix regression where the association would not construct new finder SQL on save causing bogus queries for "WHERE owner_id = NULL" even after owner was saved.  #8713 [Bryan Helmkamp]
+
+
 *1.15.5* (October 12th, 2007)
 
 * Depend on Action Pack 1.4.4

data/lib/active_record/associations.rb

@@ -50,6 +50,12 @@ module ActiveRecord
     end
   end
 
+  class HasManyThroughCantDissociateNewRecords < ActiveRecordError #:nodoc:
+    def initialize(owner, reflection)
+      super("Cannot dissociate new records through '#{owner.class.name}##{reflection.name}' on '#{reflection.source_reflection.class_name rescue nil}##{reflection.source_reflection.name rescue nil}'. Both records must have an id in order to delete the has_many :through record associating them.")
+    end
+  end
+  
   class EagerLoadPolymorphicError < ActiveRecordError #:nodoc:
     def initialize(reflection)
       super("Can not eagerly load the polymorphic association #{reflection.name.inspect}")
@@ -862,7 +868,7 @@ module ActiveRecord
         # Don't use a before_destroy callback since users' before_destroy
         # callbacks will be executed after the association is wiped out.
         old_method = "destroy_without_habtm_shim_for_#{reflection.name}"
-        class_eval <<-end_eval
+        class_eval <<-end_eval unless method_defined?(old_method)
           alias_method :#{old_method}, :destroy_without_callbacks
           def destroy_without_callbacks
             #{reflection.name}.clear
@@ -1002,10 +1008,10 @@ module ActiveRecord
               []
             end
 
-            if !records_to_save.blank?
-              records_to_save.each { |record| association.send(:insert_record, record) }
-              association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
-            end
+            records_to_save.each { |record| association.send(:insert_record, record) } unless records_to_save.blank?
+            
+            # reconstruct the SQL queries now that we know the owner's id
+            association.send(:construct_sql) if association.respond_to?(:construct_sql)
           end_eval
 
           # Doesn't use after_save as that would save associations added in after_create/after_update twice
@@ -1286,7 +1292,9 @@ module ActiveRecord
             defined_callbacks = options[callback_name.to_sym]
             if options.has_key?(callback_name.to_sym)
               class_inheritable_reader full_callback_name.to_sym
-              write_inheritable_array(full_callback_name.to_sym, [defined_callbacks].flatten)
+              write_inheritable_attribute(full_callback_name.to_sym, [defined_callbacks].flatten)
+            else
+              write_inheritable_attribute(full_callback_name.to_sym, [])
             end
           end
         end

data/lib/active_record/associations/has_many_through_association.rb

@@ -71,20 +71,26 @@ module ActiveRecord
 
       # Remove +records+ from this association.  Does not destroy +records+.
       def delete(*records)
-        records = flatten_deeper(records)
-        records.each { |associate| raise_on_type_mismatch(associate) }
-        records.reject! { |associate| @target.delete(associate) if associate.new_record? }
         return if records.empty?
-        
-        @delete_join_finder ||= "find_all_by_#{@reflection.source_reflection.association_foreign_key}"
+        records.each { |associate| raise_on_type_mismatch(associate) }
+
         through = @reflection.through_reflection
-        through.klass.transaction do
-          records.each do |associate|
-            joins = @owner.send(through.name).send(@delete_join_finder, associate.id)
-            @owner.send(through.name).delete(joins)
+        raise ActiveRecord::HasManyThroughCantDissociateNewRecords.new(@owner, through) if @owner.new_record?
+
+        load_target
+
+        klass = through.klass
+        klass.transaction do
+          flatten_deeper(records).each do |associate|
+            raise_on_type_mismatch(associate)
+            raise ActiveRecord::HasManyThroughCantDissociateNewRecords.new(@owner, through) unless associate.respond_to?(:new_record?) && !associate.new_record?
+
+            @owner.send(@reflection.through_reflection.name).proxy_target.delete(klass.delete_all(construct_join_attributes(associate)))
             @target.delete(associate)
           end
         end
+
+        self
       end
 
       def build(attrs = nil)

data/lib/active_record/version.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 15
-    TINY  = 5
+    TINY  = 6
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/aggregations_test.rb

@@ -93,3 +93,21 @@ class AggregationsTest < Test::Unit::TestCase
     assert_raises(NoMethodError) { customers(:david).balance = nil }
   end
 end
+
+class OverridingAggregationsTest < Test::Unit::TestCase
+  class Name; end
+  class DifferentName; end
+
+  class Person   < ActiveRecord::Base
+    composed_of :composed_of, :mapping => %w(person_first_name first_name)
+  end
+
+  class DifferentPerson < Person
+    composed_of :composed_of, :class_name => 'DifferentName', :mapping => %w(different_person_first_name first_name)
+  end
+
+  def test_composed_of_aggregation_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal Person.reflect_on_aggregation(:composed_of),
+                     DifferentPerson.reflect_on_aggregation(:composed_of)
+  end
+end

data/test/associations/join_model_test.rb

@@ -8,10 +8,12 @@ require 'fixtures/category'
 require 'fixtures/categorization'
 require 'fixtures/vertex'
 require 'fixtures/edge'
+require 'fixtures/book'
+require 'fixtures/citation'
 
 class AssociationsJoinModelTest < Test::Unit::TestCase
   self.use_transactional_fixtures = false
-  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices
+  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :books
 
   def test_has_many
     assert authors(:david).categories.include?(categories(:general))
@@ -450,7 +452,21 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     tags = posts(:thinking).tags
     assert_equal tags, posts(:thinking).tags.push(tags(:general))
   end
-
+  
+  def test_delete_associate_when_deleting_from_has_many_through_with_non_standard_id
+    count = books(:awdr).references.count
+    references_before = books(:awdr).references
+    book = Book.create!(:name => 'Getting Real')
+    book_awdr = books(:awdr)
+    book_awdr.references << book
+    assert_equal(count + 1, book_awdr.references(true).size)
+
+    assert_nothing_raised { book_awdr.references.delete(book) }
+    assert_equal(count, book_awdr.references.size)
+    assert_equal(count, book_awdr.references(true).size)
+    assert_equal(references_before.sort, book_awdr.references.sort)
+  end
+  
   def test_delete_associate_when_deleting_from_has_many_through
     count = posts(:thinking).tags.count
     tags_before = posts(:thinking).tags

data/test/associations_test.rb

@@ -10,6 +10,8 @@ require 'fixtures/order'
 require 'fixtures/category'
 require 'fixtures/post'
 require 'fixtures/author'
+require 'fixtures/person'
+require 'fixtures/reader'
 
 
 class AssociationsTest < Test::Unit::TestCase
@@ -21,6 +23,14 @@ class AssociationsTest < Test::Unit::TestCase
       Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels')
     end
   end
+  
+  def test_should_construct_new_finder_sql_after_create
+    person = Person.new
+    assert_equal [], person.readers.find(:all)
+    person.save!
+    reader = Reader.create! :person => person, :post => Post.new(:title => "foo", :body => "bar")
+    assert_equal [reader], person.readers.find(:all)
+  end
 
   def test_force_reload
     firm = Firm.new("name" => "A New Firm, Inc")
@@ -1840,3 +1850,68 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal %w(1 2), projects.scan(/\d/).sort
   end
 end
+
+
+class OverridingAssociationsTest < Test::Unit::TestCase
+  class Person < ActiveRecord::Base; end
+  class DifferentPerson < ActiveRecord::Base; end
+
+  class PeopleList < ActiveRecord::Base
+    has_and_belongs_to_many :has_and_belongs_to_many, :before_add => :enlist
+    has_many :has_many, :before_add => :enlist
+    belongs_to :belongs_to
+    has_one :has_one
+  end
+
+  class DifferentPeopleList < PeopleList
+    # Different association with the same name, callbacks should be omitted here.
+    has_and_belongs_to_many :has_and_belongs_to_many, :class_name => 'DifferentPerson'
+    has_many :has_many, :class_name => 'DifferentPerson'
+    belongs_to :belongs_to, :class_name => 'DifferentPerson', :foreign_key => 'belongs_to_id'
+    has_one :has_one, :class_name => 'DifferentPerson'
+  end
+
+  def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited
+    # redeclared association on AR descendant should not inherit callbacks from superclass
+    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    assert_equal([:enlist], callbacks)
+    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    assert_equal([], callbacks)
+  end
+
+  def test_has_many_association_redefinition_callbacks_should_differ_and_not_inherited
+    # redeclared association on AR descendant should not inherit callbacks from superclass
+    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    assert_equal([:enlist], callbacks)
+    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    assert_equal([], callbacks)
+  end
+
+  def test_habtm_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_and_belongs_to_many),
+      DifferentPeopleList.reflect_on_association(:has_and_belongs_to_many)
+    )
+  end
+
+  def test_has_many_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_many),
+      DifferentPeopleList.reflect_on_association(:has_many)
+    )
+  end
+
+  def test_belongs_to_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:belongs_to),
+      DifferentPeopleList.reflect_on_association(:belongs_to)
+    )
+  end
+
+  def test_has_one_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_one),
+      DifferentPeopleList.reflect_on_association(:has_one)
+    )
+  end
+end

data/test/fixtures/book.rb

@@ -0,0 +1,4 @@
+class Book < ActiveRecord::Base
+  has_many :citations, :foreign_key => 'book1_id'
+  has_many :references, :through => :citations, :source => :reference_of, :uniq => true
+end

data/test/fixtures/books.yml

@@ -0,0 +1,7 @@
+awdr:
+  id: 1
+  name: "Agile Web Development with Rails"
+
+rfr:
+  id: 2
+  name: "Ruby for Rails"

data/test/fixtures/citation.rb

@@ -0,0 +1,6 @@
+class Citation < ActiveRecord::Base
+  belongs_to :reference_of, :class_name => "Book", :foreign_key => :book2_id
+
+  belongs_to :book1, :class_name => "Book", :foreign_key => :book1_id
+  belongs_to :book2, :class_name => "Book", :foreign_key => :book2_id
+end

data/test/fixtures/db_definitions/schema.rb

@@ -62,4 +62,13 @@ ActiveRecord::Schema.define do
     t.column :message, :string, :null=>false
     t.column :developer_id, :integer, :null=>false
   end
+
+  create_table :books, :force => true do |t|
+    t.column :name, :string
+  end
+
+  create_table :citations, :force => true do |t|
+    t.column :book1_id, :integer
+    t.column :book2_id, :integer
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 1.15.5
-date: 2007-10-12 00:00:00 -05:00
+  version: 1.15.6
+date: 2007-11-24 00:00:00 +13:00
 summary: Implements the ActiveRecord pattern for ORM.
 require_paths: 
 - lib
@@ -169,6 +169,8 @@ files:
 - test/fixtures/bad_fixtures/missing_value
 - test/fixtures/binaries.yml
 - test/fixtures/binary.rb
+- test/fixtures/book.rb
+- test/fixtures/books.yml
 - test/fixtures/categories
 - test/fixtures/categories/special_categories.yml
 - test/fixtures/categories/subsubdir
@@ -179,6 +181,7 @@ files:
 - test/fixtures/categorization.rb
 - test/fixtures/categorizations.yml
 - test/fixtures/category.rb
+- test/fixtures/citation.rb
 - test/fixtures/column_name.rb
 - test/fixtures/comment.rb
 - test/fixtures/comments.yml