aub-machine 1.0.0

data/README.textile

@@ -0,0 +1,158 @@
+h1. machine
+
+Machine is a factory tool designed for a fixture replacement in Rails applications. It borrows a few concepts
+from "factory_girl":http://github.com/thoughtbot/factory_girl/tree/master but applies attributes to objects
+differently and has a different concept for associations.
+
+Written by "Aubrey Holland":mailto:aubreyholland@gmail.com.
+
+h2. download
+
+Github: "Page":http://github.com/aub/machine/tree/master
+
+Gem: <pre>gem install aub-machine --source http://gems.github.com</pre>
+
+Note: if you install using the gem from Github, you'll need this
+in your environment.rb if you want to use Rails 2.1's dependency manager:
+
+config.gem "aub-machine",
+           :lib    => "machine",
+           :source => "http://gems.github.com"
+
+h3. define a machine
+
+<pre><code>
+Machine.define :car do |car, machine|
+  car.make = 'Ford'
+  car.model = 'Taurus'
+end
+</code></pre>
+
+This defines a factory for building Car objects. The block is yielded an instance of the Car class
+along with a machine object that can be used for building associated objects. Optionally, a class
+name can be provided in cases where the name of the machine is not the same as that of the class.
+
+<pre><code>
+  Machine.define :auto, :class => Car do |auto, machine|
+    ...
+  end
+</code></pre>
+
+Machines can also be extended to any number of levels. When an extended machine is executed, the
+tree will be applied starting from the bottom. This is useful in cases where one machine is a
+specialization of another one.
+
+<pre><code>
+  Machine.define :car do |car, machine|
+    car.make = 'Ford'
+    car.type = 'Car'
+  end
+  
+  Machine.define :station_wagon, :class => Car, :extends => :car do |car, machine|
+    car.type = 'Station Wagon'
+  end
+</code></pre>
+
+In addition, groups of machines can be defined that are built from a set of base attributes.
+This is useful for namespacing similar types.
+
+<pre><code>
+  Machine.define_group :user do |group|
+    group.base do |user, machine|
+      user.password = 'password'
+      user.password_confirmation = 'password'
+      user.status = 'active'
+      user.permissions = 'none'
+    end
+
+    group.define :super_user do |user, machine|
+      user.permissions = 'super'
+    end
+  end
+</code></pre>
+
+This defines two machines, user and super_user, where super_user has all of the attributes of
+user but with a different permissions value.
+
+h3. use a machine
+
+Machines can be applied using one of three methods:
+
+<pre><code>
+  Machine(:car)           # creates an unsaved object using the machine 'car'.
+  Machine.build(:car)     # same as above.
+  Machine.build!(:car)    # creates an object using the 'car' machine and saves it.
+</code></pre>
+
+With each of these methods, a hash of replacement attributes can be passed, and those
+attributes will be used in place of the default ones defined in the machine.
+
+<pre><code>
+  Machine(:car, :make => 'Ferrari')
+</code></pre>
+  
+h3. associations
+
+Associations are filled using the machine object that is yielded in the block of the machine
+definition. Instances of other machines can be created by calling the object with the name of
+the machine.
+
+<pre><code>
+  Machine.define :garage do |garage, machine|
+    garage.car = machine.car
+  end
+</code></pre>
+
+Replacement attributes can be passed to the machine in order to specialize the instance
+for for a given association.
+
+<pre><code>
+  Machine.define :garage do |garage, machine|
+    garage.cars = [machine.car(:model => 'Thunderbird'), machine.car(:model => 'Mustang')]
+  end
+</code></pre>
+
+h3. sequences
+
+In cases where an attribute is required to be unique, sequences can be used. A sequence is
+defined as a block that takes as its argument a unique integer and returns a result.
+
+<pre><code>
+  Machine.sequence :vin do |n|
+    "abc123-#{n}"
+  end
+</code></pre>
+
+Sequences can then be used in machine definitions to set attribute values.
+
+<pre><code>
+  Machine.define :car do |car, machine|
+    car.vin = machine.next(:vin)
+    car.make = 'Honda'
+  end
+</code></pre>
+
+h1. license
+
+(The MIT License)
+
+Copyright (c) 2008 Aubrey Holland and patch
+
+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/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the machine.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the machine.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Machine'
+  rdoc.options << '--line-numbers' << '--inline-source' << "--main" << "README.textile"
+  rdoc.rdoc_files.include('README.textile')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name        = %q{machine}
+  s.version     = "1.0.0"
+  s.summary     = %q{machine defines a factory system for creating model objects to replace fixtures in Ruby apps.}
+  s.description = %q{machine defines a factory system for creating model objects to replace fixtures in Ruby apps.}
+
+  s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'test/**/*.rb']
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['test/**/*_test.rb']]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.textile"]
+  s.rdoc_options = ['--line-numbers', '--inline-source', "--main", "README.textile"]
+
+  s.authors = ["Aubrey Holland"]
+  s.email   = %q{aubrey@patch.com}
+
+  s.platform = Gem::Platform::RUBY
+  s.add_dependency(%q<activesupport>, [">= 1.0"])
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/lib/machine/association_helper.rb

