dfl-factories-and-workers 0.0.2

data/CHANGELOG

@@ -0,0 +1,10 @@
+* [10/14/2008] - 0.0.2 (gem release)
+  
+  Fixed problem with rails/init.rb
+  
+  
+* [08/05/2008] - 0.0.1 (gem release)
+  
+  Initial release as a gem.
+  
+  Removed some Rails specific code, but the gem is still dependent on activerecord.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007-2008 Nathan Herald, David Lowenfels and Jonathan Barket
+ 
+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.rdoc

@@ -0,0 +1,149 @@
+= Credits 
+
+Originally written by Nathan Herald @ Myobie.com
+
+Feature enhancements by David Lowenfels @ InternautDesign.com
+
+Minor improvements by Jonathan Barket
+
+== Get It
+
+Add it as a gem dependency
+
+  config.gem 'dfl-factories-and-workers', :lib => 'factories-and-workers', :source => 'http://gems.github.com'
+  
+Or install it as a gem manually  
+  
+  sudo gem install dfl-factories-and-workers
+  
+Or grab the source
+  
+  git clone git://github.com/dfl/factories-and-workers.git
+  
+=The Factory
+
+The Factory idea was inspired completely by Dan Manges' blog post "Fixin' Fixtures with Factory" @ http://www.dcmanges.com/blog/38
+
+
+The Factory is a module that has three methods for each model: +build_model+, +create_model+ and +valid_model_attributes+.
+( For semantic purposes, +default_model_attributes+ is also available as an alias to +valid_model_attributes+. )
+
+These methods create objects in a valid state, with default attributes and associations. When using the +create_model+ and +build_model+ methods, you can pass in a hash to override any of the default attributes if needed.
+Typically, you should create a file named 'factories.rb' in either the spec or test directory in your project to declare factory methods and default attributes.
+It will be loaded during plugin initialization (see init.rb). You could also explicitly require it from test_helper.rb
+
+A minimal factories.rb file:
+
+  include FactoriesAndWorkers::Factory    # mixin to Object, which is especially useful for script/console work; season to taste.
+
+  factory :user, :name => "default name"
+
+This would define methods named +build_user+, +create_user+, and +valid_user_attributes+ to be available in any Object in the project.
+If you wanted to override the default valid attributes, you could call:
+  create_user( :name => "a different name" )
+
+
+A more complicated example:
+
+  factory :role, :title => "role title"
+  
+  factory :user, {
+    :first_name => "Joe",
+    :last_name  => "Momma",
+    :password   => "$UNIQ(7)",                      # the $UNIQ(n) magic variable interpolates to a unique string of length n
+    :login      => "user_$COUNT",                   # the $COUNT magic variable interpolates to an incremental number, beginning with 1   
+    :role       => :belongs_to_model,
+    :created_at => lambda { Time.zone.now - 7 }     # lazy evaluation: will be called on object instantiation rather than factory definition
+  } do |u|                                          # code to be called in after_initialize hook
+    u.email = "#{u.first_name}.#{u.last_name}@example.com".downcase
+  end
+
+  factory :order, {
+    :quantity => 5,
+    :price    => 500,
+    :user     => :belongs_to_model
+    :number   => lambda { increment! :foo }         # increment a counter by arbitrary key
+  }
+
+  factory :special_order, {
+    :kind => 'Special'
+  }, :class => Order, :chain => lambda{ valid_order_attributes }   # reverse merges with valid_order_attributes
+
+
+A value of :belongs_to_model on an attribute adds logic to call +create_+ or +build_+, appropriately.
+For example:
+  valid_user_attributes         # assigns :role => build_role
+  build_user                    # assigns :role => build_role
+
+  create_user                   # assigns :role => create_role
+  valid_user_attributes(true)   # assigns :role => create_role
+In this way, models are not saved to the database unnecessarily.
+
+Note that if you pass a foreign key attribute as a build or create override, the corresponding default object will not be constructed.
+For example:
+  create_user( :role_id => 1 ) # will not call create_role.
+
+
+Two helper methods are available to be used in lambda blocks:
+* increment!( key ) -- increments a global counter keyed on a symbol or string
+* uniq( length ) -- returns a random string
+
+
+There is also a rake task to automagically generate template factories from your models.
+  rake factory:generate             # will print templates for all AR models
+  rake factory:generate MODEL=user  # will print template for user model
+
+
+=The FactoryWorker
+
+The FactoryWorker is a work in progress.
+
+If you create a file named 'factory_workers.rb' in either your spec or test directory, you can define snippets of code that can be ran at anytime, anywhere in your tests (this may not be true in the future, I may limit where it can be run, iono). 
+
+A factory worker is defined as so:
+
+  factory_worker :name do
+    # any ruby code you want
+  end
+
+Then, in your tests you can call 'worker :name' to run the ruby code contained in the worker.
+
+It can be useful for populating the database with objects:
+
+  factory_worker :salable_and_non_salable_products do
+    create_variant( :sku => "1" )
+    create_variant( :sku => "2" )
+    create_variant( :sku => "3", :in_stock => false )
+    create_variant( :sku => "4", :in_stock => false )
+  end
+
+The +create_variant+ method would provided by my factory setup, and creates a valid product with associated colors, sizes, and other options that I need. Now, I have 4 products in the database, 2 are in stock and 2 are not. So, in my test: find(:salable).length.should == 2
+
+And it does.
+
+Similar to rake task dependencies, you can chain workers together like this:
+
+  factory_worker :first do
+    puts "I am first"
+  end
+  
+  factory_worker :second => :first do
+    puts "I am second"
+  end
+  
+  factory_worker :third => :second do
+    puts "I am third"
+  end
+
+If you call 'worker :third', it should output:
+
+  I am first
+  I am second
+  I am third
+
+You can also chain workers like this:
+  factory_worker :several => [ :first, :second ]
+
+and even add dependencies to the chain in further statements
+  factory_worker :several => [ :third ]
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the factories-and-workers plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the factorires-and-workers plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'factories-and-workers'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,2 @@
+require "factories-and-workers"
+require File.dirname(__FILE__)+"/rails/init.rb" if defined?(RAILS_ENV)

