diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 06db1f5a92..c630af59f0 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -372,19 +372,23 @@ module ActiveRecord
   #
   # Any fixture labeled "DEFAULTS" is safely ignored.
   class Fixtures
+    #--
+    # NOTE: an instance of Fixtures can be called fixture_set, it is normally stored in a single YAML file and possibly in a folder with the same name.
+    #++
     MAX_ID = 2 ** 30 - 1
 
     @@all_cached_fixtures = Hash.new { |h,k| h[k] = {} }
 
-    def self.default_fixture_model_name(fixture_name) # :nodoc:
+    def self.default_fixture_model_name(fixture_set_name) # :nodoc:
       ActiveRecord::Base.pluralize_table_names ?
-        fixture_name.singularize.camelize :
-        fixture_name.camelize
+        fixture_set_name.singularize.camelize :
+        fixture_set_name.camelize
     end
 
-    def self.default_fixture_table_name(fixture_name) # :nodoc:
-       "#{ActiveRecord::Base.table_name_prefix}"\
-         "#{fixture_name.tr('/', '_')}#{ActiveRecord::Base.table_name_suffix}".to_sym
+    def self.default_fixture_table_name(fixture_set_name) # :nodoc:
+       "#{ ActiveRecord::Base.table_name_prefix }"\
+       "#{ fixture_set_name.tr('/', '_') }"\
+       "#{ ActiveRecord::Base.table_name_suffix }".to_sym
     end
 
     def self.reset_cache
@@ -411,11 +415,11 @@ module ActiveRecord
       cache_for_connection(connection).update(fixtures_map)
     end
 
-    def self.instantiate_fixtures(object, fixtures, load_instances = true)
+    def self.instantiate_fixtures(object, fixture_set, load_instances = true)
       if load_instances
-        fixtures.each do |name, fixture|
+        fixture_set.each do |fixture_name, fixture|
           begin
-            object.instance_variable_set "@#{name}", fixture.find
+            object.instance_variable_set "@#{fixture_name}", fixture.find
           rescue FixtureClassNotFound
             nil
           end
@@ -424,61 +428,59 @@ module ActiveRecord
     end
 
     def self.instantiate_all_loaded_fixtures(object, load_instances = true)
-      all_loaded_fixtures.each_value do |fixtures|
-        instantiate_fixtures(object, fixtures, load_instances)
+      all_loaded_fixtures.each_value do |fixture_set|
+        instantiate_fixtures(object, fixture_set, load_instances)
       end
     end
 
     cattr_accessor :all_loaded_fixtures
     self.all_loaded_fixtures = {}
 
-    def self.create_fixtures(fixtures_directory, table_names, class_names = {})
-      table_names = Array(table_names).map(&:to_s)
+    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {})
+      fixture_set_names = Array(fixture_set_names).map(&:to_s)
       class_names = class_names.stringify_keys
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
 