@@ -0,0 +1,16 @@
+class AssociationHelper
+  
+  def initialize #:nodoc
+    
+  end
+  
+  def next(sequence) #:nodoc
+    Machine.next(sequence)
+  end
+  
+  def method_missing(name, *args) #:nodoc
+    if Machine.machines.has_key?(name)
+      Machine.machines[name].build(*args)
+    end
+  end  
+end

data/lib/machine/machine.rb

@@ -0,0 +1,226 @@
+class MachineNotFoundError < StandardError; end
+
+class Machine
+  
+  cattr_accessor :machines #:nodoc:
+  self.machines = {}
+  
+  cattr_accessor :sequences #:nodoc:
+  self.sequences = {}
+
+  # An Array of strings specifying locations that should be searched for
+  # machine definitions. By default, machine will attempt to require
+  # "machines," "test/machines," and "spec/machines." Only the first
+  # existing file will be loaded.
+  cattr_accessor :definition_file_paths
+  self.definition_file_paths = %w(machines test/machines spec/machines)
+  
+  def self.find_definitions #:nodoc:
+    definition_file_paths.each do |file_path|
+      begin
+        require(file_path)
+        break
+      rescue LoadError
+      end
+    end
+  end
+  
+  # Defines a new machine that sets up the default attributes for new objects.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name used to identify this machine.
+  #   options: (Hash)
+  #     class: (Class) the class that will be used when generating instances for this
+  #            machine. If not specified, the class will be guessed from the 
+  #            machine name.
+  #     extends: (Symbol) the name of a machine that will be extended by this one.
+  #              If provided, the attributes of the extended machine will be applied
+  #              to the object before the one being defined.
+  #
+  # Yields:
+  #    The object being created and an association helper
+  #
+  # Example:
+  #
+  #   Machine.define :car do |car, machine|
+  #     car.make = 'GMC'
+  #     car.model = 'S-15'
+  #   end
+  def self.define(name, options={}, &block)
+    self.machines[name] = Machine.new(name, options, block)
+  end
+
+  # Defines a group of machines with a base set of attributes and then a set of
+  # machines as children. This is useful as a namespacing technique or for any
+  # case where you wish to define a set of objects that share a set of base
+  # attributes.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name to identify the group. This name will itself become a machine
+  #     that will build from the base attributes.
+  #   options: (Hash)
+  #     class: (Class) the class that will be used when generating instances for this
+  #            machine. If not specified, the class will be guessed from the 
+  #            machine name.
+  #
+  # Example
+  #
+  #   Machine.define_group :user do |group|
+  #     group.base do |user, machine|
+  #       user.password = 'password'
+  #       user.password_confirmation = 'password'
+  #       user.login = Machine.next(:login)
+  #       user.email = Machine.next(:email)
+  #     end
+  # 
+  #     group.define :super_user do |user, machine|
+  #       user.permissions = [machine.permission(:user => user)]
+  #     end
+  #   end
+  #
+  #   Machine.build(:user)
+  #   Machine.build(:super_user)
+  #
+  def self.define_group(name, options={}, &block)
+    group = MachineGroup.new(name, options)
+    yield group
+  end
+
+  # Creates an unsaved object using the machine with the given name.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of the machine to apply.
+  #   attributes: (Hash)
+  #     A set of attributes to use as a replacement for the default ones provided by
+  #     the machine.
+  #
+  # Example
+  #
+  #   Machine.build(:car, :model => 'Civic', :make => 'Honda')
+  def self.build(name, attributes={})
+    machines = machines_for(name)
+    raise MachineNotFoundError if machines.empty?
+    object = machines.shift.build(attributes)
+    while machine = machines.shift
+      machine.apply_to(object, attributes)
+    end
+    object
+  end
+
+  # Creates an saved object using the machine with the given name.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of the machine to apply.
+  #   attributes: (Hash)
+  #     A set of attributes to use as a replacement for the default ones provided by
+  #     the machine.
+  #
+  # Example
+  #
+  #   Machine.build!(:car, :model => 'Civic', :make => 'Honda')  
+  def self.build!(name, attributes={})
+    result = build(name, attributes)
+    result.save! if result.respond_to?(:save!)
+    result
+  end
+
+  # Apply the machine with the given name to the provided object. This can
+  # be used to load an existing object with the attributes defined in a machine.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of the machine to apply.
+  #   object: (Object)
+  #     The object whose attributes should be set.
+  #   attributes: (Hash)
+  #     A set of replacements attributes for those specified in the machine.
+  #
+  # Example
+  #
+  #   car = Car.new
+  #   Machine.apply_to(:car, car, :model => 'Jetta')
+  def self.apply_to(name, object, attributes={})
+    machines = machines_for(name)
+    return if machines.empty?
+    while machine = machines.shift
+      machine.apply_to(object, attributes)
+    end
+    object    
+  end
+
+  # Defines a new named sequence. Sequences can be used to set attributes
+  # that must be unique. Once a sequence is created it can be applied by
+  # calling Machine.next, passing the sequence name.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name used to identify this sequence.
+  #   block: (Proc)
+  #     The code to generate each value in the sequence. This block will be
+  #     called with a unique number each time a value in the sequence is to be
+  #     generated. The block should return the generated value for the
+  #     sequence.
+  #
+  # Example
+  #
+  #   Machine.sequence :street do |n|
+  #     "#{n} Main St."
+  #   end
+  def self.sequence(name, &block)
+    self.sequences[name] = Sequence.new(block)
+  end
+
+  # Get the next value produced by the sequence with the given name. This
+  # can be used in machine definitions to fill in attributes that must be
+  # unique.
+  #
+  # Arguments:
+  #   sequence: (Symbol)
+  #     The name of the sequence to use.
+  #
+  # Example
+  #
+  #   Machine.define :address do |address, machine|
+  #     address.street = machine.next(:street)
+  #   end
+  def self.next(sequence)
+    sequences[sequence].next if sequences.has_key?(sequence)
+  end
+  
+  def initialize(name, options, proc) #:nodoc
+    @name, @options, @proc = name, options, proc
+  end
+  
+  def extends #:nodoc
+    @options[:extends] ? machines[@options[:extends]] : nil
+  end
+  
+  def build(attributes={}) #:nodoc
+    object = build_class.new
+    apply_to(object, attributes)
+    object
+  end
+
+  def apply_to(object, attributes={}) #:nodoc
+    @proc.call(object, AssociationHelper.new)
+    attributes.each { |key, value| object.send("#{key}=", value) }
+  end
+
+  protected
+  
+  def build_class #:nodoc
+    @options[:class] || @name.to_s.camelize.constantize
+  end
+  
+  def self.machines_for(name) #:nodoc
+    result = [machines[name]]
+    while result.last
+      result << result.last.extends
+    end
+    result.compact.reverse
+  end
+end

