fixture_builder 0.3.0

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/
+.pairs
+.idea/*
+*.db
+tmp/fixture_builder.yml
+test/fixtures/magical_creatures.yml
+Gemfile.lock

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.8.7@fixture_builder --create

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,97 @@
+FixtureBuilder
+==============
+
+Based on the code from fixture_scenarios, by Chris Wanstrath. Allows you to build file fixtures from an object mother factory.
+
+Installing
+==========
+
+ 1. Install as a plugin or gem:  `gem install fixture_builder`
+ 1. Create a file which configures and declares your fixtures (see below for example)
+ 1. Require the above file in your `spec_helper.rb` or `test_helper.rb`
+
+
+Example
+=======
+
+When using an object mother such as factory_girl it can be setup like the following:
+    
+    # I usually put this file in spec/support/fixture_builder.rb
+    FixtureBuilder.configure do |fbuilder|
+      # rebuild fixtures automatically when these files change:
+      fbuilder.files_to_check += Dir["spec/factories/*.rb", "spec/support/fixture_builder.rb"]
+      
+      # now declare objects
+      fbuilder.factory do
+        david = Factory(:user, :unique_name => "david")
+        ipod = Factory(:product, :name => "iPod")
+        Factory(:purchase, :user => david, :product => ipod)
+      end
+    end
+
+The block passed to the factory method initiates the creation of the fixture files.  Before yielding to the block, FixtureBuilder cleans out the test database completely.  When the block finishes, it dumps the state of the database into fixtures, like this:
+
+    # users.yml
+    david: 
+      created_at: 2010-09-18 17:21:23.926511 Z
+      unique_name: david
+      id: 1
+      
+    # products.yml
+    i_pod:
+      name: iPod
+      id: 1
+      
+    # purchases.yml
+    purchase_001:
+      product_id: 1
+      user_id: 1
+
+FixtureBuilder guesses about how to name fixtures based on a prioritized list of attribute names.  You can also hint at a name or manually name an object.  Both of the following lines would work to rename `purchase_001` to `davids_ipod`:
+
+    fbuilder.name(:davids_ipod, Factory(:purchase, :user => david, :product => ipod))
+    @davids_ipod = Factory(:purchase, :user => david, :product => ipod)
+    
+Another way to name fixtures is to use the name_model_with. To use it you create a block that returns how you want a certain model name based on the record field.
+
+    fbuilder.name_model_with(User) do |record|
+      [record['first_name'], record['last_name']].join('_')
+    end
+ 
+For all User fixture {first_name: 'foo', last_name: 'bar'} it would generate `foo_bar` as the fixture name.
+ 
+There are also additional configuration options that can be changed to override the defaults:
+
+ * files_to_check: array of filenames that when changed cause fixtures to be rebuilt
+ * fixture_builder_file: the pathname of the file used to store file changes.
+ * record_name_fields: array of field names to use as a fixture's name prefix, it will use the first matching field it finds
+ * skip_tables: array of table names to skip building fixtures
+ * select_sql: sql string to use for select
+ * delete_sql: sql string to use for deletes
+
+By default these are set as:
+
+ * files_to_check: %w{ db/schema.rb }
+ * fixture_builder_file: RAILS_ROOT/tmp/fixture_builder.yml
+ * record_name_fields: %w{ schema_migrations }
+ * skip_tables: %w{ schema_migrations }
+ * select_sql: SELECT * FROM %s
+ * delete_sql: DELETE FROM %s
+
+Sequence Collisions
+===================
+
+One problem with generating your fixtures is that sequences can collide.  When the fixtures are generated only as needed, sometimes the process that generates the fixtures will be different than the process that runs the tests.  This results in collisions when you still use factories in your tests.  Here's a solution for FactoryGirl which resets sequences numbers to 1000 (to avoid conflicts with fixture data which should e sequenced < 1000) before the tests run:
+
+    FixtureBuilder.configure do |fbuilder|
+      ...
+    end
+    
+    # Have factory girl generate non-colliding sequences starting at 1000 for data created after the fixtures 
+    Factory.sequences.each do |name, seq|
+      seq.instance_variable_set(:@value, 1000)
+    end
+
+
+
+Copyright (c) 2009 Ryan Dy & David Stevenson, released under the MIT license

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+include Rake::DSL if defined?(Rake::DSL)
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = false
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/fixture_builder.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'fixture_builder/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{fixture_builder}
+  s.version     = FixtureBuilder::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Ryan Dy', 'David Stevenson']
+  s.date = %q{2011-04-29}
+  s.description = %q{FixtureBuilder allows testers to use their existing factories, like FactoryGirl, to generate high performance fixtures that can be shared across all your tests}
+  s.email = %q{mail@ryandy.com}
+  s.extra_rdoc_files = [
+    'README.markdown'
+  ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.homepage = %q{http://github.com/rdy/fixture_builder}
+  s.rubyforge_project = %q{fixture_builder}
+  s.summary = %q{Build YAML fixtures using object factories}
+
+  s.add_dependency(%q{activerecord}, '>= 2')
+  s.add_dependency(%q{activesupport}, '>= 2')
+  s.add_development_dependency(%q{rake}, '0.8.7')
+  s.add_development_dependency(%q{test-unit})
+  s.add_development_dependency(%q{sqlite3})
+end

data/lib/fixture_builder.rb

@@ -0,0 +1,25 @@
+require 'fixture_builder/delegations'
+require 'fixture_builder/configuration'
+require 'fixture_builder/namer'
+require 'fixture_builder/builder'
+
+module FixtureBuilder
+  class << self
+    def configuration(opts = {})
+      @configuration ||= FixtureBuilder::Configuration.new(opts)
+    end
+
+    def configure(opts = {})
+      yield configuration(opts)
+    end
+  end
+
+  begin
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "tasks/fixture_builder.rake"
+      end
+    end
+  rescue LoadError, NameError
+  end
+end

data/lib/fixture_builder/builder.rb

@@ -0,0 +1,112 @@
+module FixtureBuilder
+  class Builder
+    include Delegations::Namer
+    include Delegations::Configuration
+
+    def initialize(configuration, namer, builder_block)
+      @configuration = configuration
+      @namer = namer
+      @builder_block = builder_block
+    end
+
+    def generate!
+      say "Building fixtures"
+      clean_out_old_data
+      create_fixture_objects
+      write_data_to_files
+      after_build.call if after_build
+    end
+
+    protected
+
+    def create_fixture_objects
+      load_legacy_fixtures if legacy_fixtures.present?
+      surface_errors { instance_eval &@builder_block }
+    end
+
+    def load_legacy_fixtures
+      legacy_fixtures.each do |fixture_file|
+        fixtures = ::Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+        populate_custom_names(fixtures)
+      end
+    end
+
+    def surface_errors
+      yield
+    rescue Object => error
+      puts
+      say "There was an error building fixtures", error.inspect
+      puts
+      puts error.backtrace
+      puts
+      exit!
+    end
+
+    def write_data_to_files
+      delete_yml_files
+      dump_empty_fixtures_for_all_tables
+      dump_tables
+    end
+
+    def clean_out_old_data
+      delete_tables
+      delete_yml_files
+    end
+
+    def delete_tables
+      tables.each { |t| ActiveRecord::Base.connection.delete(delete_sql % ActiveRecord::Base.connection.quote_table_name(t)) }
+    end
+
+    def delete_yml_files
+      FileUtils.rm(Dir.glob(fixtures_dir('*.yml'))) rescue nil
+    end
+
+    def say(*messages)
+      puts messages.map { |message| "=> #{message}" }
+    end
+
+    def dump_empty_fixtures_for_all_tables
+      tables.each do |table_name|
+        write_fixture_file({}, table_name)
+      end
+    end
+
+    def dump_tables
+      default_date_format = Date::DATE_FORMATS[:default]
+      Date::DATE_FORMATS[:default] = Date::DATE_FORMATS[:db]
+      begin
+        fixtures = tables.inject([]) do |files, table_name|
+          table_klass = table_name.classify.constantize rescue nil
+          if table_klass
+            rows = table_klass.all.collect(&:attributes)
+          else
+            rows = ActiveRecord::Base.connection.select_all(select_sql % ActiveRecord::Base.connection.quote_table_name(table_name))
+          end
+          next files if rows.empty?
+
+          row_index = '000'
+          fixture_data = rows.inject({}) do |hash, record|
+            hash.merge(record_name(record, table_name, row_index) => record)
+          end
+
+          write_fixture_file fixture_data, table_name
+
+          files + [File.basename(fixture_file(table_name))]
+        end
+      ensure
+        Date::DATE_FORMATS[:default] = default_date_format
+      end
+      say "Built #{fixtures.to_sentence}"
+    end
+
+    def write_fixture_file(fixture_data, table_name)
+      File.open(fixture_file(table_name), 'w') do |file|
+        file.write fixture_data.to_yaml
+      end
+    end
+
+    def fixture_file(table_name)
+      fixtures_dir("#{table_name}.yml")
+    end
+  end
+end

data/lib/fixture_builder/configuration.rb

@@ -0,0 +1,112 @@
+require 'active_support/core_ext'
+require 'active_support/core_ext/string'
+require 'digest/md5'
+require 'fileutils'
+
+module FixtureBuilder
+  class Configuration
+    include Delegations::Namer
+
+    ACCESSIBLE_ATTRIBUTES = [:select_sql, :delete_sql, :skip_tables, :files_to_check, :record_name_fields,
+                             :fixture_builder_file, :after_build, :legacy_fixtures, :model_name_procs]
+    attr_accessor(*ACCESSIBLE_ATTRIBUTES)
+
+    SCHEMA_FILES = ['db/schema.rb', 'db/development_structure.sql', 'db/test_structure.sql', 'db/production_structure.sql']
+
+    def initialize(opts={})
+      @namer = Namer.new(self)
+      @file_hashes = file_hashes
+    end
+
+    def include(*args)
+      class_eval do
+        args.each do |arg|
+          include arg
+        end
+      end
+    end
+
+    def factory(&block)
+      self.files_to_check += @legacy_fixtures.to_a
+      return unless rebuild_fixtures?
+      @builder = Builder.new(self, @namer, block).generate!
+      write_config
+    end
+
+    def select_sql
+      @select_sql ||= "SELECT * FROM %s"
+    end
+
+    def delete_sql
+      @delete_sql ||= "DELETE FROM %s"
+    end
+
+    def skip_tables
+      @skip_tables ||= %w{ schema_migrations }
+    end
+
+    def files_to_check
+      @files_to_check ||= schema_definition_files
+    end
+
+    def schema_definition_files
+      Dir['db/*'].inject([]) do |result, file|
+        result << file if SCHEMA_FILES.include?(file)
+        result
+      end
+    end
+
+    def files_to_check=(files)
+      @files_to_check = files
+      @file_hashes = file_hashes
+      @files_to_check
+    end
+
+    def record_name_fields
+      @record_name_fields ||= %w{ unique_name display_name name title username login }
+    end
+
+    def fixture_builder_file
+      @fixture_builder_file ||= ::Rails.root.join('tmp', 'fixture_builder.yml')
+    end
+
+    def name_model_with(model_class, &block)
+      @namer.name_model_with(model_class, &block)
+    end
+
+    def tables
+      ActiveRecord::Base.connection.tables - skip_tables
+    end
+
+    def fixtures_dir(path = '')
+      File.expand_path(File.join(::Rails.root, spec_or_test_dir, 'fixtures', path))
+    end
+
+    private
+
+    def spec_or_test_dir
+      File.exists?(File.join(::Rails.root, 'spec')) ? 'spec' : 'test'
+    end
+
+    def file_hashes
+      files_to_check.inject({}) do |hash, filename|
+        hash[filename] = Digest::MD5.hexdigest(File.read(filename))
+        hash
+      end
+    end
+
+    def read_config
+      return {} unless File.exist?(fixture_builder_file)
+      YAML.load_file(fixture_builder_file)
+    end
+
+    def write_config
+      FileUtils.mkdir_p(File.dirname(fixture_builder_file))
+      File.open(fixture_builder_file, 'w') { |f| f.write(YAML.dump(@file_hashes)) }
+    end
+
+    def rebuild_fixtures?
+      @file_hashes != read_config
+    end
+  end
+end

data/lib/fixture_builder/delegations.rb

@@ -0,0 +1,20 @@
+require 'active_support/core_ext/module/delegation'
+
+module FixtureBuilder
+  module Delegations
+    module Configuration
+      def self.included(base)
+        methods_to_delegate = [:fixtures_dir, :tables, :legacy_fixtures].concat(::FixtureBuilder::Configuration::ACCESSIBLE_ATTRIBUTES).flatten
+        methods_to_delegate.each do |meth|
+          base.delegate(meth, :to => :@configuration)
+        end
+      end
+    end
+
+    module Namer
+      def self.included(base)
+        base.delegate :record_name, :populate_custom_names, :name, :name_model_with, :to => :@namer
+      end
+    end
+  end
+end

data/lib/fixture_builder/namer.rb

@@ -0,0 +1,64 @@
+module FixtureBuilder
+  class Namer
+    include Delegations::Configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @custom_names = {}
+      @model_name_procs = {}
+      @record_names = []
+    end
+
+    def name_model_with(model_class, &block)
+      @model_name_procs[model_class.table_name] = block
+    end
+
+    def name(custom_name, *model_objects)
+      raise "Cannot name an object blank" unless custom_name.present?
+      model_objects.each do |model_object|
+        raise "Cannot name a blank object" unless model_object.present?
+        key = [model_object.class.table_name, model_object.id]
+        raise "Cannot set name for #{key.inspect} object twice" if @custom_names[key]
+        @custom_names[key] = custom_name
+        model_object
+      end
+    end
+
+    def populate_custom_names(fixtures)
+      fixtures.each do |fixture|
+        name = fixture[0]
+        id = fixture[1]['id'].to_i
+        table_name = fixture[1].model_class.table_name
+        key = [table_name, id]
+        @custom_names[key] = name
+      end
+    end
+
+    def record_name(record_hash, table_name, row_index)
+      key = [table_name, record_hash['id'].to_i]
+      name = case
+               when name_proc = @model_name_procs[table_name]
+                 name_proc.call(record_hash, row_index.succ!)
+               when custom = @custom_names[key]
+                 custom
+               else
+                 inferred_record_name(record_hash, table_name, row_index)
+             end
+      @record_names << name
+      name.to_s
+    end
+
+    protected
+    def inferred_record_name(record_hash, table_name, row_index)
+      record_name_fields.each do |try|
+        if name = record_hash[try]
+          inferred_name = name.underscore.gsub(/\W/, ' ').squeeze(' ').tr(' ', '_')
+          count = @record_names.select { |name| name.to_s.starts_with?(inferred_name) }.size
+            # CHANGED == to starts_with?
+          return count.zero? ? inferred_name : "#{inferred_name}_#{count}"
+        end
+      end
+      [table_name, row_index.succ!].join('_')
+    end
+  end
+end

data/lib/fixture_builder/version.rb

@@ -0,0 +1,3 @@
+module FixtureBuilder
+  VERSION = '0.3.0'
+end

data/lib/tasks/fixture_builder.rake

@@ -0,0 +1,19 @@
+namespace :spec do
+  namespace :fixture_builder do
+    desc "Deletes the generated fixtures in spec/fixtures"
+    task :clean do
+      FileUtils.rm_f("tmp/fixture_builder.yml")
+      FileUtils.rm_f(Dir.glob('spec/fixtures/*.yml'))
+      puts "Automatically generated fixtures removed"
+    end
+
+    desc "Build the generated fixtures to spec/fixtures if dirty"
+    task :build => :environment do
+      ActiveRecord::Base.establish_connection('test')
+      Dir.glob(File.join(Rails.root, '{spec,test}', '**', 'fixture_builder.rb')).each{|file| require(file)}
+    end
+
+    desc "Clean and rebuild the generated fixtures to spec/fixtures"
+    task :rebuild => [:clean, :build]
+  end
+end

data/test/fixture_builder_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+
+class Model
+  def self.table_name
+    'models'
+  end
+end
+
+class FixtureBuilderTest < Test::Unit::TestCase
+  def teardown
+    FixtureBuilder.instance_variable_set(:'@configuration', nil)
+  end
+
+  def test_name_with
+    hash = {
+        'id' => 1,
+        'email' => 'bob@example.com'
+    }
+    FixtureBuilder.configure do |config|
+      config.name_model_with Model do |record_hash, index|
+        [record_hash['email'].split('@').first, index].join('_')
+      end
+    end
+    assert_equal 'bob_001', FixtureBuilder.configuration.send(:record_name, hash, Model.table_name, '000')
+  end
+
+  def test_configure
+    FixtureBuilder.configure do |config|
+      assert config.is_a?(FixtureBuilder::Configuration)
+      @called = true
+    end
+    assert @called
+  end
+
+  def test_spec_or_test_dir
+    assert_equal 'test', FixtureBuilder.configuration.send(:spec_or_test_dir)
+  end
+
+  def test_fixtures_dir
+    assert_match /test\/fixtures$/, FixtureBuilder.configuration.send(:fixtures_dir).to_s
+  end
+end

data/test/legacy_fixture_mode_fixture_generation_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+create_and_blow_away_old_db
+force_fixture_generation
+
+FixtureBuilder.configure do |fbuilder|
+  fbuilder.legacy_fixtures = Dir[test_path("legacy_fixtures/*.yml"), test_path("other_legacy_fixture_set/*.yml")] 
+  fbuilder.factory do
+    MagicalCreature.create(:name => "frank", :species => "unicorn")
+  end
+end
+
+class LegacyFixtureModeFixtureGenerationTest < Test::Unit::TestCase
+  @@magical_creatures = YAML.load(File.open(test_path("fixtures/magical_creatures.yml")))
+
+  def test_legacy_fixtures_created
+    alice = MagicalCreature.find_by_name("alice")
+    assert_equal "alice", alice.name
+    assert_equal "mermaid", alice.species
+  end
+
+  def test_invalid_legacy_fixtures_created
+    bigfoot = MagicalCreature.find(5)
+    assert_equal "bigfoot", bigfoot.name
+
+    assert_equal 5, @@magical_creatures['bigfoot']['id']
+    assert_equal "bigfoot", @@magical_creatures['bigfoot']['name']
+    assert_nil @@magical_creatures['bigfoot']['species']
+  end
+
+  def test_new_fixtures_are_created
+    assert_equal "frank", @@magical_creatures['frank']['name']
+    assert_equal "unicorn", @@magical_creatures['frank']['species']
+  end
+
+  def test_legacy_fixtures_retain_fixture_name
+    assert_equal "alice", @@magical_creatures['alice_the_mermaid']['name']
+    assert_equal "mermaid", @@magical_creatures['alice_the_mermaid']['species']
+  end
+end

data/test/legacy_fixture_mode_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class LegacyFixtureModeTest < Test::Unit::TestCase
+  def setup
+    create_and_blow_away_old_db
+    force_fixture_generation
+  end
+
+  def teardown
+    FixtureBuilder.send(:remove_instance_variable, :@configuration)
+  end
+
+  def test_load_legacy_fixtures
+    FixtureBuilder.configure do |fbuilder|
+      fbuilder.legacy_fixtures = Dir[test_path("legacy_fixtures/*.yml"), test_path("other_legacy_fixture_set/*.yml")] 
+      fbuilder.factory do
+      end
+    end
+    assert_equal 3, MagicalCreature.all.size
+  end
+
+  def test_generate_new_fixtures_without_legacy
+    FixtureBuilder.configure do |fbuilder|
+      fbuilder.files_to_check += Dir[test_path("*.rb")]
+      fbuilder.factory do
+        MagicalCreature.create :name => "Melinda", :species => "Philanthropist"
+      end
+    end
+    assert_equal 1, MagicalCreature.all.size
+  end
+
+  def test_new_and_old_fixtures
+    FixtureBuilder.configure do |fbuilder|
+      fbuilder.legacy_fixtures = Dir[test_path("legacy_fixtures/*.yml"), test_path("other_legacy_fixture_set/*.yml")] 
+      fbuilder.factory do
+        MagicalCreature.create :name => "Barry", :species => "Party Guy"
+      end
+    end
+    assert_equal 4, MagicalCreature.all.size
+  end
+end

data/test/legacy_fixtures/magical_creatures.yml

@@ -0,0 +1,12 @@
+bigfoot:
+  name: bigfoot
+  id: 5
+
+alice_the_mermaid:
+  name: alice
+  species: mermaid
+  id: 300
+
+xou_the_dragon:
+  name: xou
+  species: dragon

data/test/namer_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Model
+  def self.table_name
+    'models'
+  end
+end
+
+class NamerTest < Test::Unit::TestCase
+  def setup
+    configuration = FixtureBuilder::Configuration.new
+    @namer = FixtureBuilder::Namer.new(configuration)
+  end
+
+  def test_name_with
+    hash = {
+        'id' => 1,
+        'email' => 'bob@example.com'
+    }
+
+    @namer.name_model_with Model do |record_hash, index|
+      [record_hash['email'].split('@').first, index].join('_')
+    end
+
+    assert_equal 'bob_001', @namer.record_name(hash, Model.table_name, '000')
+  end
+
+  def test_record_name_without_name_with_or_custom_name
+    hash = {
+        'id' => 1,
+        'email' => 'bob@example.com'
+    }
+    assert_equal 'models_001', @namer.record_name(hash, Model.table_name, '000')
+  end
+
+  def test_record_name_with_inferred_record_name
+    hash = {
+        'id' => 1,
+        'title' => 'foo',
+        'email' => 'bob@example.com'
+    }
+    assert_equal 'foo', @namer.record_name(hash, Model.table_name, '000')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'fixture_builder'
+
+class Rails
+  def self.root
+    Pathname.new(File.join(File.dirname(__FILE__), '..'))
+  end
+end
+
+def test_path(glob)
+  File.join(Rails.root, 'test', glob)
+end
+
+require "active_support/concern"
+require "active_record"
+require "sqlite3"
+require "active_record/fixtures"
+
+class MagicalCreature < ActiveRecord::Base
+  validates_presence_of :name, :species
+end
+
+def create_and_blow_away_old_db
+  ActiveRecord::Base.configurations['test'] = {
+      'adapter' => 'sqlite3',
+      'database' => 'test.db'
+  }
+  ActiveRecord::Base.establish_connection(:test)
+
+  ActiveRecord::Base.connection.create_table(:magical_creatures, :force => true) do |t|
+    t.column :name, :string
+    t.column :species, :string
+  end
+end
+
+def force_fixture_generation
+  begin
+    FileUtils.rm(File.expand_path("../../tmp/fixture_builder.yml", __FILE__))
+  rescue
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: fixture_builder
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Ryan Dy
+- David Stevenson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-29 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: FixtureBuilder allows testers to use their existing factories, like FactoryGirl, to generate high performance fixtures that can be shared across all your tests
+email: mail@ryandy.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- .pairs
+- .rvmrc
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- fixture_builder.gemspec
+- lib/fixture_builder.rb
+- lib/fixture_builder/builder.rb
+- lib/fixture_builder/configuration.rb
+- lib/fixture_builder/delegations.rb
+- lib/fixture_builder/namer.rb
+- lib/fixture_builder/version.rb
+- lib/tasks/fixture_builder.rake
+- test/fixture_builder_test.rb
+- test/fixtures/.gitkeep
+- test/legacy_fixture_mode_fixture_generation_test.rb
+- test/legacy_fixture_mode_test.rb
+- test/legacy_fixtures/magical_creatures.yml
+- test/namer_test.rb
+- test/test_helper.rb
+- tmp/.gitkeep
+has_rdoc: true
+homepage: http://github.com/rdy/fixture_builder
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fixture_builder
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Build YAML fixtures using object factories
+test_files: 
+- test/fixture_builder_test.rb
+- test/fixtures/.gitkeep
+- test/legacy_fixture_mode_fixture_generation_test.rb
+- test/legacy_fixture_mode_test.rb
+- test/legacy_fixtures/magical_creatures.yml
+- test/namer_test.rb
+- test/test_helper.rb