data/lib/factories-and-workers.rb

@@ -0,0 +1,4 @@
+require 'active_support/core_ext'  # for returning() and HashWithIndifferentAccess
+require 'factories-and-workers/factory_builder'
+require 'factories-and-workers/factory_worker'
+require 'factories-and-workers/factory_generator'

data/lib/factories-and-workers/factory_builder.rb

@@ -0,0 +1,112 @@
+require 'digest/sha1'
+
+module FactoriesAndWorkers
+
+  module Factory
+    def self.included( base )
+      base.extend ClassMethods          
+    end
+    
+    module ClassMethods
+      def factory( kind, default_attrs, opts={}, &block )
+        FactoryBuilder.new( kind, default_attrs, opts, self, &block )
+      end
+
+      # creates a random hex string, converts it to hexatridecimal, and truncates to desired length (max 30)
+      def uniq len=10
+        Digest::SHA1.hexdigest("#{rand(1<<64)}/#{Time.now.to_f}/#{Process.pid}").to_i(16).to_s(36)[1..len]
+      end
+
+      @@factory_counter = Hash.new(0)
+      def increment! counter
+        @@factory_counter[ counter.to_s ] += 1
+      end
+
+      @@factory_initializers = {}
+      def factory_initializers
+        @@factory_initializers
+      end
+    end
+
+    # factory methods are defined as class methods; this delegation will allow them to also be called as instance methods
+    def method_missing method, *args, &block
+      if self.class.respond_to?( method )
+        self.class.send method, *args, &block
+      else
+        super
+      end
+    end
+
+  end
+
+  class FactoryBuilder
+    def initialize( factory, default_attrs, opts, from_klass, &block )
+      raise ArgumentError, ":chain must be a lambda block!" if opts[:chain] && !opts[:chain].is_a?( Proc )
+      opts.reverse_merge!( :class => factory )
+      
+      ar_klass = ActiveRecord.const_get( opts[:class].to_s.classify )
+      from_klass.factory_initializers[ factory ] = block if block_given?
+
+      # make the valid attributes method      
+      valid_attrs_method = :"valid_#{factory}_attributes"
+      Factory::ClassMethods.send :define_method, valid_attrs_method do |*args|
+        action         = args.first.is_a?( TrueClass ) ? :create : :build
+        attrs          = default_attrs.symbolize_keys
+        attr_overrides = args.extract_options!
+        attrs.merge!( attr_overrides.symbolize_keys ) if attr_overrides
+        attrs.reverse_merge!( opts[:chain].call ) if opts[:chain]
+        attrs.each_pair do |key, value|
+          if attr_overrides.keys.include?(:"#{key}_id")
+            attrs.delete(key)   # if :#{model}_id is overridden, then remove :#{model} and don't evaluate the lambda block
+          else
+            attrs[key] = case value
+            when Proc
+              value.call               # evaluate lambda blocks
+            when :belongs_to_model
+              send( :"#{action}_#{key}" )  # create or build model dependencies, if none are found in the db
+            when String                # interpolate magic variables
+              value.gsub( /\$UNIQ\((\d+)\)/ ){ from_klass.uniq( $1.to_i ) }.  
+              gsub( '$COUNT', from_klass.increment!( :"#{ar_klass}_#{key}" ).to_s )
+            else
+              value
+            end
+          end
+        end
+      end       
+
+      # make the valid attribute method, which only fetches a single attribute
+      valid_attr_method  = :"valid_#{factory}_attribute"
+      Factory::ClassMethods.send :define_method, valid_attr_method do |arg|
+        return unless arg.is_a?( Symbol )
+        base = default_attrs.dup
+        base.reverse_merge!( opts[:chain].call ) if opts[:chain]
+        returning base[ arg ] do |value|
+          value = value.call if value.is_a?( Proc )            # evaluate lambda if needed
+        end
+      end
+
+      # alias default_*_attributes to valid_*_attributes, for semantic equivalency
+      Factory::ClassMethods.send :alias_method, valid_attrs_method.to_s.gsub('valid','default').to_sym, valid_attrs_method
+      Factory::ClassMethods.send :alias_method,  valid_attr_method.to_s.gsub('valid','default').to_sym, valid_attr_method
+
+
+      after_initialize_block = from_klass.factory_initializers[ factory ]
+
+      # make the create method
+      Factory::ClassMethods.send :define_method, :"create_#{factory}" do |*args|
+        ar_klass.create!( self.send( valid_attrs_method, true, args.first ) ) do |obj|
+          after_initialize_block.call( obj ) if after_initialize_block
+        end
+      end
+
+      # make the build method
+      Factory::ClassMethods.send :define_method, :"build_#{factory}" do |*args|
+        ar_klass.new( self.send( valid_attrs_method, false, args.first ) ) do |obj|
+          after_initialize_block.call( obj ) if after_initialize_block
+        end
+      end
+
+    end #initialize
+  end
+
+end

