activerecord 1.0.0 → 1.1.0

data/lib/active_record/deprecated_associations.rb

@@ -20,7 +20,7 @@ module ActiveRecord
     
        def deprecated_remove_association_relation(association_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
-          def remove_#{association_name}(items)
+          def remove_#{association_name}(*items)
             #{association_name}.delete(items)
           end
         end_eval

data/lib/active_record/fixtures.rb

@@ -1,4 +1,6 @@
 require 'yaml'
+require 'active_record/support/class_inheritable_attributes'
+require 'active_record/support/inflector'
 
 # Fixtures are a way of organizing data that you want to test against. Each fixture file is created as a row
 # in the database and created as a hash with column names as keys and data as values. All of these fixture hashes
@@ -31,6 +33,20 @@ require 'yaml'
 #     assert_equal @developers["david"]["name"], Developer.find(@developers["david"]["id"]).name
 #   end
 #
+# == Automatic fixture setup and instance variable availability
+#
+# Fixtures can also be automatically instantiated in instance variables relating to their names using the following style:
+#
+#   class FixturesTest < Test::Unit::TestCase
+#     fixtures :developers # you can add more with comma separation
+#
+#     def test_developers
+#       assert_equal 3, @developers.size # the container for all the fixtures is automatically set
+#       assert_kind_of Developer, @david # works like @developers["david"].find
+#       assert_equal "David Heinemeier Hansson", @david.name
+#     end
+#   end
+#
 # == YAML fixtures
 #
 # Additionally, fixtures supports yaml files.  Like fixture files, these yaml files have a pre-defined format.  The document
@@ -53,50 +69,56 @@ require 'yaml'
 # In that file, there's two records.  Each record must have two parts:  'name' and 'data'.  The data that you add
 # must be indented like you see above.
 #
-# Yaml fixtures file names must end with .yaml as in people.yaml or camel.yaml.  The yaml fixtures are placed in the same
+# Yaml fixtures file names must end with .yml as in people.yml or camel.yml.  The yaml fixtures are placed in the same
 # directory as the normal fixtures and can happy co-exist.  :)
-class Fixtures
+class Fixtures < Hash
+  def self.instantiate_fixtures(object, fixtures_directory, *table_names)
+    [ create_fixtures(fixtures_directory, *table_names) ].flatten.each_with_index do |fixtures, idx|
+      object.instance_variable_set "@#{table_names[idx]}", fixtures
+      fixtures.each { |name, fixture| object.instance_variable_set "@#{name}", fixture.find }
+    end
+  end
+  
   def self.create_fixtures(fixtures_directory, *table_names)
     connection = block_given? ? yield : ActiveRecord::Base.connection
-    ActiveRecord::Base.logger.level = Logger::ERROR
+    old_logger_level = ActiveRecord::Base.logger.level
 
-    fixtures = [ table_names ].flatten.collect do |table_name|
-      Fixtures.new(connection, table_name, "#{fixtures_directory}/#{table_name}")
+    begin
+      ActiveRecord::Base.logger.level = Logger::ERROR
+      fixtures = connection.transaction do
+        table_names.flatten.map do |table_name|
+          Fixtures.new(connection, table_name.to_s, File.join(fixtures_directory, table_name.to_s))
+        end
+      end
+      return fixtures.size > 1 ? fixtures : fixtures.first
+    ensure
+      ActiveRecord::Base.logger.level = old_logger_level
     end
-
-    ActiveRecord::Base.logger.level = Logger::DEBUG
-
-    return fixtures.size > 1 ? fixtures : fixtures.first
   end
 
   def initialize(connection, table_name, fixture_path, file_filter = /^\.|CVS|\.yaml/)
     @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
-    @fixtures = read_fixtures
+    @class_name = Inflector.classify(@table_name)
 
+    read_fixture_files
     delete_existing_fixtures
     insert_fixtures
   end
 
-  # Access a fixture hash by using its file name as the key
-  def [](key)
-    @fixtures[key]
-  end
-
-  # Get the number of fixtures kept in this container
-  def length
-    @fixtures.length
-  end
-
   private
-    def read_fixtures
-      Dir.entries(@fixture_path).inject({}) do |fixtures, file|
-        # is this a regular fixture file?
-        fixtures[file] = Fixture.new(@fixture_path, file) unless file =~ @file_filter
-        # is this a *.yaml file?
-        if file =~ /\.yaml/
-          YamlFixture.produce( "#{@fixture_path}/#{file}" ).each { |fix| fixtures[fix.yaml_name] = fix }
+    def read_fixture_files
+      Dir.entries(@fixture_path).each do |file|
+        case file
+          when /\.ya?ml$/
+            path = File.join(@fixture_path, file)
+            YamlFixture.produce(path).each { |fixture|
+                self[fixture.yaml_name] = fixture
+            }
+          when @file_filter
+            # skip
+          else
+            self[file] = Fixture.new(@fixture_path, file, @class_name)
         end
-        fixtures
       end
     end
 
@@ -105,20 +127,25 @@ class Fixtures
     end
 
     def insert_fixtures
-      @fixtures.values.each do |fixture|
+      values.each do |fixture|
         @connection.execute "INSERT INTO #{@table_name} (#{fixture.key_list}) VALUES(#{fixture.value_list})"
       end
     end
-
-    def []=(key, value)
-      @fixtures[key] = value
-    end
 end
 
 class Fixture #:nodoc:
-  def initialize(fixture_path, file)
-    @fixture_path, @file = fixture_path, file
-    @fixture = read_fixture
+  include Enumerable
+  class FixtureError < StandardError; end
+  class FormatError < FixtureError; end
+
+  def initialize(fixture_path, file, class_name)
+    @fixture_path, @file, @class_name = fixture_path, file, class_name
+    @fixture = read_fixture_file
+    @class_name
+  end
+
+  def each
+    @fixture.each { |item| yield item }
   end
 
   def [](key)
@@ -134,14 +161,29 @@ class Fixture #:nodoc:
   end
 
   def value_list
-    @fixture.values.map { |v| "'#{v}'" }.join(", ")
+    @fixture.values.map { |v| ActiveRecord::Base.connection.quote(v).gsub('\\n', "\n").gsub('\\r', "\r") }.join(", ")
   end
-
+  
+  def find
+    Object.const_get(@class_name).find(self["id"])
+  end
+  
   private
-    def read_fixture
-      IO.readlines("#{@fixture_path}/#{@file}").inject({}) do |fixture, line|
-        key, value = line.split(/ => /)
-        fixture[key.strip] = value.strip
+    def read_fixture_file
+      path = File.join(@fixture_path, @file)
+      IO.readlines(path).inject({}) do |fixture, line|
+        # Mercifully skip empty lines.
+        next if line.empty?
+
+        # Use the same regular expression for attributes as Active Record.
+        unless md = /^\s*([a-zA-Z][-_\w]*)\s*=>\s*(.+)\s*$/.match(line)
+          raise FormatError, "#{path}: fixture format error at '#{line}'.  Expecting 'key => value'."
+        end
+        key, value = md.captures
+
+        # Disallow duplicate keys to catch typos.
+        raise FormatError, "#{path}: duplicate '#{key}' in fixture." if fixture[key]
+        fixture[key] = value.strip
         fixture
       end
     end
@@ -150,23 +192,64 @@ end
 # A YamlFixture is like a fixture, but instead of a name to use as
 # a key, it uses a yaml_name.
 class YamlFixture < Fixture #:nodoc:
-  # yaml_name is equivalent to a normal fixture's filename
-  attr_accessor :yaml_name
+  class YamlFormatError < FormatError; end
+
+  # yaml_name is analogous to a normal fixture's filename
+  attr_reader :yaml_name
 
-  # constructor is passed the name & the actual instantiate fixture
+  # Instantiate with fixture name and data.
   def initialize(yaml_name, fixture)
     @yaml_name, @fixture = yaml_name, fixture
   end
 
-  # given a valid yaml file name, create an array of YamlFixture objects
-  def self.produce( yaml_file_name )
-    results = []
-    yaml_file = File.open( yaml_file_name )
-    YAML::load_documents( yaml_file ) do |doc|
-      f = YamlFixture.new( doc['name'], doc['data'] )
-      results << f
+  def produce(yaml_file_name)
+    YamlFixture.produce(yaml_file_name)
+  end
+
+  # Extract an array of YamlFixtures from a yaml file.
+  def self.produce(yaml_file_name)
+    fixtures = []
+    File.open(yaml_file_name) do |yaml_file|
+      YAML::load_documents(yaml_file) do |doc|
+        missing = %w(name data).reject { |key| doc[key] }.join(' and ')
+        raise YamlFormatError, "#{path}: yaml fixture missing #{missing}: #{doc.to_yaml}" unless missing.empty?
+        fixtures << YamlFixture.new(doc['name'], doc['data'])
+      end
     end
-    yaml_file.close
-    results
+    fixtures
   end
 end
+
+class Test::Unit::TestCase #:nodoc:
+  include ClassInheritableAttributes
+  
+  cattr_accessor :fixture_path
+  cattr_accessor :fixture_table_names
+  
+  def self.fixtures(*table_names)
+    write_inheritable_attribute("fixture_table_names", table_names)
+  end
+
+  def setup
+    instantiate_fixtures(*fixture_table_names) if fixture_table_names
+  end
+  
+  def self.method_added(method_symbol)
+    if method_symbol == :setup && !method_defined?(:setup_without_fixtures)
+      alias_method :setup_without_fixtures, :setup
+      define_method(:setup) do
+        instantiate_fixtures(*fixture_table_names) if fixture_table_names
+        setup_without_fixtures
+      end
+    end
+  end
+
+  private
+    def instantiate_fixtures(*table_names)
+      Fixtures.instantiate_fixtures(self, fixture_path, *table_names)
+    end
+    
+    def fixture_table_names
+      self.class.read_inheritable_attribute("fixture_table_names")
+    end
+end

data/lib/active_record/observer.rb

@@ -8,7 +8,7 @@ module ActiveRecord
   #
   #   class CommentObserver < ActiveRecord::Observer
   #     def after_save(comment)
-  #       NotificationServer.send_email("admin@do.com", "New comment was posted", comment)
+  #       Notifications.deliver_comment("admin@do.com", "New comment was posted", comment)
   #     end
   #   end
   #

data/lib/active_record/support/inflector.rb

@@ -31,6 +31,14 @@ module Inflector
     class_name_in_module.gsub(/^.*::/, '')
   end
 
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+  
+  def classify(table_name)
+    camelize(singularize(table_name))
+  end
+
   def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
     Inflector.underscore(Inflector.demodulize(class_name)) + 
       (separate_class_name_and_id_with_underscore ? "_id" : "id")

data/lib/active_record/transactions.rb

@@ -18,13 +18,13 @@ module ActiveRecord
       end
     end
 
-    # Transactions are protective blocks where SQL statements are only permanent if they can all succed as one atomic action. 
+    # Transactions are protective blocks where SQL statements are only permanent if they can all succeed as one atomic action. 
     # The classic example is a transfer between two accounts where you can only have a deposit if the withdrawal succedded and
     # vice versa. Transaction enforce the integrity of the database and guards the data against program errors or database break-downs.
     # So basically you should use transaction blocks whenever you have a number of statements that must be executed together or
     # not at all. Example:
     #
-    #   Account.transaction do
+    #   transaction do
     #     david.withdrawal(100)
     #     mary.deposit(100)
     #   end
@@ -33,6 +33,23 @@ module ActiveRecord
     # Exceptions will force a ROLLBACK that returns the database to the state before the transaction was begun. Be aware, though,
     # that the objects by default will _not_ have their instance data returned to their pre-transactional state.
     #
+    # == Transactions are not distributed across database connections
+    #
+    # A transaction acts on a single database connection.  If you have
+    # multiple class-specific databases, the transaction will not protect
+    # interaction among them.  One workaround is to begin a transaction
+    # on each class whose models you alter:
+    #
+    #   Student.transaction do
+    #     Course.transaction do
+    #       course.enroll(student)
+    #       student.units += course.units
+    #     end
+    #   end
+    #
+    # This is a poor solution, but full distributed transactions are beyond
+    # the scope of Active Record.
+    #
     # == Save and destroy are automatically wrapped in a transaction
     #
     # Both Base#save and Base#destroy come wrapped in a transaction that ensures that whatever you do in validations or callbacks
@@ -65,38 +82,38 @@ module ActiveRecord
         begin
           objects.each { |o| o.extend(Transaction::Simple) }
           objects.each { |o| o.start_transaction }
-          connection.begin_db_transaction
 
-          block.call
-  
-          connection.commit_db_transaction
+          result = connection.transaction(&block)
+
           objects.each { |o| o.commit_transaction }
-        rescue Exception => exception
-          connection.rollback_db_transaction
+          return result
+        rescue Exception => object_transaction_rollback
           objects.each { |o| o.abort_transaction }
-          raise exception
+          raise
         ensure
           TRANSACTION_MUTEX.unlock
         end
       end
     end
 
+    def transaction(*objects, &block)
+      self.class.transaction(*objects, &block)
+    end
+
     def destroy_with_transactions #:nodoc:
       if TRANSACTION_MUTEX.locked?
         destroy_without_transactions
       else
-        ActiveRecord::Base.transaction { destroy_without_transactions }
+        transaction { destroy_without_transactions }
       end
     end
     
     def save_with_transactions(perform_validation = true) #:nodoc:
-      result = nil
       if TRANSACTION_MUTEX.locked?
-        result = save_without_transactions(perform_validation)
+        save_without_transactions(perform_validation)
       else
-        ActiveRecord::Base.transaction { result = save_without_transactions(perform_validation) }
+        transaction { save_without_transactions(perform_validation) }
       end
-      return result
     end
   end
 end

data/rakefile

@@ -6,7 +6,10 @@ require 'rake/packagetask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
-PKG_VERSION = "1.0.0"
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'activerecord'
+PKG_VERSION   = '1.1.0' + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 PKG_FILES = FileList[
     "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "install.rb", "rakefile"
@@ -20,7 +23,6 @@ task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_postg
 
 Rake::TestTask.new("test_ruby_mysql") { |t|
   t.libs << "test" << "test/connections/native_mysql"
-  t.test_files = "lib/active_record/vendor/mysql.rb"
   t.pattern = 'test/*_test.rb'
   t.verbose = true
 }
@@ -43,7 +45,7 @@ Rake::TestTask.new("test_sqlite") { |t|
   t.verbose = true
 }
 
-# Genereate the RDoc documentation
+# Generate the RDoc documentation
 
 Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_dir = 'doc'
@@ -56,6 +58,12 @@ 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
+end
+
 # Publish documentation
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
@@ -73,7 +81,7 @@ end
 dist_dirs = [ "lib", "test", "examples", "dev-utils" ]
 
 spec = Gem::Specification.new do |s|
-  s.name = 'activerecord'
+  s.name = PKG_NAME
   s.version = PKG_VERSION
   s.summary = "Implements the ActiveRecord pattern for ORM."
   s.description = %q{Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database tables and classes together for business objects, like Customer or Subscription, that can find, save, and destroy themselves without resorting to manual SQL.}
@@ -119,4 +127,4 @@ task :lines do
     end
   }
   puts "Lines #{lines}, LOC #{codelines}"
-end
+end

data/test/abstract_unit.rb

@@ -1,5 +1,9 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
+# Make rubygems available for testing if possible
+begin require('rubygems');        rescue LoadError; end
+begin require('dev-utils/debug'); rescue LoadError; end
+
 require 'test/unit'
 require 'active_record'
 require 'active_record/fixtures'
@@ -13,4 +17,6 @@ class Test::Unit::TestCase #:nodoc:
       Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names)
     end
   end
-end
+end
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"