data/lib/machine/machine_group.rb

@@ -0,0 +1,22 @@
+class MachineGroup
+  
+  def initialize(name, options={}) #:nodoc
+    @name = name
+    @options = options
+  end
+  
+  def base(&block) #:nodoc
+    @base_machine = Machine.new(@name, @options, block)
+    Machine.machines[@name] = @base_machine
+  end
+  
+  def define(name, &block) #:nodoc
+    if @base_machine
+      options = @options.merge(:extends => @name)
+    else
+      options = @options.merge(:class => (@options[:class] || @name.to_s.camelize.constantize))
+    end
+    machine = Machine.new(name, options, block)
+    Machine.machines[name] = machine
+  end
+end

data/lib/machine/sequence.rb

@@ -0,0 +1,12 @@
+class Sequence
+  
+  def initialize(proc) #:nodoc
+    @proc, @current_value = proc, 0
+  end
+  
+  def next #:nodoc
+    @current_value += 1
+    @proc.call(@current_value)
+  end
+  
+end

data/lib/machine.rb

@@ -0,0 +1,15 @@
+require 'machine/association_helper'
+require 'machine/machine'
+require 'machine/machine_group'
+require 'machine/sequence'
+
+# Find the definitions in the default locations:
+# machines.rb
+# test/machines.rb
+# spec/machines.rb
+Machine.find_definitions
+
+# Shorthand method for building a machine, is an alias for Machine.build(name, attributes)
+def Machine(name, attributes={})
+  Machine.build(name, attributes)
+end

