TEST_CODEOWNERS/rails
3
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge pull request #4254 from alexeymuranov/my-nicify-fixtures-rb

Browse Source 
Rename variables and remove unused code in fixtures.rb
This commit is contained in:
Jeremy Kemper 2012-05-09 19:01:03 -07:00
commit 42a14c436c
2 changed files with 82 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
activerecord/lib/active_record/fixtures.rb
View File

@ -372,19 +372,23 @@ class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
#
# 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 @@ def self.cache_fixtures(connection, fixtures_map)
cache_for_connection(connection).update(fixtures_map)
end
def self.instantiate_fixtures(object, fixture_name, 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 @@ def self.instantiate_fixtures(object, fixture_name, fixtures, load_instances = t
end
def self.instantiate_all_loaded_fixtures(object, load_instances = true)
all_loaded_fixtures.each do |table_name, fixtures|
ActiveRecord::Fixtures.instantiate_fixtures(object, table_name, 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 @@ def self.create_fixtures(fixtures_directory, table_names, class_names = {})
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 @@ def self.identify(label)
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 @@ def table_rows
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,26 +633,23 @@ def column_names
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
def yaml_fixtures_key(path)
::File.basename(@fixture_path).split(".").first
end
end
class Fixture #:nodoc:
@ -708,7 +704,7 @@ module TestFixtures
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 = []
@ -716,9 +712,8 @@ module TestFixtures
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
@ -742,18 +737,18 @@ def set_fixture_class(class_names = {})
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)
@ -768,33 +763,39 @@ def try_to_load_dependency(file_name)
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
@ -901,8 +902,8 @@ def instantiate_fixtures
ActiveRecord::Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
else
raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
@loaded_fixtures.each do |fixture_name, fixtures|
ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_name, fixtures, load_instances?)
@loaded_fixtures.each_value do |fixture_set|
ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_set, load_instances?)
end
end
end

4
activerecord/test/cases/helper.rb
View File

@ -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