radiant 0.6.9 → 0.7.0

data/vendor/rails/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -70,7 +70,7 @@ module ActiveRecord
     #
     # Options:
     #
-    # * <tt>:database</tt> -- Path to the database file.
+    # * <tt>:database</tt> - Path to the database file.
     class SQLiteAdapter < AbstractAdapter
       def adapter_name #:nodoc:
         'SQLite'
@@ -107,7 +107,7 @@ module ActiveRecord
           :decimal     => { :name => "decimal" },
           :datetime    => { :name => "datetime" },
           :timestamp   => { :name => "datetime" },
-          :time        => { :name => "datetime" },
+          :time        => { :name => "time" },
           :date        => { :name => "date" },
           :binary      => { :name => "blob" },
           :boolean     => { :name => "boolean" }
@@ -192,7 +192,7 @@ module ActiveRecord
       end
 
       def indexes(table_name, name = nil) #:nodoc:
-        execute("PRAGMA index_list(#{table_name})", name).map do |row|
+        execute("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
           index = IndexDefinition.new(table_name, row['name'])
           index.unique = row['unique'] != '0'
           index.columns = execute("PRAGMA index_info('#{index.name}')").map { |col| col['name'] }
@@ -214,16 +214,23 @@ module ActiveRecord
       end
 
       def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        if @connection.respond_to?(:transaction_active?) && @connection.transaction_active?
+          raise StatementInvalid, 'Cannot add columns to a SQLite database while inside a transaction'
+        end
+        
         super(table_name, column_name, type, options)
         # See last paragraph on http://www.sqlite.org/lang_altertable.html
         execute "VACUUM"
       end
 
-      def remove_column(table_name, column_name) #:nodoc:
-        alter_table(table_name) do |definition|
-          definition.columns.delete(definition[column_name])
+      def remove_column(table_name, *column_names) #:nodoc:
+        column_names.flatten.each do |column_name|
+          alter_table(table_name) do |definition|
+            definition.columns.delete(definition[column_name])
+          end
         end
       end
+      alias :remove_columns :remove_column
 
       def change_column_default(table_name, column_name, default) #:nodoc:
         alter_table(table_name) do |definition|
@@ -231,6 +238,15 @@ module ActiveRecord
         end
       end
 
+      def change_column_null(table_name, column_name, null, default = nil)
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+        alter_table(table_name) do |definition|
+          definition[column_name].null = null
+        end
+      end
+
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
         alter_table(table_name) do |definition|
           include_default = options_include_default?(options)
@@ -244,6 +260,9 @@ module ActiveRecord
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        unless columns(table_name).detect{|c| c.name == column_name.to_s }
+          raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
+        end
         alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
       end
 
@@ -257,7 +276,7 @@ module ActiveRecord
             record = {}
             row.each_key do |key|
               if key.is_a?(String)
-                record[key.sub(/^\w+\./, '')] = row[key]
+                record[key.sub(/^"?\w+"?\./, '')] = row[key]
               end
             end
             record
@@ -265,7 +284,7 @@ module ActiveRecord
         end
 
         def table_structure(table_name)
-          returning structure = execute("PRAGMA table_info(#{table_name})") do
+          returning structure = execute("PRAGMA table_info(#{quote_table_name(table_name)})") do
             raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
           end
         end
@@ -304,13 +323,13 @@ module ActiveRecord
             yield @definition if block_given?
           end
 
-          copy_table_indexes(from, to)
+          copy_table_indexes(from, to, options[:rename] || {})
           copy_table_contents(from, to,
             @definition.columns.map {|column| column.name},
             options[:rename] || {})
         end
 
-        def copy_table_indexes(from, to) #:nodoc:
+        def copy_table_indexes(from, to, rename = {}) #:nodoc:
           indexes(from).each do |index|
             name = index.name
             if to == "altered_#{from}"
@@ -319,10 +338,17 @@ module ActiveRecord
               name = name[5..-1]
             end
 
-            # index name can't be the same
-            opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
-            opts[:unique] = true if index.unique
-            add_index(to, index.columns, opts)
+            to_column_names = columns(to).map(&:name)
+            columns = index.columns.map {|c| rename[c] || c }.select do |column|
+              to_column_names.include?(column)
+            end
+
+            unless columns.empty?
+              # index name can't be the same
+              opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
+              opts[:unique] = true if index.unique
+              add_index(to, columns, opts)
+            end
           end
         end
 
@@ -333,8 +359,9 @@ module ActiveRecord
           columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
           quoted_columns = columns.map { |col| quote_column_name(col) } * ','
 
-          @connection.execute "SELECT * FROM #{from}" do |row|
-            sql = "INSERT INTO #{to} (#{quoted_columns}) VALUES ("
+          quoted_to = quote_table_name(to)
+          @connection.execute "SELECT * FROM #{quote_table_name(from)}" do |row|
+            sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
             sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
             sql << ')'
             @connection.execute sql

data/vendor/rails/activerecord/lib/active_record/dirty.rb

@@ -0,0 +1,165 @@
+module ActiveRecord
+  # Track unsaved attribute changes.
+  #
+  # A newly instantiated object is unchanged:
+  #   person = Person.find_by_name('uncle bob')
+  #   person.changed?       # => false
+  #
+  # Change the name:
+  #   person.name = 'Bob'
+  #   person.changed?       # => true
+  #   person.name_changed?  # => true
+  #   person.name_was       # => 'uncle bob'
+  #   person.name_change    # => ['uncle bob', 'Bob']
+  #   person.name = 'Bill'
+  #   person.name_change    # => ['uncle bob', 'Bill']
+  #
+  # Save the changes:
+  #   person.save
+  #   person.changed?       # => false
+  #   person.name_changed?  # => false
+  #
+  # Assigning the same value leaves the attribute unchanged:
+  #   person.name = 'Bill'
+  #   person.name_changed?  # => false
+  #   person.name_change    # => nil
+  #
+  # Which attributes have changed?
+  #   person.name = 'bob'
+  #   person.changed        # => ['name']
+  #   person.changes        # => { 'name' => ['Bill', 'bob'] }
+  #
+  # Before modifying an attribute in-place:
+  #   person.name_will_change!
+  #   person.name << 'by'
+  #   person.name_change    # => ['uncle bob', 'uncle bobby']
+  module Dirty
+    def self.included(base)
+      base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
+      base.alias_method_chain :write_attribute, :dirty
+      base.alias_method_chain :save,            :dirty
+      base.alias_method_chain :save!,           :dirty
+      base.alias_method_chain :update,          :dirty
+      base.alias_method_chain :reload,          :dirty
+
+      base.superclass_delegating_accessor :partial_updates
+      base.partial_updates = true
+    end
+
+    # Do any attributes have unsaved changes?
+    #   person.changed? # => false
+    #   person.name = 'bob'
+    #   person.changed? # => true
+    def changed?
+      !changed_attributes.empty?
+    end
+
+    # List of attributes with unsaved changes.
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ['name']
+    def changed
+      changed_attributes.keys
+    end
+
+    # Map of changed attrs => [original value, new value]
+    #   person.changes # => {}
+    #   person.name = 'bob'
+    #   person.changes # => { 'name' => ['bill', 'bob'] }
+    def changes
+      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
+    end
+
+    # Attempts to +save+ the record and clears changed attributes if successful.
+    def save_with_dirty(*args) #:nodoc:
+      if status = save_without_dirty(*args)
+        changed_attributes.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+    def save_with_dirty!(*args) #:nodoc:
+      status = save_without_dirty!(*args)
+      changed_attributes.clear
+      status
+    end
+
+    # <tt>reload</tt> the record and clears changed attributes.
+    def reload_with_dirty(*args) #:nodoc:
+      record = reload_without_dirty(*args)
+      changed_attributes.clear
+      record
+    end
+
+    private
+      # Map of change attr => original value.
+      def changed_attributes
+        @changed_attributes ||= {}
+      end
+
+      # Handle *_changed? for method_missing.
+      def attribute_changed?(attr)
+        changed_attributes.include?(attr)
+      end
+
+      # Handle *_change for method_missing.
+      def attribute_change(attr)
+        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      end
+
+      # Handle *_was for method_missing.
+      def attribute_was(attr)
+        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+      end
+
+      # Handle *_will_change! for method_missing.
+      def attribute_will_change!(attr)
+        changed_attributes[attr] = clone_attribute_value(:read_attribute, attr)
+      end
+
+      # Wrap write_attribute to remember original attribute value.
+      def write_attribute_with_dirty(attr, value)
+        attr = attr.to_s
+
+        # The attribute already has an unsaved change.
+        if changed_attributes.include?(attr)
+          old = changed_attributes[attr]
+          changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          changed_attributes[attr] = old if field_changed?(attr, old, value)
+        end
+
+        # Carry on.
+        write_attribute_without_dirty(attr, value)
+      end
+
+      def update_with_dirty
+        if partial_updates?
+          # Serialized attributes should always be written in case they've been
+          # changed in place.
+          update_without_dirty(changed | self.class.serialized_attributes.keys)
+        else
+          update_without_dirty
+        end
+      end
+
+      def field_changed?(attr, old, value)
+        if column = column_for_attribute(attr)
+          if column.type == :integer && column.null && (old.nil? || old == 0)
+            # For nullable integer columns, NULL gets stored in database for blank (i.e. '') values.
+            # Hence we don't record it as a change if the value changes from nil to ''.
+            # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+            # be typecast back to 0 (''.to_i => 0)
+            value = nil if value.blank?
+          else
+            value = column.type_cast(value)
+          end
+        end
+
+        old != value
+      end
+
+  end
+end

data/vendor/rails/activerecord/lib/active_record/fixtures.rb

@@ -1,11 +1,14 @@
 require 'erb'
 require 'yaml'
 require 'csv'
+require 'active_support/test_case'
 
-module YAML #:nodoc:
-  class Omap #:nodoc:
-    def keys;   map { |k, v| k } end
-    def values; map { |k, v| v } end
+if RUBY_VERSION < '1.9'
+  module YAML #:nodoc:
+    class Omap #:nodoc:
+      def keys;   map { |k, v| k } end
+      def values; map { |k, v| v } end
+    end
   end
 end
 
@@ -29,9 +32,9 @@ end
 # in a non-verbose, human-readable format. It ships with Ruby 1.8.1+.
 #
 # Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed in the directory appointed
-# by <tt>Test::Unit::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <your-rails-app>/test/fixtures/). The fixture file ends with the .yml file extension (Rails example:
-# "<your-rails-app>/test/fixtures/web_sites.yml"). The format of a YAML fixture file looks like this:
+# by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
+# put your files in <tt><your-rails-app>/test/fixtures/</tt>). The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
+# <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a YAML fixture file looks like this:
 #
 #   rubyonrails:
 #     id: 1
@@ -64,7 +67,8 @@ end
 # = CSV fixtures
 #
 # Fixtures can also be kept in the Comma Separated Value format. Akin to YAML fixtures, CSV fixtures are stored
-# in a single file, but instead end with the .csv file extension (Rails example: "<your-rails-app>/test/fixtures/web_sites.csv")
+# in a single file, but instead end with the <tt>.csv</tt> file extension
+# (Rails example: <tt><your-rails-app>/test/fixtures/web_sites.csv</tt>).
 #
 # The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
 # humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the file is then comprised
@@ -89,12 +93,12 @@ end
 #
 # This type of fixture was the original format for Active Record that has since been deprecated in favor of the YAML and CSV formats.
 # Fixtures for this format are created by placing text files in a sub-directory (with the name of the model) to the directory
-# appointed by <tt>Test::Unit::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <your-rails-app>/test/fixtures/<your-model-name>/ -- like <your-rails-app>/test/fixtures/web_sites/ for the WebSite
-# model).
+# appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
+# put your files in <tt><your-rails-app>/test/fixtures/<your-model-name>/</tt> --
+# like <tt><your-rails-app>/test/fixtures/web_sites/</tt> for the WebSite model).
 #
 # Each text file placed in this directory represents a "record".  Usually these types of fixtures are named without
-# extensions, but if you are on a Windows machine, you might consider adding .txt as the extension.  Here's what the
+# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.  Here's what the
 # above example might look like:
 #
 #   web_sites/google
@@ -115,7 +119,7 @@ end
 #
 #   require 'web_site'
 #
-#   class WebSiteTest < Test::Unit::TestCase
+#   class WebSiteTest < ActiveSupport::TestCase
 #     def test_web_site_count
 #       assert_equal 2, WebSite.count
 #     end
@@ -125,7 +129,7 @@ end
 # easiest way to add fixtures to the database:
 #
 #   ...
-#   class WebSiteTest < Test::Unit::TestCase
+#   class WebSiteTest < ActiveSupport::TestCase
 #     fixtures :web_sites # add more by separating the symbols with commas
 #   ...
 #
@@ -135,20 +139,20 @@ end
 #
 # In addition to being available in the database, the fixtures are also loaded into a hash stored in an instance variable
 # of the test case.  It is named after the symbol... so, in our example, there would be a hash available called
-# @web_sites.  This is where the "fixture name" comes into play.
+# <tt>@web_sites</tt>.  This is where the "fixture name" comes into play.
 #
-# On top of that, each record is automatically "found" (using Model.find(id)) and placed in the instance variable of its name.
-# So for the YAML fixtures, we'd get @rubyonrails and @google, which could be interrogated using regular Active Record semantics:
+# On top of that, each record is automatically "found" (using <tt>Model.find(id)</tt>) and placed in the instance variable of its name.
+# So for the YAML fixtures, we'd get <tt>@rubyonrails</tt> and <tt>@google</tt>, which could be interrogated using regular Active Record semantics:
 #
 #   # test if the object created from the fixture data has the same attributes as the data itself
 #   def test_find
 #     assert_equal @web_sites["rubyonrails"]["name"], @rubyonrails.name
 #   end
 #
-# As seen above, the data hash created from the YAML fixtures would have @web_sites["rubyonrails"]["url"] return
-# "http://www.rubyonrails.org" and @web_sites["google"]["name"] would return "Google". The same fixtures, but loaded
-# from a CSV fixture file, would be accessible via @web_sites["web_site_1"]["name"] == "Ruby on Rails" and have the individual
-# fixtures available as instance variables @web_site_1 and @web_site_2.
+# As seen above, the data hash created from the YAML fixtures would have <tt>@web_sites["rubyonrails"]["url"]</tt> return
+# "http://www.rubyonrails.org" and <tt>@web_sites["google"]["name"]</tt> would return "Google". The same fixtures, but loaded
+# from a CSV fixture file, would be accessible via <tt>@web_sites["web_site_1"]["name"] == "Ruby on Rails"</tt> and have the individual
+# fixtures available as instance variables <tt>@web_site_1</tt> and <tt>@web_site_2</tt>.
 #
 # If you do not wish to use instantiated fixtures (usually for performance reasons) there are two options.
 #
@@ -173,15 +177,15 @@ end
 # Some times you don't care about the content of the fixtures as much as you care about the volume. In these cases, you can
 # mix ERb in with your YAML or CSV fixtures to create a bunch of fixtures for load testing, like:
 #
-# <% for i in 1..1000 %>
-# fix_<%= i %>:
-#   id: <%= i %>
-#   name: guy_<%= 1 %>
-# <% end %>
+#   <% for i in 1..1000 %>
+#   fix_<%= i %>:
+#     id: <%= i %>
+#     name: guy_<%= 1 %>
+#   <% end %>
 #
 # This will create 1000 very simple YAML fixtures.
 #
-# Using ERb, you can also inject dynamic values into your fixtures with inserts like <%= Date.today.strftime("%Y-%m-%d") %>.
+# Using ERb, you can also inject dynamic values into your fixtures with inserts like <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
 # This is however a feature to be used with some caution. The point of fixtures are that they're stable units of predictable
 # sample data. If you feel that you need to inject dynamic values, then perhaps you should reexamine whether your application
 # is properly testable. Hence, dynamic values in fixtures are to be considered a code smell.
@@ -191,23 +195,23 @@ end
 # TestCases can use begin+rollback to isolate their changes to the database instead of having to delete+insert for every test case.
 # They can also turn off auto-instantiation of fixture data since the feature is costly and often unused.
 #
-#   class FooTest < Test::Unit::TestCase
+#   class FooTest < ActiveSupport::TestCase
 #     self.use_transactional_fixtures = true
 #     self.use_instantiated_fixtures = false
-#   
+#
 #     fixtures :foos
-#   
+#
 #     def test_godzilla
 #       assert !Foo.find(:all).empty?
 #       Foo.destroy_all
 #       assert Foo.find(:all).empty?
 #     end
-#   
+#
 #     def test_godzilla_aftermath
 #       assert !Foo.find(:all).empty?
 #     end
 #   end
-#   
+#
 # If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures,
 # then you may omit all fixtures declarations in your test cases since all the data's already there and every case rolls back its changes.
 #
@@ -254,7 +258,7 @@ end
 #   reginald: # generated id: 324201669
 #     name: Reginald the Pirate
 #
-# ActiveRecord looks at the fixture's model class, discovers the correct
+# Active Record looks at the fixture's model class, discovers the correct
 # primary key, and generates it right before inserting the fixture
 # into the database.
 #
@@ -264,7 +268,7 @@ end
 # == Label references for associations (belongs_to, has_one, has_many)
 #
 # Specifying foreign keys in fixtures can be very fragile, not to
-# mention difficult to read. Since ActiveRecord can figure out the ID of
+# mention difficult to read. Since Active Record can figure out the ID of
 # any fixture from its label, you can specify FK's by label instead of ID.
 #
 # === belongs_to
@@ -301,15 +305,15 @@ end
 #     name: George the Monkey
 #     pirate: reginald
 #
-# Pow! All is made clear. ActiveRecord reflects on the fixture's model class,
+# Pow! All is made clear. Active Record reflects on the fixture's model class,
 # finds all the +belongs_to+ associations, and allows you to specify
 # a target *label* for the *association* (monkey: george) rather than
-# a target *id* for the *FK* (monkey_id: 1).
+# a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
 #
 # ==== Polymorphic belongs_to
 #
 # Supporting polymorphic relationships is a little bit more complicated, since
-# ActiveRecord needs to know what type your association is pointing at. Something
+# Active Record needs to know what type your association is pointing at. Something
 # like this should look familiar:
 #
 #   ### in fruit.rb
@@ -329,7 +333,7 @@ end
 #   apple:
 #     eater: george (Monkey)
 #
-# Just provide the polymorphic target type and ActiveRecord will take care of the rest.
+# Just provide the polymorphic target type and Active Record will take care of the rest.
 #
 # === has_and_belongs_to_many
 #
@@ -392,15 +396,15 @@ end
 #
 # Zap! No more fruits_monkeys.yml file. We've specified the list of fruits
 # on George's fixture, but we could've just as easily specified a list
-# of monkeys on each fruit. As with +belongs_to+, ActiveRecord reflects on
+# of monkeys on each fruit. As with +belongs_to+, Active Record reflects on
 # the fixture's model class and discovers the +has_and_belongs_to_many+
 # associations.
 #
 # == Autofilled timestamp columns
 #
-# If your table/model specifies any of ActiveRecord's
-# standard timestamp columns (created_at, created_on, updated_at, updated_on),
-# they will automatically be set to Time.now.
+# If your table/model specifies any of Active Record's
+# standard timestamp columns (+created_at+, +created_on+, +updated_at+, +updated_on+),
+# they will automatically be set to <tt>Time.now</tt>.
 #
 # If you've set specific values, they'll be left alone.
 #
@@ -423,7 +427,7 @@ end
 # == Support for YAML defaults
 #
 # You probably already know how to use YAML to set and reuse defaults in
-# your +database.yml+ file,. You can use the same technique in your fixtures:
+# your <tt>database.yml</tt> file. You can use the same technique in your fixtures:
 #
 #   DEFAULTS: &DEFAULTS
 #     created_on: <%= 3.weeks.ago.to_s(:db) %>
@@ -438,7 +442,7 @@ end
 #
 # Any fixture labeled "DEFAULTS" is safely ignored.
 
-class Fixtures < YAML::Omap
+class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
   @@all_cached_fixtures = {}
@@ -466,8 +470,8 @@ class Fixtures < YAML::Omap
     fixtures.size > 1 ? fixtures : fixtures.first
   end
 
-  def self.cache_fixtures(connection, fixtures)
-    cache_for_connection(connection).update(fixtures.index_by(&:table_name))
+  def self.cache_fixtures(connection, fixtures_map)
+    cache_for_connection(connection).update(fixtures_map)
   end
 
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances = true)
@@ -523,7 +527,7 @@ class Fixtures < YAML::Omap
             end
           end
 
