cranky 0.3.1 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 832320f9e104372957157b3cef6c0d81592a6b66
+  data.tar.gz: 6560e13c455a033fa20f11041c065bf13b95f7ec
+SHA512:
+  metadata.gz: 82347e3df728a862aec73692225e6e0344df1503d0ff117ca4f8bff366f8626e7fbc027d7322c32f73b95d11de6a0bd0bbe1c895a1116141e5fbb5c45238e62f
+  data.tar.gz: a5c223a0a63ad0231fb342c5f20fcd17fbdd438431a05f78fff8fa25fbc00b163f8b1bb6bea24166e36070bab98d7ca3f88812987de034d944aa49f3a251f9e8

data/Gemfile

@@ -3,11 +3,10 @@ source "http://gemcutter.org"
 group :development do
   gem "rake"
   gem "gemcutter"
-  gem "ruby-debug19", :require => 'ruby-debug'
 end
 
 group :test do
   gem "rspec"
-  gem "rcov"
+  gem "simplecov", require: false
 end
 

data/Gemfile.lock

@@ -1,14 +1,11 @@
 GEM
   remote: http://gemcutter.org/
   specs:
-    archive-tar-minitar (0.5.2)
-    columnize (0.3.4)
     diff-lcs (1.1.2)
+    docile (1.1.5)
     gemcutter (0.7.0)
-    linecache19 (0.5.12)
-      ruby_core_source (>= 0.1.4)
+    json (1.8.3)
     rake (0.9.2)
-    rcov (0.9.9)
     rspec (2.6.0)
       rspec-core (~> 2.6.0)
       rspec-expectations (~> 2.6.0)
@@ -17,16 +14,11 @@ GEM
     rspec-expectations (2.6.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.6.0)
-    ruby-debug-base19 (0.11.25)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby_core_source (>= 0.1.4)
-    ruby-debug19 (0.11.6)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby-debug-base19 (>= 0.11.19)
-    ruby_core_source (0.1.5)
-      archive-tar-minitar (>= 0.5.2)
+    simplecov (0.11.2)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
 
 PLATFORMS
   ruby
@@ -34,6 +26,8 @@ PLATFORMS
 DEPENDENCIES
   gemcutter
   rake
-  rcov
   rspec
-  ruby-debug19
+  simplecov
+
+BUNDLED WITH
+   1.12.2

data/README.md