-      files_to_read = table_names.reject { |table_name|
-        fixture_is_cached?(connection, table_name)
+      files_to_read = fixture_set_names.reject { |fs_name|
+        fixture_is_cached?(connection, fs_name)
       }
 
       unless files_to_read.empty?
         connection.disable_referential_integrity do
           fixtures_map = {}
 
-          fixture_files = files_to_read.map do |path|
-            fixture_name = path
-
-            fixtures_map[fixture_name] = new( # ActiveRecord::Fixtures.new
+          fixture_sets = files_to_read.map do |fs_name|
+            fixtures_map[fs_name] = new( # ActiveRecord::Fixtures.new
               connection,
-              fixture_name,
-              class_names[fixture_name.to_s] || default_fixture_model_name(fixture_name),
-              ::File.join(fixtures_directory, path))
+              fs_name,
+              class_names[fs_name] || default_fixture_model_name(fs_name),
+              ::File.join(fixtures_directory, fs_name))
           end
 
           all_loaded_fixtures.update(fixtures_map)
 
           connection.transaction(:requires_new => true) do
-            fixture_files.each do |ff|
-              conn = ff.model_class.respond_to?(:connection) ? ff.model_class.connection : connection
-              table_rows = ff.table_rows
+            fixture_sets.each do |fs|
+              conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
+              table_rows = fs.table_rows
 
               table_rows.keys.each do |table|
                 conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
               end
 
-              table_rows.each do |table_name,rows|
+              table_rows.each do |fixture_set_name, rows|
                 rows.each do |row|
-                  conn.insert_fixture(row, table_name)
+                  conn.insert_fixture(row, fixture_set_name)
                 end
               end
             end
 
             # Cap primary key sequences to max(pk).
             if connection.respond_to?(:reset_pk_sequence!)
-              fixture_files.each do |ff|
-                connection.reset_pk_sequence!(ff.table_name)
+              fixture_sets.each do |fs|
+                connection.reset_pk_sequence!(fs.table_name)
               end
             end
           end
@@ -486,7 +488,7 @@ module ActiveRecord
           cache_fixtures(connection, fixtures_map)
         end
       end
-      cached_fixtures(connection, table_names)
+      cached_fixtures(connection, fixture_set_names)
     end
 
     # Returns a consistent, platform-independent identifier for +label+.
@@ -497,26 +499,23 @@ module ActiveRecord
 
     attr_reader :table_name, :name, :fixtures, :model_class
 
-    def initialize(connection, fixture_name, class_name, fixture_path)
-      @connection   = connection
-      @fixture_path = fixture_path
-      @name         = fixture_name
-      @class_name   = class_name
+    def initialize(connection, name, class_name, path)
+      @fixtures = {} # Ordered hash
+      @name     = name
+      @path     = path
 
-      @fixtures     = {}
-
-      # Should be an AR::Base type class
-      if class_name.is_a?(Class)
+      if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
         @model_class = class_name
       else
         @model_class = class_name.constantize rescue nil
       end
 
-      @connection  = model_class.connection if model_class && model_class.respond_to?(:connection)
+      @connection  = ( model_class.respond_to?(:connection) ?
+                       model_class.connection : connection )
 
       @table_name = ( model_class.respond_to?(:table_name) ?
                       model_class.table_name :
-                      self.class.default_fixture_table_name(fixture_name) )
+                      self.class.default_fixture_table_name(name) )
 
       read_fixture_files
     end
@@ -555,8 +554,8 @@ module ActiveRecord
         if model_class && model_class < ActiveRecord::Model
           # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
           if model_class.record_timestamps
-            timestamp_column_names.each do |name|
-              row[name] = now unless row.key?(name)
+            timestamp_column_names.each do |c_name|
+              row[c_name] = now unless row.key?(c_name)
             end
           end
 
@@ -634,21 +633,21 @@ module ActiveRecord
       end
 
       def read_fixture_files