-          cache_fixtures(connection, fixtures)
+          cache_fixtures(connection, fixtures_map)
         end
       end
     end
@@ -558,7 +562,11 @@ class Fixtures < YAML::Omap
     now = now.to_s(:db)
 
     # allow a standard key to be used for doing defaults in YAML
-    delete(assoc("DEFAULTS"))
+    if is_a?(Hash)
+      delete('DEFAULTS')
+    else
+      delete(assoc('DEFAULTS'))
+    end
 
     # track any join tables we need to insert later
     habtm_fixtures = Hash.new do |h, habtm|
@@ -644,8 +652,16 @@ class Fixtures < YAML::Omap
     end
 
     def model_class
-      @model_class ||= @class_name.is_a?(Class) ?
-        @class_name : @class_name.constantize rescue nil
+      unless defined?(@model_class)
+        @model_class =
+          if @class_name.nil? || @class_name.is_a?(Class)
+            @class_name
+          else
+            @class_name.constantize rescue nil
+          end
+      end
+
+      @model_class
     end
 
     def primary_key_name
@@ -676,14 +692,6 @@ class Fixtures < YAML::Omap
         read_yaml_fixture_files
       elsif File.file?(csv_file_path)
         read_csv_fixture_files
-      else
-        # Standard fixtures
-        Dir.entries(@fixture_path).each do |file|
-          path = File.join(@fixture_path, file)
-          if File.file?(path) and file !~ @file_filter
-            self[file] = Fixture.new(path, @class_name)
-          end
-        end
       end
     end
 