data/machine.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.version = '1.0.0'
+  s.date = %q{2008-11-07}
+ 
+  s.name = %q{machine}
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Aubrey Holland', 'patch']
+  s.description = %q{machine defines a factory system for creating model objects to replace fixtures in Ruby apps.}
+  s.email = %q{aubrey@patch.com}
+  s.files = ['lib', 'lib/machine', 'lib/machine/association_helper.rb', 'lib/machine/machine.rb', 'lib/machine/machine_group.rb', 'lib/machine/sequence.rb', 'lib/machine.rb', 'machine-1.0.0.gem', 'machine.gemspec', 'rails', 'rails/init.rb', 'Rakefile', 'README.textile', 'test', 'test/machine_group_test.rb', 'test/machine_test.rb', 'test/models.rb', 'test/sequence_test.rb', 'test/test.db', 'test/test_helper.rb', 'TODO.textile']
+  s.homepage = %q{http://github.com/aub/machine/tree/master}
+  s.require_paths = ['lib']
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Machine crunches factories.}
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.textile']
+  s.rdoc_options = ['--line-numbers', '--inline-source', '--main', 'README.textile']
+  s.test_files = ['test/machine_test.rb', 'test/machine_group_test.rb', 'test/sequence_test.rb']
+  
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'machine'