@@ -0,0 +1,326 @@
+# Cranky
+
+Cranky is a fixtures replacement inspired by the excellent Factory Girl but with easier syntax and no external
+dependencies, it will work straight out of the box with rails 10.
+
+In short use this if you want to quickly and naturally create factory methods that you feel 100% in control of.
+
+## Install
+
+First install the gem...
+
+~~~
+gem install cranky
+~~~
+
+Or with bundler...
+
+~~~ruby
+# Gemfile
+gem "cranky"
+~~~
+
+Then in your spec_helper.rb ...
+
+~~~ruby
+# spec_helper.rb
+require "cranky"
+require "factories/my_factories"
+~~~
+
+The above assumes that you have created your factory methods in a file called my_factories.rb in the spec/factories directory.
+You can create as many different factory files as you want, just require them in the same way.
+
+## In a Nutshell
+
+The API to use in your tests is:
+
+~~~ruby
+crank(:user)                  # Build a user instance without saving
+crank!(:user)                 # Build and save a user instance
+crank(:user, :name => "Ian")  # Override a default attribute value
+crank(:user_attrs)            # Return a set of valid attributes rather than the object
+~~~
+
+Alternatively the Factory Girl syntax also works and therefore Cranky can drop into tests already written for that framework...
+
+~~~ruby
+Factory.build(:user)                  # Build a user instance without saving
+Factory.create(:user)                 # Build and save a user instance
+Factory.build(:user, :name => "Ian")  # Override a default attribute value
+Factory.attributes_for(:user)         # Return a set of valid attributes rather than the object
+~~~
+
+Or if you're coming from Machinist, you can make your Cranky factories drop into your existing tests by setting up make and make! methods as [shown here](http://gist.github.com/525653).
+
+Cranky has a nice debug option (rails only) to warn you when your factory is broken, recommend you do this for your first spec...
+
+~~~ruby
+describe User do
+  it "should have a working factory" do
+    # This will raise an error and report the validation errors should they occur
+    Factory.debug(:user).should be_valid
+  end
+end
+~~~
+
+Cranky allows you to build factories via std Ruby methods, like this...
+
+~~~ruby
+# factories/my_factories.rb
+class Cranky::Factory     # Your factory must reopen Cranky::Factory
+
+  # Simple factory method to create a user instance, you would call this via Factory.build(:user)
+  def user
+    # Define attributes via a hash, generate the values any way you want
+    define :name    => "Jimmy",               
+           :email   => "jimmy#{n}@home.com",   # An 'n' counter method is available to help make things unique
+           :role    => "pleb",
+           :address => default_address         # Call your own helper methods to wire up your associations
+  end
+
+  # Easily create variations via the inherit helper, callable via Factory.build(:admin)
+  def admin
+    inherit(:user, :role => "admin")
+  end
+
+  # Return a default address if it already exists, or call the address factory to make one
+  def default_address
+    @default_address ||= create(:address) 
+  end
+  
+  # Alternatively loose the DSL altogether and define the factory yourself, still callable via Factory.build(:address)
+  def address
+    a = Address.new
+    a.street = "192 Broadway"
+    a.city = options[:city] || "New York"   # You can get any caller overrides via the options hash
+    a                                       # Only rule is the method must return the generated object 
+  end
+
+end
+~~~
+
+# Details
+
+## Define Your Factories
+
+This is where Cranky really shines, if you can create Ruby methods you can pretty much create your factories without having to refer to the syntax documentation ever again.
+
+The only rules are:
+
+1. Your factory must reopen the Cranky::Factory class
+2. Your factory method must return the object you wanted to create
+3. You can access the overrides passed in via options[:key]. (not really a rule!) 
+
+So for example to create a simple user factory...
+
+~~~ruby
+# factories/my_factories.rb
+class Cranky::Factory
+
+  # Simple factory method to create a user instance, you would call this via Factory.build(:user)
+  def user
+    u       = User.new
+    u.name  = options[:name] || "Jimmy"                 # Use the passed in name if present, or the default
+    u.email = options[:email] || "jimmy#{n}@home.com"   # Give each user a unique email address
+    u.role  = options[:role] || "pleb"
+    u
+  end
+
+end
+~~~
+
+Now of course you are working in straight Ruby here, so you can extend this any way you want as long as you follow the above rules. 
+
+For example here it is with the capability to automatically create a default address association...
+
+~~~ruby
+# factories/my_factories.rb
+class Cranky::Factory
+
+  # Return the default address if it already exists, or call the address factory to make one
+  def default_address
+    @default_address ||= create(:address) 
+  end
+
+  def user
+    u         = User.new
+    u.name    = options[:name] || "Jimmy"
+    u.email   = options[:email] || "jimmy#{n}@home.com"
+    u.role    = options[:role] || "pleb"
+    u.address = default_address
+    u
+  end
+
+  # Create the address factory in the same way
+
+end
+~~~
+
+Quite often the database will be cleared between tests but the instance variable in the factory will not necessarily be reset which could lead to problems if the tests check for the associated record in the database.
+So a nice tip is to implement default associations like this (assuming you're using Rails)...
+
+~~~ruby
+# Return the default address if it already exists, or call the address factory to make one
+def default_address
+  # If the default address exists, but has been cleared from the database...
+  @default_address = nil if @default_address && !Address.exists?(@default_address.id)
+  @default_address ||= create(:address) 
+end
+~~~
+
+You can pass additional arguments to your factories via the overrides hash...
+
+~~~ruby
+Factory.build(:user, :new_address => true)
+
+def user
+  u         = User.new
+  u.name    = options[:name] || "Jimmy"
+  u.email   = options[:email] || "jimmy#{n}@home.com"
+  u.role    = options[:role] || "pleb"
+  u.address = options[:new_address] ? create(:address) : default_address
+  u
+end
+~~~
+
+You can use traits...
+
+~~~ruby
+Factory.build(:user, traits: [:admin, :manager])
+
+def user
+  u         = User.new
+  u.name    = options[:name] || "Jimmy"
+  u.email   = options[:email] || "jimmy#{n}@home.com"
+  u.role    = options[:role] || "pleb"
+  u.address = options[:new_address] ? create(:address) : default_address
+  u
+end
+
+def apply_trait_admin_to_user(user)
+  user.roles << :admin
+end
+
+def apply_trait_manager_to_user(user)
+  user.roles << :manager
+end
+~~~
+
+## Helpers
+
+Of course its nice to get some help...
+
+### Define
+
+Most of your factories are likely to simply define a list of mimimum attribute values, use the define helper for this. 
+
+~~~ruby
+# The user factory re-written using the define helper
+def user
+  define :name    => "Jimmy",
+         :email   => "jimmy#{n}@home.com",
+         :role    => "pleb",
+         :address => default_address
+end
+~~~
+
+Note that you don't have to worry about handling the overrides here, they will be applied automatically if present, just define the defaults.
+
+The define argument is just a regular hash, you have complete freedom to choose how to generate the values to be passed into it.
+
+If you like you can generate attributes with a block:
+
+~~~ruby
+def user
+  define :name    => "Jimmy",
+         :email   => lambda{|u| "#{u.name.downcase}@home.com"},
+         :role    => "pleb",
+         :address => default_address
+end
+~~~
+
+The define method will return the object, you can grab this for additional manipulation as you would expect...
+
+~~~ruby
+def user
+  u = define :name    => "Jimmy",
+             :email   => "jimmy#{n}@home.com",
+             :role    => "pleb",
+             :address => default_address
+  u.do_something
+  u               # Remember to return it at the end
+end
+~~~
+
+If for any reason you want to have your factory method named differently from the model it instantiates you can pass in a :class attribute to the define method...
+
+~~~ruby
+# Called via Factory.create(:jimmy)
+def jimmy
+  u = define :class   => :user, 
+             :name    => "Jimmy",
+             :email   => "jimmy#{n}@home.com",
+             :role    => "pleb",
+             :address => default_address
+end
+~~~
+
+### Inherit
+
+You can inherit from other factories via the inherit method. So for example to create an admin user you might do...
+
+~~~ruby
+# Called via Factory.create(:admin)
+def admin
+  inherit(:user, :role => "admin")  # Pass in any attribute overrides you want
+end
+~~~
+
+### Unique Attributes (n)
+
+If you want to generate unique attributes you can call the n method which will automatically increment the next time it is called.
+
+Note that every time n is called it will increment, it does not implement a unique counter per attribute.
+
+### Reset
+
+Clear all instance variables in the factory. This may be useful to run between tests depending on your factory logic...
+
+~~~ruby
+before(:each) do
+  Factory.reset
+end
+~~~
+
+### Debug
+
+Sometimes it is useful to be warned that your factory is generating invalid instances (although quite often your tests may intentionally generate invalid instances, so use this with care). By turning on debug the Factory will raise an error if the generated instance is invalid...
+
+~~~ruby
+Factory.debug(:user)   # A replacement for Factory.build, with validation warnings enabled
+Factory.debug!(:user)  # Likewise for Factory.create
+~~~
+
+Note that this relies on the instance having a valid? method, so in practice this may only work with Rails.
+
+### Attributes For
+
+Returns the attributes that would be applied by a given factory method...
+
+~~~ruby
+valid_attributes = Factory.attributes_for(:user)
+~~~
+
+Requires that the instance has an attributes method, so again may only work under Rails.
+
+## Additional Features
+
+Want any? Feel free to let me know.
+
+## Thanks
+
+Cranky was inspired by [factory_girl](http://github.com/thoughtbot/factory_girl) and [miniskirt](http://gist.github.com/273579).
+
+Thanks to both.
+

data/Rakefile

@@ -0,0 +1,36 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'cranky'
+require 'rubygems'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = ("spec/**/*_spec.rb")
+end
+
+task :default => :spec
+
+task :release_tag do
+  system "git commit -a -m 'Release #{Cranky::VERSION}'"
+  system "git tag -a v#{Cranky::VERSION} -m 'version #{Cranky::VERSION}'"
+end
+
+# Push to github
+desc "Push to Github"
+task :push do
+ system "git push --tags origin master"
+end
+
+desc "Build the gem"
+task :build do
+  system "bundle exec gem build cranky.gemspec"
+end
+ 
+desc "Release version #{Cranky::VERSION}"
+task :release => [:build, :release_tag, :push] do
+  system "bundle exec gem push cranky-#{Cranky::VERSION}.gem"
+end
+
+

data/lib/cranky/factory.rb

@@ -58,6 +58,16 @@ module Cranky
 
     private
 
+      def apply_traits(what, item)
+        Array(options[:traits]).each do |t|
+          trait_method_name = "apply_trait_#{t}_to_#{what}"
+          fail("Invalid trait '#{t}'! No method '#{trait_method_name}' is defined.") unless respond_to?(trait_method_name)
+          send(trait_method_name, item)
+        end
+
+        item
+      end
+
       def n
         @n += 1
       end
@@ -71,6 +81,7 @@ module Cranky
         item = "TBD"
         new_job(what, overrides) do
           item = self.send(what)        # Invoke the factory method
+          item = apply_traits(what, item)
         end
         item
       end

data/lib/cranky/version.rb

@@ -1,3 +1,3 @@
 module Cranky
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/spec/cranky_spec.rb

@@ -127,6 +127,15 @@ describe "The Cranky factory" do
     Factory.build(:user_hash, :role => :admin)[:role].should == :admin
   end
 
+  it "is capable of using traits" do
+    user = Factory.build(:user_manually, :traits => :manager)
+    user.role.should == :manager
+  end
+
+  it "raises exception if trait method is undefined" do
+    lambda { Factory.build(:user_by_define, :traits => :manager) }.should raise_error("Invalid trait 'manager'! No method 'apply_trait_manager_to_user_by_define' is defined.")
+  end
+
   specify "attributes are not assigned when they have the value :skip" do
     crank(:user, :name => :skip).name.should_not be
   end

data/spec/spec_helper.rb

@@ -1,7 +1,11 @@
-require 'rubygems'
-require 'rspec'
+require 'simplecov'
+SimpleCov.start
+
 require 'cranky'
 
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+end
 
 class TestClass
   attr_accessor :valid
@@ -91,7 +95,8 @@ class Cranky::Factory
            :name => "Fred",
            :role => :user
   end
-end
-
-
 
+  def apply_trait_manager_to_user_manually(user)
+    user.role = :manager
+  end
+end

metadata

@@ -1,78 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: cranky
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 1
-  version: 0.3.1
+version: !ruby/object:Gem::Version
+  version: 0.4.0
 platform: ruby
-authors: 
+authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-22 00:00:00 +01:00
-default_executable: 
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies: []
-
-description: A very light yet powerful test factory framework with an extremely clean syntax that makes it very easy to define your factories.
-email: ginty@hyperdecade.com
+description: A very light yet powerful test factory framework with an extremely clean
+  syntax that makes it very easy to define your factories.
+email: stephen.f.mcginty@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/cranky/factory.rb
-- lib/cranky/version.rb
-- lib/cranky/job.rb
-- lib/cranky.rb
-- spec/spec_helper.rb
-- spec/cranky_spec.rb
+files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
-- README.rdoc
 - LICENSE
+- README.md
+- Rakefile
 - init.rb
-has_rdoc: true
+- lib/cranky.rb
+- lib/cranky/factory.rb
+- lib/cranky/job.rb
+- lib/cranky/version.rb
+- spec/cranky_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/ginty/cranky
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -570131409
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 3
-      - 4
+    - !ruby/object:Gem::Version
       version: 1.3.4
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A very light yet powerful test factory framework.
 test_files: []
-

data/README.rdoc

@@ -1,265 +0,0 @@
-= Cranky
-
-Cranky is a fixtures replacement inspired by the excellent Factory Girl but with easier syntax and no external
-dependencies, it will work straight out of the box with rails 10.
-
-In short use this if you want to quickly and naturally create factory methods that you feel 100% in control of.
-
-== Install
-
-First install the gem...
-
-  gem install cranky
-
-Or with bundler...
-
-  # Gemfile
-  gem "cranky"
-
-Then in your spec_helper.rb ...
-
-  # spec_helper.rb
-  require "cranky"
-  require "factories/my_factories"
-
-The above assumes that you have created your factory methods in a file called my_factories.rb in the spec/factories directory.
-You can create as many different factory files as you want, just require them in the same way.
-
-== In a Nutshell
-
-The API to use in your tests is:
-
-  crank(:user)                  # Build a user instance without saving
-  crank!(:user)                 # Build and save a user instance
-  crank(:user, :name => "Ian")  # Override a default attribute value
-  crank(:user_attrs)            # Return a set of valid attributes rather than the object
-
-Alternatively the Factory Girl syntax also works and therefore Cranky can drop into tests already written for that framework...
-
-  Factory.build(:user)                  # Build a user instance without saving
-  Factory.create(:user)                 # Build and save a user instance
-  Factory.build(:user, :name => "Ian")  # Override a default attribute value
-  Factory.attributes_for(:user)         # Return a set of valid attributes rather than the object
-
-Or if you're coming from Machinist, you can make your Cranky factories drop into your existing tests by setting up make and make! methods as shown here.[http://gist.github.com/525653]
-
-Cranky has a nice debug option (rails only) to warn you when your factory is broken, recommend you do this for your first spec...
-
-  describe User do
-    it "should have a working factory" do
-      # This will raise an error and report the validation errors should they occur
-      Factory.debug(:user).should be_valid
-    end
-  end
-
-Cranky allows you to build factories via std Ruby methods, like this...
-
-  # factories/my_factories.rb
-  class Cranky::Factory     # Your factory must reopen Cranky::Factory
-
-    # Simple factory method to create a user instance, you would call this via Factory.build(:user)
-    def user
-      # Define attributes via a hash, generate the values any way you want
-      define :name    => "Jimmy",               
-             :email   => "jimmy#{n}@home.com",   # An 'n' counter method is available to help make things unique
-             :role    => "pleb",
-             :address => default_address         # Call your own helper methods to wire up your associations
-    end
-
-    # Easily create variations via the inherit helper, callable via Factory.build(:admin)
-    def admin
-      inherit(:user, :role => "admin")
-    end
-
-    # Return a default address if it already exists, or call the address factory to make one
-    def default_address
-      @default_address ||= create(:address) 
-    end
-
-    # Alternatively loose the DSL altogether and define the factory yourself, still callable via Factory.build(:address)
-    def address
-      a = Address.new
-      a.street = "192 Broadway"
-      a.city = options[:city] || "New York"   # You can get any caller overrides via the options hash
-      a                                       # Only rule is the method must return the generated object 
-    end
-
-  end
-
-= Details
-
-== Define Your Factories
-
-This is where Cranky really shines, if you can create Ruby methods you can pretty much create your factories without having to refer to the syntax documentation ever again.
-
-The only rules are:
-
-1. Your factory must reopen the Cranky::Factory class
-2. Your factory method must return the object you wanted to create
-3. You can access the overrides passed in via options[:key]  (not really a rule!) 
-
-So for example to create a simple user factory...
-
-  # factories/my_factories.rb
-  class Cranky::Factory
-
-    # Simple factory method to create a user instance, you would call this via Factory.build(:user)
-    def user
-      u       = User.new
-      u.name  = options[:name] || "Jimmy"                 # Use the passed in name if present, or the default
-      u.email = options[:email] || "jimmy#{n}@home.com"   # Give each user a unique email address
-      u.role  = options[:role] || "pleb"
-      u
-    end
-
-  end
-
-Now of course you are working in straight Ruby here, so you can extend this any way you want as long as you follow the above rules. 
-
-For example here it is with the capability to automatically create a default address association...
-
-  # factories/my_factories.rb
-  class Cranky::Factory
-
-    # Return the default address if it already exists, or call the address factory to make one
-    def default_address
-      @default_address ||= create(:address) 
-    end
-
-    def user
-      u         = User.new
-      u.name    = options[:name] || "Jimmy"
-      u.email   = options[:email] || "jimmy#{n}@home.com"
-      u.role    = options[:role] || "pleb"
-      u.address = default_address
-      u
-    end
-
-    ... # Create the address factory in the same way
-
-  end
-
-Quite often the database will be cleared between tests but the instance variable in the factory will not necessarily be reset which could lead to problems if the tests check for the associated record in the database.
-So a nice tip is to implement default associations like this (assuming you're using Rails)...
-
-  # Return the default address if it already exists, or call the address factory to make one
-  def default_address
-    # If the default address exists, but has been cleared from the database...
-    @default_address = nil if @default_address && !Address.exists?(@default_address.id)
-    @default_address ||= create(:address) 
-  end
-
-You can pass additional arguments to your factories via the overrides hash...
-
-  Factory.build(:user, :new_address => true)
-
-  def user
-    u         = User.new
-    u.name    = options[:name] || "Jimmy"
-    u.email   = options[:email] || "jimmy#{n}@home.com"
-    u.role    = options[:role] || "pleb"
-    u.address = options[:new_address] ? create(:address) : default_address
-    u
-  end
-
-== Helpers
-
-Of course its nice to get some help...
-
-=== Define
-
-Most of your factories are likely to simply define a list of mimimum attribute values, use the define helper for this. 
-
-  # The user factory re-written using the define helper
-  def user
-    define :name    => "Jimmy",
-           :email   => "jimmy#{n}@home.com",
-           :role    => "pleb",
-           :address => default_address
-  end
-
-Note that you don't have to worry about handling the overrides here, they will be applied automatically if present, just define the defaults.
-
-The define argument is just a regular hash, you have complete freedom to choose how to generate the values to be passed into it.
-
-If you like you can generate attributes with a block:
-
-  def user
-    define :name    => "Jimmy",
-           :email   => lambda{|u| "#{u.name.downcase}@home.com"},
-           :role    => "pleb",
-           :address => default_address
-  end
-
-The define method will return the object, you can grab this for additional manipulation as you would expect...
-
-  def user
-    u = define :name    => "Jimmy",
-               :email   => "jimmy#{n}@home.com",
-               :role    => "pleb",
-               :address => default_address
-    u.do_something
-    u               # Remember to return it at the end
-  end
-
-If for any reason you want to have your factory method named differently from the model it instantiates you can pass in a :class attribute to the define method...
-
-  # Called via Factory.create(:jimmy)
-  def jimmy
-    u = define :class   => :user, 
-               :name    => "Jimmy",
-               :email   => "jimmy#{n}@home.com",
-               :role    => "pleb",
-               :address => default_address
-  end
-
-=== Inherit
-
-You can inherit from other factories via the inherit method. So for example to create an admin user you might do...
-
-  # Called via Factory.create(:admin)
-  def admin
-    inherit(:user, :role => "admin")  # Pass in any attribute overrides you want
-  end
-
-=== Unique Attributes (n)
-
-If you want to generate unique attributes you can call the n method which will automatically increment the next time it is called.
-
-Note that every time n is called it will increment, it does not implement a unique counter per attribute.
-
-=== Reset
-
-Clear all instance variables in the factory. This may be useful to run between tests depending on your factory logic...
-
-  before(:each) do
-    Factory.reset
-  end
-
-=== Debug
-
-Sometimes it is useful to be warned that your factory is generating invalid instances (although quite often your tests may intentionally generate invalid instances, so use this with care). By turning on debug the Factory will raise an error if the generated instance is invalid...
-
-  Factory.debug(:user)   # A replacement for Factory.build, with validation warnings enabled
-  Factory.debug!(:user)  # Likewise for Factory.create
-
-Note that this relies on the instance having a valid? method, so in practice this may only work with Rails.
-
-=== Attributes For
-
-Returns the attributes that would be applied by a given factory method...
-
-  valid_attributes = Factory.attributes_for(:user)
-
-Requires that the instance has an attributes method, so again may only work under Rails.
-
-== Additional Features
-
-Want any? Feel free to let me know.
-
-== Thanks
-
-Cranky was inspired by factory_girl[http://github.com/thoughtbot/factory_girl] and miniskirt[http://gist.github.com/273579].
-
-Thanks to both.
-