@@ -704,25 +712,26 @@ class Fixtures < YAML::Omap
           end
 
         yaml_value.each do |fixture|
-          fixture.each do |name, data|
+          raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{fixture}" unless fixture.respond_to?(:each)
+	  fixture.each do |name, data|
             unless data
               raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
 
-            self[name] = Fixture.new(data, @class_name)
+            self[name] = Fixture.new(data, model_class)
           end
         end
       end
     end
 
     def read_csv_fixture_files
-      reader = CSV::Reader.create(erb_render(IO.read(csv_file_path)))
+      reader = CSV.parse(erb_render(IO.read(csv_file_path)))
       header = reader.shift
       i = 0
       reader.each do |row|
         data = {}
         row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{Inflector::underscore(@class_name)}_#{i+=1}"]= Fixture.new(data, @class_name)
+        self["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class)
       end
     end
 
@@ -758,19 +767,15 @@ class Fixture #:nodoc:
   class FormatError < FixtureError #:nodoc:
   end
 
-  attr_reader :class_name
+  attr_reader :model_class
 
-  def initialize(fixture, class_name)
-    case fixture
-      when Hash, YAML::Omap
-        @fixture = fixture
-      when String
-        @fixture = read_fixture_file(fixture)
-      else
-        raise ArgumentError, "Bad fixture argument #{fixture.inspect} during creation of #{class_name} fixture"
-    end
+  def initialize(fixture, model_class)
+    @fixture = fixture
+    @model_class = model_class.is_a?(Class) ? model_class : model_class.constantize rescue nil
+  end
 
-    @class_name = class_name
+  def class_name
+    @model_class.name if @model_class
   end
 
   def each
@@ -791,47 +796,28 @@ class Fixture #:nodoc:
   end
 
   def value_list
-    klass = @class_name.constantize rescue nil
-
     list = @fixture.inject([]) do |fixtures, (key, value)|
-      col = klass.columns_hash[key] if klass.respond_to?(:ancestors) && klass.ancestors.include?(ActiveRecord::Base)
+      col = model_class.columns_hash[key] if model_class.respond_to?(:ancestors) && model_class.ancestors.include?(ActiveRecord::Base)
       fixtures << ActiveRecord::Base.connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
     end
     list * ', '
   end
 
   def find
-    klass = @class_name.is_a?(Class) ? @class_name : Object.const_get(@class_name) rescue nil
-    if klass
-      klass.find(self[klass.primary_key])
+    if model_class
+      model_class.find(self[model_class.primary_key])
     else
-      raise FixtureClassNotFound, "The class #{@class_name.inspect} was not found."
+      raise FixtureClassNotFound, "No class attached to find."
     end
   end
-
-  private
-    def read_fixture_file(fixture_file_path)
-      IO.readlines(fixture_file_path).inject({}) do |fixture, line|
-        # Mercifully skip empty lines.
-        next if line =~ /^\s*$/
-
-        # Use the same regular expression for attributes as Active Record.
-        unless md = /^\s*([a-zA-Z][-_\w]*)\s*=>\s*(.+)\s*$/.match(line)
-          raise FormatError, "#{fixture_file_path}: fixture format error at '#{line}'.  Expecting 'key => value'."
-        end
-        key, value = md.captures
-
-        # Disallow duplicate keys to catch typos.
-        raise FormatError, "#{fixture_file_path}: duplicate '#{key}' in fixture." if fixture[key]
-        fixture[key] = value.strip
-        fixture
-      end
-    end
 end
 
 module Test #:nodoc:
   module Unit #:nodoc:
     class TestCase #:nodoc:
+      setup :setup_fixtures
+      teardown :teardown_fixtures
+
       superclass_delegating_accessor :fixture_path
       superclass_delegating_accessor :fixture_table_names
       superclass_delegating_accessor :fixture_class_names
@@ -847,67 +833,78 @@ module Test #:nodoc:
       @@already_loaded_fixtures = {}
       self.fixture_class_names = {}
 
-      def self.set_fixture_class(class_names = {})
-        self.fixture_class_names = self.fixture_class_names.merge(class_names)
-      end
+      class << self
+        def set_fixture_class(class_names = {})
+          self.fixture_class_names = self.fixture_class_names.merge(class_names)
+        end
 
-      def self.fixtures(*table_names)
-        if table_names.first == :all
-          table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
-          table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
-        else
-          table_names = table_names.flatten.map { |n| n.to_s }
+        def fixtures(*table_names)
+          if table_names.first == :all
+            table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
+            table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
+          else
+            table_names = table_names.flatten.map { |n| n.to_s }
+          end
+
+          self.fixture_table_names |= table_names
+          require_fixture_classes(table_names)
+          setup_fixture_accessors(table_names)
         end
 
-        self.fixture_table_names |= table_names
-        require_fixture_classes(table_names)
-        setup_fixture_accessors(table_names)
-      end
+        def try_to_load_dependency(file_name)
+          require_dependency file_name
+        rescue LoadError => e
+          # Let's hope the developer has included it himself
 
-      def self.require_fixture_classes(table_names = nil)
-        (table_names || fixture_table_names).each do |table_name|
-          file_name = table_name.to_s
-          file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
-          begin
-            require_dependency file_name
-          rescue LoadError
-            # Let's hope the developer has included it himself
+          # Let's warn in case this is a subdependency, otherwise
+          # subdependency error messages are totally cryptic
+          if ActiveRecord::Base.logger
+            ActiveRecord::Base.logger.warn("Unable to load #{file_name}, underlying cause #{e.message} \n\n #{e.backtrace.join("\n")}")
+          end
+        end
+
+        def require_fixture_classes(table_names = nil)
+          (table_names || fixture_table_names).each do |table_name|
+            file_name = table_name.to_s
+            file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
+            try_to_load_dependency(file_name)
           end
         end
-      end
 
-      def self.setup_fixture_accessors(table_names = nil)
-        (table_names || fixture_table_names).each do |table_name|
-          table_name = table_name.to_s.tr('.', '_')
+        def setup_fixture_accessors(table_names = nil)
+          table_names = [table_names] if table_names && !table_names.respond_to?(:each)
+          (table_names || fixture_table_names).each do |table_name|
+            table_name = table_name.to_s.tr('.', '_')
 
-          define_method(table_name) do |*fixtures|
-            force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
+            define_method(table_name) do |*fixtures|
+              force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
 
-            @fixture_cache[table_name] ||= {}
+              @fixture_cache[table_name] ||= {}
 
-            instances = fixtures.map do |fixture|
-              @fixture_cache[table_name].delete(fixture) if force_reload
+              instances = fixtures.map do |fixture|
+                @fixture_cache[table_name].delete(fixture) if force_reload
 
-              if @loaded_fixtures[table_name][fixture.to_s]
-                @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
-              else
-                raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+                if @loaded_fixtures[table_name][fixture.to_s]
+                  @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
+                else
+                  raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+                end
               end
-            end
 
-            instances.size == 1 ? instances.first : instances
+              instances.size == 1 ? instances.first : instances
+            end
           end
         end
-      end
 
-      def self.uses_transaction(*methods)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.concat methods.map(&:to_s)
-      end
+        def uses_transaction(*methods)
+          @uses_transaction = [] unless defined?(@uses_transaction)
+          @uses_transaction.concat methods.map(&:to_s)
+        end
 
-      def self.uses_transaction?(method)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.include?(method.to_s)
+        def uses_transaction?(method)
+          @uses_transaction = [] unless defined?(@uses_transaction)
+          @uses_transaction.include?(method.to_s)
+        end
       end
 
       def use_transactional_fixtures?
@@ -915,10 +912,8 @@ module Test #:nodoc:
           !self.class.uses_transaction?(method_name)
       end
 
-      def setup_with_fixtures
-        return if @fixtures_setup
-        @fixtures_setup = true
-        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+      def setup_fixtures
+        return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
 
         if pre_loaded_fixtures && !use_transactional_fixtures
           raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
@@ -946,12 +941,9 @@ module Test #:nodoc:
         # Instantiate fixtures for every test if requested.
         instantiate_fixtures if use_instantiated_fixtures
       end
-      alias_method :setup, :setup_with_fixtures
 
-      def teardown_with_fixtures
-        return if @fixtures_teardown
-        @fixtures_teardown = true
-        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+      def teardown_fixtures
+        return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
 
         unless use_transactional_fixtures?
           Fixtures.reset_cache
@@ -964,35 +956,6 @@ module Test #:nodoc:
         end
         ActiveRecord::Base.verify_active_connections!
       end
-      alias_method :teardown, :teardown_with_fixtures
-
-      def self.method_added(method)
-        return if @__disable_method_added__
-        @__disable_method_added__ = true
-        
-        case method.to_s
-        when 'setup'
-          unless method_defined?(:setup_without_fixtures)
-            alias_method :setup_without_fixtures, :setup
-            define_method(:full_setup) do
-              setup_with_fixtures
-              setup_without_fixtures
-            end
-          end
-          alias_method :setup, :full_setup
-        when 'teardown'
-          unless method_defined?(:teardown_without_fixtures)
-            alias_method :teardown_without_fixtures, :teardown
-            define_method(:full_teardown) do
-              teardown_without_fixtures
-              teardown_with_fixtures
-            end
-          end
-          alias_method :teardown, :full_teardown
-        end
-        
-        @__disable_method_added__ = false
-      end
 
       private
         def load_fixtures