data/lib/factories-and-workers/factory_generator.rb

@@ -0,0 +1,49 @@
+module Factory
+
+  IGNORED_COLUMNS = %w[ id created_at updated_at created_on updated_on ]
+
+  def self.generate_template arg
+    model = arg.classify.constantize
+    columns = {}
+    model.columns.each do |col|
+      key = col.name
+      if key =~ /^(.+)_id$/
+        columns[ $1.to_sym ]  = :belongs_to_model
+      else
+        columns[ key.to_sym ] = { :type => col.type, :default => col.default }
+      end unless IGNORED_COLUMNS.include?( key )
+    end
+
+    template = "\nfactory :#{model.to_s.underscore}, {\n"
+    columns.each_pair do |name, val|
+      template += "  :#{name} => #{ default_for( val ) },\n"
+    end
+    template += "}\n\n"
+  end
+
+  protected
+
+  def self.default_for val
+    case val
+    when :belongs_to_model
+      return val.inspect
+    when Hash
+      # return val[:default] if val[:default] # not sure if this works?
+      case val[:type]
+      when :integer
+        123
+      when :string, :text
+        "SomeString".inspect
+      when :float
+        1.23
+      when :date
+        "lambda{ 7.days.from_now }"
+      when :datetime
+        "lambda{ 12.hours.from_now }"
+      when :boolean
+        val[:default] || false
+      end
+    end
+  end
+
+end

