activerecord 1.9.1 → 1.10.0

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.9.1' + PKG_BUILD
+PKG_VERSION   = '1.10.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -38,7 +38,7 @@ Rake::TestTask.new("test_mysql_ruby") { |t|
   t.verbose = true
 }
 
-for adapter in %( postgresql sqlite sqlite3 sqlserver db2 oci )
+for adapter in %w( postgresql sqlite sqlite3 sqlserver db2 oci )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
     t.pattern = 'test/*_test.rb'
@@ -76,7 +76,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.0.3' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.0.4' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"
@@ -101,18 +101,42 @@ Rake::GemPackageTask.new(spec) do |p|
   p.need_zip = true
 end
 
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/active_record/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
 
 # Publishing ------------------------------------------------------
 
 desc "Publish the beta gem"
 task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("davidhh@comox.textdrive.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh davidhh@comox.textdrive.com './gemupdate.sh'`
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.com './gemupdate.sh'`
 end
 
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@comox.textdrive.com", "public_html/ar", "doc").upload
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.com", "public_html/ar", "doc").upload
 end
 
 desc "Publish the release files to RubyForge."

data/test/associations_go_eager_test.rb

@@ -0,0 +1,55 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+
+class EagerAssociationTest < Test::Unit::TestCase
+  fixtures :posts, :comments, :authors, :categories, :categories_posts
+
+  def test_loading_with_one_association
+    posts = Post.find(:all, :include => :comments)
+    assert_equal 2, posts.first.comments.size
+    assert posts.first.comments.include?(@greetings)
+
+    post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+    assert_equal 2, post.comments.size
+    assert post.comments.include?(@greetings)
+  end
+
+  def test_loading_with_multiple_associations
+    posts = Post.find(:all, :include => [ :comments, :author, :categories ], :order => "posts.id")
+    assert_equal 2, posts.first.comments.size
+    assert_equal 2, posts.first.categories.size
+    assert posts.first.comments.include?(@greetings)
+  end
+
+  def test_loading_from_an_association
+    posts = @david.posts.find(:all, :include => :comments)
+    assert_equal 2, posts.first.comments.size
+  end
+
+  def test_loading_with_no_associations
+    assert_nil Post.find(@authorless.id, :include => :author).author
+  end
+
+  def test_eager_association_loading_with_belongs_to
+    comments = Comment.find(:all, :include => :post)
+    assert_equal @welcome.title, comments.first.post.title
+    assert_equal @thinking.title, comments.last.post.title
+  end
+
+  def test_eager_association_loading_with_habtm
+    posts = Post.find(:all, :include => :categories, :order => "posts.id")
+    assert_equal 2, posts[0].categories.size
+    assert_equal 1, posts[1].categories.size
+    assert_equal 0, posts[2].categories.size
+    assert posts[0].categories.include?(@technology)
+    assert posts[1].categories.include?(@general)
+  end
+  
+  def test_eager_with_inheritance
+    posts = SpecialPost.find(:all, :include => [ :comments ])
+  end  
+end
+

data/test/associations_test.rb

@@ -105,6 +105,30 @@ class HasOneAssociationsTest < Test::Unit::TestCase
     assert_equal 1, Account.find_all.length
   end
 
+  def test_succesful_build_association
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    firm.save
+
+    account = firm.build_account("credit_limit" => 1000)
+    assert account.save
+    assert_equal account, firm.account
+  end
+
+  def test_failing_build_association
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    firm.save
+
+    account = firm.build_account
+    assert !account.save
+    assert_equal "can't be empty", account.errors.on("credit_limit")
+  end
+
+  def test_create_association
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    firm.save
+    assert_equal firm.create_account("credit_limit" => 1000), firm.account
+  end
+
   def test_build
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
@@ -203,8 +227,9 @@ end
 
 
 class HasManyAssociationsTest < Test::Unit::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects, :topics
+  
   def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects", "topics"
     @signals37 = Firm.find(1)
   end
   
@@ -249,6 +274,10 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 1, Firm.find_first.clients_using_counter_sql.size
     assert_equal 0, Firm.find_first.clients_using_zero_counter_sql.size
   end
+
+  def test_counting_non_existant_items_using_sql
+    assert_equal 0, Firm.find_first.no_clients_using_counter_sql.size
+  end
   
   def test_belongs_to_sanity
     c = Client.new
@@ -288,8 +317,8 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   def test_find_all
     firm = Firm.find_first
     assert_equal firm.clients, firm.clients.find_all
-    assert_equal 2, firm.clients.find_all("type = 'Client'").length
-    assert_equal 1, firm.clients.find_all("name = 'Summit'").length
+    assert_equal 2, firm.clients.find(:all, :conditions => "type = 'Client'").length
+    assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length
   end
 
   def test_find_all_sanitized
@@ -481,9 +510,21 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_dependence
-    assert_equal 2, Client.find_all.length
+    assert_equal 2, Client.find_all.size
     Firm.find_first.destroy
-    assert_equal 0, Client.find_all.length
+    assert Client.find_all.empty?
+  end
+
+  def test_destroy_dependent_when_deleted_from_association
+    firm = Firm.find_first
+    assert_equal 2, firm.clients.size
+
+    client = firm.clients.first
+    firm.clients.delete(client)
+
+    assert_raise(ActiveRecord::RecordNotFound) { Client.find(client.id) }
+    assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(client.id) }
+    assert_equal 1, firm.clients.size
   end
 
   def test_three_levels_of_dependence
@@ -546,6 +587,19 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_equal apple.id, citibank.firm_id
   end
   
+  def test_creating_the_belonging_object
+    citibank = Account.create("credit_limit" => 10)
+    apple    = citibank.create_firm("name" => "Apple")
+    assert_equal apple, citibank.firm
+  end
+
+  def test_building_the_belonging_object
+    citibank = Account.create("credit_limit" => 10)
+    apple    = citibank.build_firm("name" => "Apple")
+    citibank.save
+    assert_equal apple.id, citibank.firm_id
+  end
+  
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
@@ -615,7 +669,7 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
 
   def test_new_record_with_foreign_key_but_no_object
     c = Client.new("firm_id" => 1)
-    assert_equal @first_firm, c.firm_with_basic_id
+    assert_equal Firm.find_first, c.firm_with_basic_id
   end
 
   def test_forgetting_the_load_when_foreign_key_enters_late
@@ -623,12 +677,12 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_nil c.firm_with_basic_id
 
     c.firm_id = 1
-    assert_equal @first_firm, c.firm_with_basic_id
+    assert_equal Firm.find_first, c.firm_with_basic_id
   end
 
   def test_field_name_same_as_foreign_key
     computer = Computer.find 1
-    assert_not_nil computer.developer, ":foreign key == attribute didn't lock up"
+    assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
   end
 
   def xtest_counter_cache
@@ -651,12 +705,7 @@ end
 
 
 class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
-  def setup
-    @accounts, @companies, @developers, @projects, @developers_projects = 
-      create_fixtures "accounts", "companies", "developers", "projects", "developers_projects"
-
-    @signals37 = Firm.find(1)
-  end
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects
   
   def test_has_and_belongs_to_many
     david = Developer.find(1)
@@ -860,4 +909,12 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     @active_record.developers.reload
     assert_equal @developers["david"].find, @active_record.developers.find(@developers["david"]["id"]), "Ruby find"
   end
-end
+
+  def xtest_find_in_association_with_options
+    developers = @active_record.developers.find(:all)
+    assert_equal 2, developers.size
+    
+    assert_equal @david, @active_record.developers.find(:first, :conditions => "salary < 10000")
+    assert_equal @jamis, @active_record.developers.find(:first, :order => "salary DESC")
+  end
+end

data/test/base_test.rb

@@ -103,15 +103,14 @@ class BasicsTest < Test::Unit::TestCase
   end
  
   def test_attributes_hash
-    assert_equal @projects["action_controller"].to_hash, @action_controller.attributes
+    assert_equal @projects['active_record'].to_hash, Project.find_first.attributes
   end
-  
+
   def test_create
     topic = Topic.new
     topic.title = "New Topic"
     topic.save
-    id = topic.id
-    topicReloaded = Topic.find(id)
+    topicReloaded = Topic.find(topic.id)
     assert_equal("New Topic", topicReloaded.title)
   end
   
@@ -139,16 +138,13 @@ class BasicsTest < Test::Unit::TestCase
     topic.title = "Another New Topic"
     topic.written_on = "2003-12-12 23:23:00"
     topic.save
-    id = topic.id
-    assert_equal(id, topic.id)
-    
-    topicReloaded = Topic.find(id)
+    topicReloaded = Topic.find(topic.id)
     assert_equal("Another New Topic", topicReloaded.title)
 
     topicReloaded.title = "Updated topic"
     topicReloaded.save
     
-    topicReloadedAgain = Topic.find(id)
+    topicReloadedAgain = Topic.find(topic.id)
     
     assert_equal("Updated topic", topicReloadedAgain.title)
   end
@@ -157,9 +153,8 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.new
     topic.title = "Still another topic"
     topic.save
-    id = topic.id
     
-    topicReloaded = Topic.find(id)
+    topicReloaded = Topic.find(topic.id)
     topicReloaded.title = "A New Topic"
     topicReloaded.send :write_attribute, 'does_not_exist', 'test'
     assert_nothing_raised { topicReloaded.save }
@@ -198,10 +193,9 @@ class BasicsTest < Test::Unit::TestCase
     topic.title = "Yet Another New Topic"
     topic.written_on = "2003-12-12 23:23:00"
     topic.save
-    id = topic.id
     topic.destroy
-    
-    assert_raises(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(id) }
+    assert_raise(TypeError) { topic.save }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
   
   def test_record_not_found_exception
@@ -353,7 +347,7 @@ class BasicsTest < Test::Unit::TestCase
   def test_attribute_keys_on_new_instance
     t = Topic.new
     assert_equal nil, t.title, "The topics table has a title column, so it should be nil"
-    assert_raises(NoMethodError) { t.title2 }
+    assert_raise(NoMethodError) { t.title2 }
   end
   
   def test_class_name
@@ -644,7 +638,7 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.create("content" => myobj)
     Topic.serialize(:content, Hash)
 
-    assert_raises(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
 
     settings = { "color" => "blue" }
     Topic.find(topic.id).update_attribute("content", settings)
@@ -660,19 +654,19 @@ class BasicsTest < Test::Unit::TestCase
   
   def test_class_level_destroy
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
-    @first.replies << should_be_destroyed_reply
+    Topic.find(1).replies << should_be_destroyed_reply
 
     Topic.destroy(1)
-    assert_raises(ActiveRecord::RecordNotFound) { Topic.find(1) }
-    assert_raises(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
+    assert_raise(ActiveRecord::RecordNotFound) { Reply.find(should_be_destroyed_reply.id) }
   end
 
   def test_class_level_delete
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
-    @first.replies << should_be_destroyed_reply
+    Topic.find(1).replies << should_be_destroyed_reply
 
     Topic.delete(1)
-    assert_raises(ActiveRecord::RecordNotFound) { Topic.find(1) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_nothing_raised { Reply.find(should_be_destroyed_reply.id) }
   end
 

data/test/deprecated_associations_test.rb

@@ -174,30 +174,6 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
     assert_equal @signals37.create_in_clients_of_firm("name" => "Another Client"), @signals37.clients_of_firm(true).last
   end
 
-  def test_succesful_build_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-
-    account = firm.build_account("credit_limit" => 1000)
-    assert account.save
-    assert_equal account, firm.account
-  end
-
-  def test_failing_build_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-
-    account = firm.build_account
-    assert !account.save
-    assert_equal "can't be empty", account.errors.on("credit_limit")
-  end
-
-  def test_create_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    assert_equal firm.create_account("credit_limit" => 1000), firm.account
-  end
-
   def test_has_and_belongs_to_many
     david = Developer.find(1)
     assert david.has_projects?

data/test/deprecated_finder_test.rb

@@ -0,0 +1,147 @@
+require 'abstract_unit'
+require 'fixtures/company'
+require 'fixtures/topic'
+require 'fixtures/entrant'
+require 'fixtures/developer'
+
+class FinderTest < Test::Unit::TestCase
+  fixtures :companies, :topics, :entrants, :developers
+
+  def test_find_all_with_limit
+    entrants = Entrant.find_all nil, "id ASC", 2
+    
+    assert_equal(2, entrants.size)
+    assert_equal(@entrants["first"]["name"], entrants.first.name)
+  end
+
+  def test_find_all_with_prepared_limit_and_offset
+    if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
+      if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
+        assert_raises(ArgumentError) { Entrant.find_all nil, "id ASC", [2, 1] }
+      end
+    else
+      entrants = Entrant.find_all nil, "id ASC", [2, 1]
+
+      assert_equal(2, entrants.size)
+      assert_equal(@entrants["second"]["name"], entrants.first.name)
+    end
+  end
+
+  def test_find_first
+    first = Topic.find_first "title = 'The First Topic'"
+    assert_equal(@topics["first"]["title"], first.title)
+  end
+  
+  def test_find_first_failing
+    first = Topic.find_first "title = 'The First Topic!'"
+    assert_nil(first)
+  end
+  
+  def test_deprecated_find_on_conditions
+    assert Topic.find_on_conditions(1, "approved = 0")
+    assert_raises(ActiveRecord::RecordNotFound) { Topic.find_on_conditions(1, "approved = 1") }
+  end
+  
+  def test_condition_interpolation
+    assert_kind_of Firm, Company.find_first(["name = '%s'", "37signals"])
+    assert_nil Company.find_first(["name = '%s'", "37signals!"])
+    assert_nil Company.find_first(["name = '%s'", "37signals!' OR 1=1"])
+    assert_kind_of Time, Topic.find_first(["id = %d", 1]).written_on
+  end
+
+  def test_bind_variables
+    assert_kind_of Firm, Company.find_first(["name = ?", "37signals"])
+    assert_nil Company.find_first(["name = ?", "37signals!"])
+    assert_nil Company.find_first(["name = ?", "37signals!' OR 1=1"])
+    assert_kind_of Time, Topic.find_first(["id = ?", 1]).written_on
+    assert_raises(ActiveRecord::PreparedStatementInvalid) {
+      Company.find_first(["id=? AND name = ?", 2])
+    }
+    assert_raises(ActiveRecord::PreparedStatementInvalid) {
+	   Company.find_first(["id=?", 2, 3, 4])
+    }
+  end
+  
+  def test_bind_variables_with_quotes
+    Company.create("name" => "37signals' go'es agains")
+    assert Company.find_first(["name = ?", "37signals' go'es agains"])
+  end
+
+  def test_named_bind_variables_with_quotes
+    Company.create("name" => "37signals' go'es agains")
+    assert Company.find_first(["name = :name", {:name => "37signals' go'es agains"}])
+  end
+
+  def test_named_bind_variables
+    assert_equal '1', bind(':a', :a => 1) # ' ruby-mode
+    assert_equal '1 1', bind(':a :a', :a => 1)  # ' ruby-mode
+  
+    assert_kind_of Firm, Company.find_first(["name = :name", { :name => "37signals" }])
+    assert_nil Company.find_first(["name = :name", { :name => "37signals!" }])
+    assert_nil Company.find_first(["name = :name", { :name => "37signals!' OR 1=1" }])
+    assert_kind_of Time, Topic.find_first(["id = :id", { :id => 1 }]).written_on
+    assert_raises(ActiveRecord::PreparedStatementInvalid) {
+      Company.find_first(["id=:id and name=:name", { :id=>3 }])
+    }
+    assert_raises(ActiveRecord::PreparedStatementInvalid) {
+      Company.find_first(["id=:id", { :id=>3, :name=>"37signals!" }])
+    }
+  end
+
+  def test_count
+    assert_equal(0, Entrant.count("id > 3"))
+    assert_equal(1, Entrant.count(["id > ?", 2]))
+    assert_equal(2, Entrant.count(["id > ?", 1]))
+  end
+
+  def test_count_by_sql
+    assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
+    assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
+    assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1]))
+  end
+
+  def test_find_all_with_limit
+    first_five_developers = Developer.find_all nil, 'id ASC', 5
+    assert_equal 5, first_five_developers.length
+    assert_equal 'David', first_five_developers.first.name
+    assert_equal 'fixture_5', first_five_developers.last.name
+    
+    no_developers = Developer.find_all nil, 'id ASC', 0
+    assert_equal 0, no_developers.length
+    
+    assert_equal first_five_developers, Developer.find_all(nil, 'id ASC', [5])
+    assert_equal no_developers, Developer.find_all(nil, 'id ASC', [0])
+  end
+ 
+  def test_find_all_with_limit_and_offset
+    first_three_developers = Developer.find_all nil, 'id ASC', [3, 0]
+    second_three_developers = Developer.find_all nil, 'id ASC', [3, 3]
+    last_two_developers = Developer.find_all nil, 'id ASC', [2, 8]
+    
+    assert_equal 3, first_three_developers.length
+    assert_equal 3, second_three_developers.length
+    assert_equal 2, last_two_developers.length
+    
+    assert_equal 'David', first_three_developers.first.name
+    assert_equal 'fixture_4', second_three_developers.first.name
+    assert_equal 'fixture_9', last_two_developers.first.name
+  end
+
+  def test_find_all_by_one_attribute_with_options
+    topics = Topic.find_all_by_content("Have a nice day", nil, "id DESC")
+    assert @topics["first"].find, topics.last
+
+    topics = Topic.find_all_by_content("Have a nice day", nil, "id DESC")
+    assert @topics["first"].find, topics.first
+  end
+
+
+  protected
+    def bind(statement, *vars)
+      if vars.first.is_a?(Hash)
+        ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
+      else
+        ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
+      end
+    end
+end