data/test/machine_group_test.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class MachineGroupTest < Test::Unit::TestCase
+
+  def setup
+    Machine.machines.clear
+  end
+  
+  context "defining the base machine" do
+    setup do
+      @group = MachineGroup.new(:article)
+    end
+
+    should "create a machine from the name of the group" do
+      @group.base do |article, machine|
+        article.title = 'ooooh'
+      end
+      a = Machine(:article)
+      assert_equal 'ooooh', a.title
+    end
+  end
+
+  context "creating a group with a specified class" do
+    setup do
+      @group = MachineGroup.new(:whoosit, :class => Article)
+    end
+
+    should "create the correct type of object and set its attributes" do
+      @group.base do |article, machine|
+        article.title = 'ooooh'
+      end
+      a = Machine(:whoosit)
+      assert a.instance_of?(Article)
+      assert_equal 'ooooh', a.title      
+    end
+  end
+
+  context "defining the sub-machines" do
+    setup do
+      @group = MachineGroup.new(:article)
+      @group.base do |article, machine|
+        article.title = 'ooooh'
+        article.rating = 3
+      end
+      @group.define :arts_article do |article, machine|
+        article.title = 'awww'
+      end
+    end
+
+    should "create a machine for the sub-machine" do
+      a = Machine(:arts_article)
+      assert a.instance_of?(Article)
+    end
+    
+    should "set make the new machine an extension of the base" do
+      a = Machine(:arts_article)
+      assert_equal 'awww', a.title
+      assert_equal 3, a.rating
+    end
+  end
+  
+  context "defining sub-machines with no base" do
+    setup do
+      @group = MachineGroup.new(:article)
+      @group.define :arts_article do |article, machine|
+        article.title = 'awww'
+      end
+    end
+
+    should "create a machine for the sub-machine" do
+      a = Machine(:arts_article)
+      assert a.instance_of?(Article)
+    end
+    
+    should "set the attributes correctly" do
+      a = Machine(:arts_article)
+      assert_equal 'awww', a.title
+    end
+  end
+  
+  context "creating a group with a specified class and no base" do
+    setup do
+      @group = MachineGroup.new(:whoosit, :class => Article)
+      @group.define :arts_article do |article, machine|
+        article.title = 'ummm'
+      end
+    end
+
+    should "create the right type of object and set its attributes" do
+      a = Machine(:arts_article)
+      assert a.instance_of?(Article)
+      assert_equal 'ummm', a.title      
+    end
+  end
+end

data/test/machine_test.rb