data/lib/factories-and-workers/factory_worker.rb

@@ -0,0 +1,60 @@
+module FactoriesAndWorkers
+
+  module Worker
+    def worker( worker_name )
+      FactoryWorker.find_and_work worker_name
+    end
+
+    def self.included( base )
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def factory_worker( worker, &block )
+        FactoryWorker.new( worker, &block )
+      end
+    end
+
+  end
+
+  class FactoryWorker
+    @@workers = HashWithIndifferentAccess.new
+
+    def initialize( worker, &block )
+      case worker
+      when Hash
+        @dependencies = [ *worker.values.first ]
+        @worker = worker.keys.first
+      when Symbol, String
+        @worker = worker
+      else
+        raise ArgumentError, "I don't know how to make a factory worker out of '#{worker.inspect}'"
+      end
+
+      @block = block if block_given?
+      @@workers[ @worker ] = self
+    end
+
+    def self.find_and_work( worker_name )
+      raise ArgumentError, "There is no factory worker named '#{worker_name.to_s}' available" unless @@workers.include?(worker_name.to_s)
+      @@workers[ worker_name ].work
+    end
+
+    def work
+      @dependencies.each{ |w| self.class.find_and_work( w ) } if @dependencies
+      surface_errors{ @block.call( self ) } if @block
+    end
+
+    def surface_errors
+      yield
+    rescue Object => error
+      puts 
+      puts "There was an error working the factory worker '#{@worker}':", error.inspect
+      puts 
+      puts error.backtrace
+      puts 
+      exit!
+    end
+  end
+
+end

data/lib/tasks/generate_factories.rake

@@ -0,0 +1,18 @@
+desc "Generate factory templates from database schema; takes optional MODEL= argument"
+
+namespace :factory do
+
+  task :generate do
+    require File.join( RAILS_ROOT, 'config', 'environment' )
+
+    if arg = ENV['model'] || ENV['MODEL']
+      puts Factory.generate_template( arg )
+    else
+      all_models = Dir.glob( File.join( RAILS_ROOT, 'app', 'models', '*.rb') ).map{|path| path[/.+\/(.+).rb/, 1] }
+      all_models.select{|m| m.classify.constantize < ActiveRecord::Base}.each do |model|
+        puts Factory.generate_template( model )
+      end
+    end
+  end
+
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+require 'fileutils'
+
+# config.after_initialize do
+  %w(spec/factories.rb spec/factory_workers.rb test/factories.rb test/factory_workers.rb).each do |file|
+    path = File.join(Dir.pwd, file)
+    require path if File.exists?(path)
+  end
+# end

data/test/app/models/monkey.rb

@@ -0,0 +1,6 @@
+class Monkey < ActiveRecord::Base
+  attr_accessor :unique, :counter, :number
+    
+  belongs_to :pirate
+  validates_presence_of :name
+end

data/test/app/models/pirate.rb

@@ -0,0 +1,3 @@
+class Pirate < ActiveRecord::Base
+  has_one :monkey
+end

data/test/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  attr_accessor :first_name, :last_name, :email
+end

data/test/db/schema.rb

@@ -0,0 +1,17 @@
+ActiveRecord::Schema.define do
+
+  create_table :monkeys do |t|
+    t.column :name, :string
+  end
+  
+  create_table :pirates do |t|
+    t.column :catchphrase, :string
+    t.column :monkey_id, :integer
+    t.column :created_on, :datetime
+    t.column :updated_on, :datetime
+  end
+
+  create_table :users do |t|
+  end
+  
+end

data/test/factories.rb

@@ -0,0 +1,18 @@
+include FactoriesAndWorkers::Factory
+
+factory :monkey, {
+  :name    => "George",
+  :unique  => "$UNIQ(10)",
+  :counter => "$COUNT",
+  :number  => lambda{ increment! :foo }
+}
+
+factory :pirate, {
+  :catchphrase => "Ahhrrrr, Matey!",
+  :monkey      => :belongs_to_model,
+  :created_on  => lambda{ 1.day.ago }
+}
+
+factory :ninja_pirate, {
+  :catchphrase => "(silent)"
+}, :class => Pirate, :chain => lambda{ valid_pirate_attributes( :monkey => nil ) }