-        yaml_files = Dir["#{@fixture_path}/**/*.yml"].select { |f|
+        yaml_files = Dir["#{@path}/**/*.yml"].select { |f|
           ::File.file?(f)
         } + [yaml_file_path]
 
         yaml_files.each do |file|
           Fixtures::File.open(file) do |fh|
-            fh.each do |name, row|
-              fixtures[name] = ActiveRecord::Fixture.new(row, model_class)
+            fh.each do |fixture_name, row|
+              fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
             end
           end
         end
       end
 
       def yaml_file_path
-        "#{@fixture_path}.yml"
+        "#{@path}.yml"
       end
 
   end
@@ -705,7 +704,7 @@ module ActiveRecord
       class_attribute :fixture_table_names
       class_attribute :fixture_class_names
       class_attribute :use_transactional_fixtures
-      class_attribute :use_instantiated_fixtures   # true, false, or :no_instances
+      class_attribute :use_instantiated_fixtures # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures
 
       self.fixture_table_names = []
@@ -713,9 +712,8 @@ module ActiveRecord
       self.use_instantiated_fixtures = false
       self.pre_loaded_fixtures = false
 
-      self.fixture_class_names = Hash.new do |h, fixture_name|
-        fixture_name = fixture_name.to_s
-        h[fixture_name] = ActiveRecord::Fixtures.default_fixture_model_name(fixture_name)
+      self.fixture_class_names = Hash.new do |h, fixture_set_name|
+        h[fixture_set_name] = ActiveRecord::Fixtures.default_fixture_model_name(fixture_set_name)
       end
     end
 
@@ -739,18 +737,18 @@ module ActiveRecord
         self.fixture_class_names = self.fixture_class_names.merge(class_names.stringify_keys)
       end
 
-      def fixtures(*fixture_names)
-        if fixture_names.first == :all
-          fixture_names = Dir["#{fixture_path}/**/*.yml"].map { |f|
+      def fixtures(*fixture_set_names)
+        if fixture_set_names.first == :all
+          fixture_set_names = Dir["#{fixture_path}/**/*.yml"].map { |f|
             File.basename f, '.yml'
           }
         else
-          fixture_names = fixture_names.flatten.map { |n| n.to_s }
+          fixture_set_names = fixture_set_names.flatten.map { |n| n.to_s }
         end
 
-        self.fixture_table_names |= fixture_names
-        require_fixture_classes(fixture_names)
-        setup_fixture_accessors(fixture_names)
+        self.fixture_table_names |= fixture_set_names
+        require_fixture_classes(fixture_set_names)
+        setup_fixture_accessors(fixture_set_names)
       end
 
       def try_to_load_dependency(file_name)
@@ -765,33 +763,39 @@ module ActiveRecord
         end
       end
 
-      def require_fixture_classes(fixture_names = nil)
-        (fixture_names || fixture_table_names).each do |fixture_name|
-          file_name = fixture_name.to_s
+      def require_fixture_classes(fixture_set_names = nil)
+        if fixture_set_names
+          fixture_set_names = fixture_set_names.map { |n| n.to_s }
+        else
+          fixture_set_names = fixture_table_names
+        end
+
+        fixture_set_names.each do |file_name|
           file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
           try_to_load_dependency(file_name)
         end
       end
 
-      def setup_fixture_accessors(fixture_names = nil)
-        fixture_names = Array(fixture_names || fixture_table_names)
+      def setup_fixture_accessors(fixture_set_names = nil)
+        fixture_set_names = Array(fixture_set_names || fixture_table_names)
         methods = Module.new do
-          fixture_names.each do |fixture_name|
-            fixture_name = fixture_name.to_s
-            accessor_name = fixture_name.tr('/', '_').to_sym
+          fixture_set_names.each do |fs_name|
+            fs_name = fs_name.to_s
+            accessor_name = fs_name.tr('/', '_').to_sym
 
-            define_method(accessor_name) do |*fixtures|
-              force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
+            define_method(accessor_name) do |*fixture_names|
+              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
 
-              @fixture_cache[fixture_name] ||= {}
+              @fixture_cache[fs_name] ||= {}
 
-              instances = fixtures.map do |fixture|
-                @fixture_cache[fixture_name].delete(fixture) if force_reload
+              instances = fixture_names.map do |f_name|
+                f_name = f_name.to_s
+                @fixture_cache[fs_name].delete(f_name) if force_reload
 
-                if @loaded_fixtures[fixture_name][fixture.to_s]
-                  @fixture_cache[fixture_name][fixture] ||= @loaded_fixtures[fixture_name][fixture.to_s].find
+                if @loaded_fixtures[fs_name][f_name]
+                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
                 else
-                  raise StandardError, "No entry named '#{fixture}' found for fixture collection '#{fixture_name}'"
+                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
                 end
               end
 
@@ -898,8 +902,8 @@ module ActiveRecord
           ActiveRecord::Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each_value do |fixtures|
-            ActiveRecord::Fixtures.instantiate_fixtures(self, fixtures, load_instances?)
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_set, load_instances?)
           end
         end
       end
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 345ae0b582..20279f814b 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -80,8 +80,8 @@ class ActiveSupport::TestCase
   self.use_instantiated_fixtures  = false
   self.use_transactional_fixtures = true
 
-  def create_fixtures(*table_names, &block)
-    ActiveRecord::Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, fixture_class_names, &block)
+  def create_fixtures(*fixture_set_names, &block)
+    ActiveRecord::Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, fixture_set_names, fixture_class_names, &block)
   end
 end