activerecord 1.3.0 → 1.4.0

data/lib/active_record/vendor/mysql.rb

@@ -1091,7 +1091,7 @@ class << Mysql
       when "\0" then "\\0"
       when "\n" then "\\n"
       when "\r" then "\\r"
-      when "\032" then "\Z"
+      when "\032" then "\\Z"
       else "\\"+$1
       end
     end

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.3.0' + PKG_BUILD
+PKG_VERSION   = '1.4.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 PKG_FILES = FileList[
@@ -45,6 +45,18 @@ Rake::TestTask.new("test_sqlite") { |t|
   t.verbose = true
 }
 
+Rake::TestTask.new("test_sqlserver") { |t|
+  t.libs << "test" << "test/connections/native_sqlserver"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
+Rake::TestTask.new("test_db2") { |t|
+  t.libs << "test" << "test/connections/native_db2"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
 # Generate the RDoc documentation
 
 Rake::RDocTask.new { |rdoc|
@@ -61,14 +73,14 @@ Rake::RDocTask.new { |rdoc|
 # Publish beta gem
 desc "Publish the beta gem"
 task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("davidhh@one.textdrive.com", "domains/rubyonrails.org/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh davidhh@one.textdrive.com './gemupdate.sh'`
+  Rake::SshFilePublisher.new("davidhh@comox.textdrive.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@comox.textdrive.com './gemupdate.sh'`
 end
 
 # Publish documentation
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@one.textdrive.com", "domains/rubyonrails.org/ar", "doc").upload
+  Rake::SshDirPublisher.new("davidhh@comox.textdrive.com", "public_html/ar", "doc").upload
 end
 
 
@@ -96,7 +108,7 @@ spec = Gem::Specification.new do |s|
   
   s.author = "David Heinemeier Hansson"
   s.email = "david@loudthinking.com"
-  s.homepage = "http://activerecord.rubyonrails.org"
+  s.homepage = "http://www.rubyonrails.com"
   s.rubyforge_project = "activerecord"
 end
   

data/test/associations_test.rb

@@ -149,6 +149,10 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     @signals37.clients_of_firm.each {|f| }
   end
   
+  def test_counting
+    assert_equal 2, Firm.find_first.clients.count
+  end
+  
   def test_finding
     assert_equal 2, Firm.find_first.clients.length
   end
@@ -183,9 +187,31 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 0, Firm.find_first.clients_using_zero_counter_sql.size
   end
 
+  def test_find_ids
+    firm = Firm.find_first
+
+    assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find }
+
+    client = firm.clients.find(2)
+    assert_kind_of Client, client
+
+    client_ary = firm.clients.find([2])
+    assert_kind_of Array, client_ary
+    assert_equal client, client_ary.first
+
+    client_ary = firm.clients.find(2, 3)
+    assert_kind_of Array, client_ary
+    assert_equal 2, client_ary.size
+    assert_equal client, client_ary.first
+
+    assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) }
+  end
+
   def test_find_all
-    assert_equal 2, Firm.find_first.clients.find_all("type = 'Client'").length
-    assert_equal 1, Firm.find_first.clients.find_all("name = 'Summit'").length
+    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
   end
 
   def test_find_all_sanitized
@@ -193,9 +219,18 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal firm.clients.find_all("name = 'Summit'"), firm.clients.find_all(["name = '%s'", "Summit"])
   end
 
+  def test_find_first
+    firm = Firm.find_first
+    assert_equal firm.clients.first, firm.clients.find_first
+    assert_equal Client.find(2), firm.clients.find_first("type = 'Client'")
+  end
+
+  def test_find_first_sanitized
+    assert_equal Client.find(2), Firm.find_first.clients.find_first(["type = ?", "Client"])
+  end
+
   def test_find_in_collection
     assert_equal Client.find(2).name, @signals37.clients.find(2).name
-    assert_equal Client.find(2).name, @signals37.clients.find {|c| c.name == @signals37.clients.find(2).name }.name
     assert_raises(ActiveRecord::RecordNotFound) { @signals37.clients.find(6) }
   end
 
@@ -519,7 +554,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
 
   def test_removing_associations_on_destroy
     Developer.find(1).destroy
-    assert Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = '1'").empty?
+    assert Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
   end
   
   def test_additional_columns_from_join_table

data/test/base_test.rb

@@ -119,7 +119,7 @@ class BasicsTest < Test::Unit::TestCase
   def test_update
     topic = Topic.new
     topic.title = "Another New Topic"
-    topic.written_on = "2003-12-12 23:23"
+    topic.written_on = "2003-12-12 23:23:00"
     topic.save
     id = topic.id
     assert_equal(id, topic.id)
@@ -162,7 +162,7 @@ class BasicsTest < Test::Unit::TestCase
   def test_destroy
     topic = Topic.new
     topic.title = "Yet Another New Topic"
-    topic.written_on = "2003-12-12 23:23"
+    topic.written_on = "2003-12-12 23:23:00"
     topic.save
     id = topic.id
     topic.destroy
@@ -327,7 +327,16 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal 1, topic.approved
     assert_nil topic.last_read
   end
-  
+
+  def test_utc_as_time_zone
+    Topic.default_timezone = :utc
+    attributes = { "bonus_time" => "5:42:00AM" }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
+    Topic.default_timezone = :local
+  end
+
   def test_default_values_on_empty_strings
     topic = Topic.new
     topic.approved  = nil
@@ -576,4 +585,4 @@ class BasicsTest < Test::Unit::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { Topic.find(1) }
     assert_nothing_raised { Reply.find(should_be_destroyed_reply.id) }
   end
-end
+end

data/test/binary_test.rb

@@ -0,0 +1,43 @@
+require 'abstract_unit'
+require 'fixtures/binary'
+
+class BinaryTest < Test::Unit::TestCase
+  def setup
+    @data = create_data_fixture
+  end
+  
+  def test_load_save
+    # Without using prepared statements, it makes no sense to test
+    # BLOB data with DB2, because the length of a statement is
+    # limited to 32KB.
+    if ActiveRecord::ConnectionAdapters.const_defined? :DB2Adapter
+      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::DB2Adapter)
+    end
+    bin = Binary.new
+    bin.data = @data
+
+    assert bin.data == @data,
+      "Assigned data differs from file data"
+        
+    bin.save
+
+    assert bin.data == @data,
+      "Assigned data differs from file data after save"
+
+    db_bin = Binary.find(bin.id)
+
+    assert db_bin.data == bin.data,
+      "Loaded binary data differes from memory version"
+    
+    assert db_bin.data == File.new(File.dirname(__FILE__)+"/fixtures/associations.png","rb").read, 
+      "Loaded binary data differes from file version"
+  end
+  
+  private
+  
+  def create_data_fixture
+    Binary.connection.execute("DELETE FROM binaries")
+    File.new(File.dirname(__FILE__)+"/fixtures/associations.png","rb").read
+  end
+  
+end

data/test/callbacks_test.rb

@@ -0,0 +1,230 @@
+require 'abstract_unit'
+
+class CallbackDeveloper < ActiveRecord::Base
+  class << self
+    def table_name; 'developers' end
+
+    def callback_string(callback_method)
+      "history << [#{callback_method.to_sym.inspect}, :string]"
+    end
+
+    def callback_proc(callback_method)
+      Proc.new { |model| model.history << [callback_method, :proc] }
+    end
+
+    def define_callback_method(callback_method)
+      define_method("#{callback_method}_method") do |model|
+        model.history << [callback_method, :method]
+      end
+    end
+
+    def callback_object(callback_method)
+      klass = Class.new
+      klass.send(:define_method, callback_method) do |model|
+        model.history << [callback_method, :object]
+      end
+      klass.new
+    end
+  end
+
+  ActiveRecord::Callbacks::CALLBACKS.each do |callback_method|
+    callback_method_sym = callback_method.to_sym
+    define_callback_method(callback_method_sym)
+    send(callback_method, callback_method_sym)
+    send(callback_method, callback_string(callback_method_sym))
+    send(callback_method, callback_proc(callback_method_sym))
+    send(callback_method, callback_object(callback_method_sym))
+    send(callback_method) { |model| model.history << [callback_method_sym, :block] }
+  end
+
+  def history
+    @history ||= []
+  end
+
+  # after_initialize and after_find may not be declared using class methods.
+  # They are invoked only if instance methods have been defined.
+  def after_initialize
+    history << [:after_initialize, :method]
+  end
+
+  def after_find
+    history << [:after_find, :method]
+  end
+end
+
+
+class CallbacksTest < Test::Unit::TestCase
+  def setup
+    @developers = create_fixtures('developers')
+  end
+
+  def test_initialize
+    david = CallbackDeveloper.new
+    assert_equal [
+      [ :after_initialize,            :method ]
+    ], david.history
+  end
+
+  def test_find
+    david = CallbackDeveloper.find(1)
+    assert_equal [
+      [ :after_find,                  :method ],
+      [ :after_initialize,            :method ]
+    ], david.history
+  end
+
+  def test_new_valid?
+    david = CallbackDeveloper.new
+    david.valid?
+    assert_equal [
+      [ :after_initialize,            :method ],
+      [ :before_validation,           :string ],
+      [ :before_validation,           :proc   ],
+      [ :before_validation,           :object ],
+      [ :before_validation,           :block  ],
+      [ :before_validation_on_create, :string ],
+      [ :before_validation_on_create, :proc   ],
+      [ :before_validation_on_create, :object ],
+      [ :before_validation_on_create, :block  ],
+      [ :after_validation,            :string ],
+      [ :after_validation,            :proc   ],
+      [ :after_validation,            :object ],
+      [ :after_validation,            :block  ],
+      [ :after_validation_on_create,  :string ],
+      [ :after_validation_on_create,  :proc   ],
+      [ :after_validation_on_create,  :object ],
+      [ :after_validation_on_create,  :block  ]
+    ], david.history
+  end
+
+  def test_existing_valid?
+    david = CallbackDeveloper.find(1)
+    david.valid?
+    assert_equal [
+      [ :after_find,                  :method ],
+      [ :after_initialize,            :method ],
+      [ :before_validation,           :string ],
+      [ :before_validation,           :proc   ],
+      [ :before_validation,           :object ],
+      [ :before_validation,           :block  ],
+      [ :before_validation_on_update, :string ],
+      [ :before_validation_on_update, :proc   ],
+      [ :before_validation_on_update, :object ],
+      [ :before_validation_on_update, :block  ],
+      [ :after_validation,            :string ],
+      [ :after_validation,            :proc   ],
+      [ :after_validation,            :object ],
+      [ :after_validation,            :block  ],
+      [ :after_validation_on_update,  :string ],
+      [ :after_validation_on_update,  :proc   ],
+      [ :after_validation_on_update,  :object ],
+      [ :after_validation_on_update,  :block  ]
+    ], david.history
+  end
+
+  def test_create
+    david = CallbackDeveloper.create('name' => 'David', 'salary' => 1000000)
+    assert_equal [
+      [ :after_initialize,            :method ],
+      [ :before_validation,           :string ],
+      [ :before_validation,           :proc   ],
+      [ :before_validation,           :object ],
+      [ :before_validation,           :block  ],
+      [ :before_validation_on_create, :string ],
+      [ :before_validation_on_create, :proc   ],
+      [ :before_validation_on_create, :object ],
+      [ :before_validation_on_create, :block  ],
+      [ :after_validation,            :string ],
+      [ :after_validation,            :proc   ],
+      [ :after_validation,            :object ],
+      [ :after_validation,            :block  ],
+      [ :after_validation_on_create,  :string ],
+      [ :after_validation_on_create,  :proc   ],
+      [ :after_validation_on_create,  :object ],
+      [ :after_validation_on_create,  :block  ],
+      [ :before_save,                 :string ],
+      [ :before_save,                 :proc   ],
+      [ :before_save,                 :object ],
+      [ :before_save,                 :block  ],
+      [ :before_create,               :string ],
+      [ :before_create,               :proc   ],
+      [ :before_create,               :object ],
+      [ :before_create,               :block  ],
+      [ :after_create,                :string ],
+      [ :after_create,                :proc   ],
+      [ :after_create,                :object ],
+      [ :after_create,                :block  ],
+      [ :after_save,                  :string ],
+      [ :after_save,                  :proc   ],
+      [ :after_save,                  :object ],
+      [ :after_save,                  :block  ]
+    ], david.history
+  end
+
+  def test_save
+    david = CallbackDeveloper.find(1)
+    david.save
+    assert_equal [
+      [ :after_find,                  :method ],
+      [ :after_initialize,            :method ],
+      [ :before_validation,           :string ],
+      [ :before_validation,           :proc   ],
+      [ :before_validation,           :object ],
+      [ :before_validation,           :block  ],
+      [ :before_validation_on_update, :string ],
+      [ :before_validation_on_update, :proc   ],
+      [ :before_validation_on_update, :object ],
+      [ :before_validation_on_update, :block  ],
+      [ :after_validation,            :string ],
+      [ :after_validation,            :proc   ],
+      [ :after_validation,            :object ],
+      [ :after_validation,            :block  ],
+      [ :after_validation_on_update,  :string ],
+      [ :after_validation_on_update,  :proc   ],
+      [ :after_validation_on_update,  :object ],
+      [ :after_validation_on_update,  :block  ],
+      [ :before_save,                 :string ],
+      [ :before_save,                 :proc   ],
+      [ :before_save,                 :object ],
+      [ :before_save,                 :block  ],
+      [ :before_update,               :string ],
+      [ :before_update,               :proc   ],
+      [ :before_update,               :object ],
+      [ :before_update,               :block  ],
+      [ :after_update,                :string ],
+      [ :after_update,                :proc   ],
+      [ :after_update,                :object ],
+      [ :after_update,                :block  ],
+      [ :after_save,                  :string ],
+      [ :after_save,                  :proc   ],
+      [ :after_save,                  :object ],
+      [ :after_save,                  :block  ]
+    ], david.history
+  end
+
+  def test_destroy
+    david = CallbackDeveloper.find(1)
+    david.destroy
+    assert_equal [
+      [ :after_find,                  :method ],
+      [ :after_initialize,            :method ],
+      [ :before_destroy,              :string ],
+      [ :before_destroy,              :proc   ],
+      [ :before_destroy,              :object ],
+      [ :before_destroy,              :block  ],
+      [ :after_destroy,               :string ],
+      [ :after_destroy,               :proc   ],
+      [ :after_destroy,               :object ],
+      [ :after_destroy,               :block  ]
+    ], david.history
+  end
+
+  def test_delete
+    david = CallbackDeveloper.find(1)
+    CallbackDeveloper.delete(david.id)
+    assert_equal [
+      [ :after_find,                  :method ],
+      [ :after_initialize,            :method ]
+    ], david.history
+  end
+end