data/test/factory_builder_test.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class FactoryBuilderTest < Test::Unit::TestCase
+
+  def metaclass; class << self; self; end; end
+
+  def test_unknown_factory_raises_error
+    e = assert_raises(NameError) do
+      metaclass.class_eval do
+        factory :foo, {}
+      end
+    end
+    assert_equal "uninitialized constant ActiveRecord::Foo", e.message
+  end
+
+  def test_factory_with_initializer
+    metaclass.class_eval do      
+      factory :user, {
+        :first_name => "Joe",
+        :last_name  => "Blow"
+      } do |u| u.email = "#{u.first_name}.#{u.last_name}@example.com".downcase end        
+    end
+    assert_equal "joe.doe@example.com", build_user( :last_name => 'Doe' ).email
+  end
+
+  def test_build_monkey_does_not_save
+    assert_difference "Monkey.count", 0 do
+      build_monkey
+    end
+  end 
+
+  def test_create_monkey_does_save
+    assert_difference "Monkey.count", 1 do
+      create_monkey
+    end
+  end
+  
+  def test_valid_monkey_attributes
+    assert_equal( {:name => "George"}, remove_variability( valid_monkey_attributes ) )
+  end
+
+  def test_valid_pirate_attributes_without_create_parents
+    assert_difference "Monkey.count", 0 do
+      valid_pirate_attributes( false )
+    end
+  end
+  
+  def test_valid_pirate_attributes_with_create_parents
+    assert_difference "Monkey.count", 1 do
+      valid_pirate_attributes( true )
+    end
+  end
+
+  def test_valid_attribute__does_not_evaluate_other_attributes
+    assert_difference "Monkey.count", 0 do
+      assert_equal "Ahhrrrr, Matey!", valid_pirate_attribute(:catchphrase)
+    end
+  end
+
+  def test_build_pirate
+    assert_difference "Pirate.count", 0 do
+      assert_difference "Monkey.count", 0 do
+        build_pirate
+      end
+    end
+  end
+
+  def test_create_pirate_evaluates_lambda
+    assert_difference "Pirate.count", 1 do
+      assert_difference "Monkey.count", 1 do
+        @pirate = create_pirate
+      end
+    end
+    assert_equal @pirate.created_on.to_s, 1.day.ago.to_s
+    sleep 1
+    assert_not_equal create_pirate.updated_on.to_s, @pirate.updated_on.to_s
+  end
+
+  def test_ninja_pirate_is_silent_and_has_no_monkey
+    assert_difference "Pirate.count", 1 do
+      assert_difference "Monkey.count", 0 do
+        @pirate = create_ninja_pirate
+      end
+    end
+    assert_equal "(silent)", @pirate.catchphrase
+  end
+  
+  def test_overridden_attributes
+    @phil = create_monkey( :name => "Phil" )
+    assert_not_equal valid_monkey_attribute(:name), @phil.name, "default monkey name should be overridden"
+
+    assert_difference "Pirate.count", 0 do
+      assert_difference "Monkey.count", 0 do
+        @pirate = build_pirate( :monkey => @phil, :catchphrase => "chunky bacon!" )
+      end
+    end
+    assert_not_equal valid_pirate_attribute(:catchphrase), @pirate.catchphrase, "default pirate catchphrase should be overridden"
+    assert_equal "Phil", @pirate.monkey.name
+    assert_equal "George", build_pirate.monkey.name
+  end
+
+  def test_overridden_attribute_id_will_not_evaluate_lambda_for_model_creation
+    assert_difference "Monkey.count", 0 do
+      @pirate = build_pirate( :monkey_id => 1 )
+    end
+  end
+
+  def test_uniq_interpolation
+    a = build_monkey.unique
+    assert_equal 10, a.size
+
+    b = build_monkey.unique
+    assert_equal 10, b.size
+
+    assert_not_equal a, b
+  end
+
+  def test_count_interpolation_not_interfered_with_by_external_counter
+    assert_difference "build_monkey.counter.to_i", 1 do
+      increment!(:foo)
+    end
+  end
+  
+  def test_increment!
+    a = build_monkey.number
+    assert_equal a+1, build_monkey.number
+    assert_equal a+2, increment!(:foo)
+    assert_equal a+3, build_monkey.number
+  end
+  
+  def test_default_attributes_alias
+    hash1 = remove_variability( valid_monkey_attributes )
+    hash2 = remove_variability( default_monkey_attributes )
+    assert_equal hash1, hash2
+  end
+  
+  protected
+
+  def remove_variability hash
+    variable_attributes = [:unique, :counter, :number]
+    returning hash do
+      variable_attributes.each{ |a| hash.delete(a) }
+    end
+  end
+
+end