@@ -0,0 +1,269 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class MachineTest < Test::Unit::TestCase
+
+  def setup
+    Machine.machines.clear
+  end
+
+  context "building simple machines" do
+    should "add a machine to the list when defined" do
+      Machine.define :test, :hack => 'ack' do
+      end
+      assert_equal 1, Machine.machines.size
+    end
+
+    should "set proper machine variables when creating" do
+      Machine.define :testo, :class => Article do
+      end
+      assert_not_nil Machine.machines[:testo]
+    end
+  end
+  
+  context "using machines" do
+    should "build an instance of the object" do
+      Machine.define :article do
+      end
+      assert Machine.build(:article).instance_of?(Article)
+    end
+
+    should "build an instance of the provided class" do
+      Machine.define :something, :class => Article do
+      end
+      assert Machine.build(:something).instance_of?(Article)
+    end
+
+    should "set default attributes on the built object" do
+      Machine.define :thing, :class => Article do |article, machine|
+        article.title = 'aha'
+      end
+      assert_equal 'aha', Machine.build(:thing).title
+    end
+
+    should "allow overriding of default attributes" do
+      Machine.define :thing, :class => Article do |article, machine|
+        article.title = 'aha'
+      end
+      assert_equal 'ooooh', Machine.build(:thing, :title => 'ooooh').title    
+    end
+
+    should "only replace the attributes that are passed" do
+      Machine.define :thing, :class => Article do |article, machine|
+        article.title = 'aha'
+        article.rating = 123
+      end
+      assert_equal 123, Machine.build(:thing, :title => 'ooooh').rating
+    end
+
+    should "not save records with build" do
+      Machine.define :thing, :class => Article do |article, machine|
+        article.title = 'aha'
+      end
+      assert Machine.build(:thing).new_record?    
+    end
+
+    should "save records with build!" do
+      Machine.define :thing, :class => Article do |article, machine|
+        article.title = 'aha'
+      end
+      assert !Machine.build!(:thing).new_record?
+    end
+    
+    should "allow redefinition of a machine" do
+      Machine.define :article do |article, machine|
+        article.title = 'aha'
+      end
+
+      Machine.define :article do |article, machine|
+        article.title = 'oho'
+      end
+      assert_equal 'oho', Machine.build(:article).title
+    end
+    
+    should 'raise an exception when using a machine that doesn\'t exist' do
+      assert_raises MachineNotFoundError do
+        Machine.build(:i_can_has_exception)
+      end
+    end
+  end
+  
+  context "with objects that are not active record" do
+    setup do
+      Machine.define :non_model do |nonmodel, machine|
+        nonmodel.name = 'hoo'
+      end      
+    end
+
+    should "build the object correctly" do
+      assert_equal 'hoo', Machine.build(:non_model).name      
+    end
+    
+    should "not freak out when calling build! with non-activerecord objects" do
+      assert_nothing_raised do
+        Machine.build!(:non_model).name
+      end
+    end
+  end
+      
+  context "with associations" do
+    setup do
+      Machine.define :publication do |publication, machine|
+        publication.name = 'booya'
+      end
+      
+      Machine.define :comment do |comment, machine|
+        comment.data = 'dsfsdf'
+      end
+
+      Machine.define :article do |article, machine|
+        article.comments = [machine.comment, machine.comment]
+        article.publication = machine.publication
+      end
+    end
+
+    should "build associated records" do
+      assert_equal 2, Machine.build(:article).comments.size
+      assert Machine.build(:article).comments[0].instance_of?(Comment)
+    end
+    
+    should "allow passing replacement attributes" do
+      Machine.define :article do |article, machine|
+        article.comments = [machine.comment(:data => 'nice article'), machine.comment(:data => 'bad article')]
+      end
+      assert_equal ['nice article', 'bad article'].sort, Machine.build(:article).comments.map { |c| c.data }.sort
+    end
+    
+    should "not save associated objects when using build" do
+      assert Machine.build(:article).comments[0].new_record?
+    end
+    
+    should "save associated objects when using build!" do
+      assert !Machine.build!(:article).comments[0].new_record?
+      assert !Machine.build!(:article).publication.new_record?
+    end
+  end
+  
+  context "extending existing factories" do
+    setup do
+      Machine.define :old_article, :class => Article do |article, machine|
+        article.title = 'old'
+        article.rating = 12
+      end
+      
+      Machine.define :new_article, :class => Article, :extends => :old_article do |article, machine|
+        article.title = 'new'
+        article.author = 'Joe Six Pack'
+      end
+    end
+
+    should "create a new model with the correct attributes" do
+      article = Machine.build(:new_article)
+      assert_equal 'new', article.title
+      assert_equal 12, article.rating
+      assert_equal 'Joe Six Pack', article.author
+    end
+    
+    should "work properly with multiple layers of extensions" do
+      Machine.define :newer_article, :class => Article, :extends => :new_article do |article, machine|
+        article.rating = 13
+      end
+      
+      article = Machine.build(:newer_article)
+      assert_equal 'new', article.title
+      assert_equal 13, article.rating
+      assert_equal 'Joe Six Pack', article.author
+    end
+  end
+  
+  context "loading default paths" do
+    Machine.definition_file_paths.each do |file|
+      should "automatically load definitions from #{file}.rb" do
+        Machine.stubs(:require).raises(LoadError)
+        Machine.expects(:require).with(file)
+        Machine.find_definitions
+      end
+    end
+
+    should "only load the first set of machines detected" do
+      first, second, third = Machine.definition_file_paths
+      Machine.expects(:require).with(first).raises(LoadError)
+      Machine.expects(:require).with(second)
+      Machine.expects(:require).with(third).never
+      Machine.find_definitions
+    end
+  end
+
+  context "using the helper method" do
+    setup do
+      Machine.define :article do |article, machine|
+        article.title = 'aha'
+      end      
+    end
+
+    should "apply machines correctly" do
+      assert Machine(:article).instance_of?(Article)
+    end
+    
+    should "set the attributes" do
+      assert_equal 'aha', Machine(:article).title
+    end
+    
+    should "allow replacement attributes" do
+      assert_equal 'ooh', Machine(:article, :title => 'ooh').title
+    end
+    
+    should "not save the object" do
+      assert Machine(:article).new_record?
+    end
+  end
+  
+  context "applying a machine to an existing object" do
+    setup do
+      Machine.define :article do |article, machine|
+        article.title = 'aha'
+      end
+      @article = Article.new(:title => 'old')
+    end
+
+    should "update the object's attributes" do
+      Machine.apply_to(:article, @article)
+      assert_equal 'aha', @article.title
+    end
+    
+    should "accept replacement attributes" do
+      Machine.apply_to(:article, @article, :title => 'new')
+      assert_equal 'new', @article.title
+    end
+    
+    should "not save the object" do
+      Machine.apply_to(:article, @article)
+      assert @article.new_record?
+    end
+  end
+  
+  context "group definition" do
+    should "yield a Group instance" do
+      thing = nil
+      Machine.define_group :user do |group|
+        thing = group
+      end
+      assert thing.kind_of?(MachineGroup)
+    end
+  end
+  
+  context 'using sequences' do
+    setup do
+      Machine.sequence :title do |n|
+        "title-#{n}"
+      end
+      Machine.define :article do |article, machine|
+        article.title = machine.next(:title)
+      end
+    end
+
+    should 'be able to set values using the sequence' do
+      assert_equal 'title-1', Machine(:article).title
+    end
+  end
+  
+end