data/test/factory_worker_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class FactoryWorkerTest < Test::Unit::TestCase
+  include FactoriesAndWorkers::Worker
+  
+  factory_worker :one do
+    @@foo = "one!"
+  end
+
+  factory_worker :two => :one do
+    @@foo += " two!"
+  end
+
+  factory_worker :three do
+    @@foo += " three!"
+  end
+
+  factory_worker :count => [ :one, :two ]
+  factory_worker :count => [ :three ]
+  
+  def test_worker
+    worker :one
+    assert_equal "one!", @@foo
+  end
+
+  def test_worker_with_dependencies
+    worker :two
+    assert_equal "one! two!", @@foo
+  end
+
+  def test_worker_with_dependencies_2
+    worker :count
+    assert_equal "one! two! three!", @@foo
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,43 @@
+$:.reject!{ |e| e.include? 'TextMate' }
+
+require "test/unit"
+
+plugin_root = File.join(File.dirname(__FILE__), "..")
+app_root = File.join(plugin_root, "..", "..", "..")
+
+ENV["RAILS_ENV"] = "test"
+
+# pull in some basic Rails bits, but not our whole app, yo
+require File.expand_path(File.join(app_root, "config", "boot"))
+$:.unshift(File.expand_path(File.join(plugin_root, "lib")))
+
+# initialize the plugin
+require plugin_root + "/init"
+
+# pull in just what we need from Rails
+%w( active_record active_support ).each { |f| require f }
+
+
+# we'll use a totally standalone db for our testing
+options = { :adapter => "sqlite3", :timeout => 500, :database => ":memory:" }
+
+# establish the connection manually
+ActiveRecord::Base.establish_connection(options)
+  
+# ...and provide some connection data so that fixtures will work
+ActiveRecord::Base.configurations = { :sqlite3 => options }
+
+# kickstart
+ActiveRecord::Base.connection
+
+# create our test schema
+ActiveRecord::Migration.verbose = false
+require File.expand_path(File.join(plugin_root, "test", "db", "schema"))
+
+# pull in our test AR::B models
+models = Dir.glob(File.join(plugin_root, "test", "app", "models", "*.rb"))
+models.each { |m| require File.expand_path(m) }
+
+
+# load the factories
+require File.join( plugin_root, 'test', 'factories' )

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: dfl-factories-and-workers
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Nathan Herald
+- David Lowenfels
+- Jonathan Barket
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Fixtures replacement
+email: david@internautdesign.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- CHANGELOG
+- LICENSE
+- init.rb
+- Rakefile
+- lib/factories-and-workers
+- lib/factories-and-workers.rb
+- lib/factories-and-workers/factory_builder.rb
+- lib/factories-and-workers/factory_generator.rb
+- lib/factories-and-workers/factory_worker.rb
+- lib/tasks
+- lib/tasks/generate_factories.rake
+- rails
+- rails/init.rb
+- test/app
+- test/app/models
+- test/app/models/monkey.rb
+- test/app/models/pirate.rb
+- test/app/models/user.rb
+- test/db
+- test/db/schema.rb
+- test/factories.rb
+- test/factory_builder_test.rb
+- test/factory_worker_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://blog.internautdesign.com/2008/6/4/factories-and-workers-plugin
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Fixtures replacement
+test_files: []
+