data/test/models.rb

@@ -0,0 +1,43 @@
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), 'test.db')
+)
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :publications, :force => true do |t|
+      t.string :name
+    end
+    
+    create_table :articles, :force => true do |t|
+      t.references :publication
+      t.string  :title
+      t.integer :rating
+      t.string :author
+    end
+
+    create_table :comments, :force => true do |t|
+      t.references :article
+      t.string  :data
+    end
+  end
+end
+
+CreateSchema.suppress_messages { CreateSchema.migrate(:up) }
+
+class Publication < ActiveRecord::Base
+  has_many :articles
+end
+
+class Article < ActiveRecord::Base
+  has_many :comments
+  belongs_to :publication
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :article
+end
+
+class NonModel
+  attr_accessor :name
+end

data/test/sequence_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class SequenceTest < Test::Unit::TestCase
+  
+  should 'allow definition of sequences' do
+    Machine.sequence :thing do
+    end
+    assert_equal 1, Machine.sequences.size
+  end
+  
+  should 'increment the sequence value' do
+    Machine.sequence :thing do |n|
+      n
+    end
+    assert_equal 1, Machine.sequences[:thing].next
+    assert_equal 2, Machine.sequences[:thing].next
+  end
+  
+  should 'be able to output strings' do
+    Machine.sequence :thing do |n|
+      "article-#{n}"
+    end
+    assert_equal 'article-1', Machine.sequences[:thing].next
+    assert_equal 'article-2', Machine.sequences[:thing].next
+  end  
+  
+  should 'be callable through the machine' do
+    Machine.sequence :thing do |n|
+      "article-#{n}"
+    end
+    assert_equal 'article-1', Machine.next(:thing)
+  end
+  
+  should 'raise an exception when calling a nonexistent sequence' do
+    assert_raises MachineNotFoundError do
+      Machine.next(:who)
+    end
+  end  
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.join(File.dirname(__FILE__))
+
+require 'test/unit'
+require 'rubygems'
+require 'ruby-debug'
+
+require 'activerecord'
+require 'machine'
+require 'mocha'
+require 'models'
+require 'shoulda'
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: aub-machine
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Aubrey Holland
+- patch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-07 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: machine defines a factory system for creating model objects to replace fixtures in Ruby apps.
+email: aubrey@patch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- lib
+- lib/machine
+- lib/machine/association_helper.rb
+- lib/machine/machine.rb
+- lib/machine/machine_group.rb
+- lib/machine/sequence.rb
+- lib/machine.rb
+- machine-1.0.0.gem
+- machine.gemspec
+- rails
+- rails/init.rb
+- Rakefile
+- README.textile
+- test
+- test/machine_group_test.rb
+- test/machine_test.rb
+- test/models.rb
+- test/sequence_test.rb
+- test/test.db
+- test/test_helper.rb
+- TODO.textile
+has_rdoc: true
+homepage: http://github.com/aub/machine/tree/master
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.textile
+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: Machine crunches factories.
+test_files: 
+- test/machine_test.rb
+- test/machine_group_test.rb
+- test/sequence_test.rb