factory_girl_extensions 0.4.0 → 2.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.markdown

@@ -0,0 +1,115 @@
+# FactoryGirl extensions
+
+factory_girl_extensions is a simple set of syntax extensions that I typically like to use on projects when using factory_girl.
+
+## Install
+
+    gem install factory_girl_extensions
+
+## FactoryGirl extensions 2.0
+
+As of version 2.0, factory_girl_extensions now targets the new FactoryGirl 2.0 API.
+
+ - Only FactoryGirl 2.0+ is supported now.  If you are using an older version of FactoryGirl, please use factory_girl_extensions < 2.0
+ - You can no longer use `:email.next` to generate the next :email sequence.  factory_girl_extensions no longer includes custom sequence code (because this feature wasn't heavily used and the new FactoryGirl inline sequences are pretty awesome)
+ - The code has been updated to be Ruby 1.8/1.9 compatible and now follows the same patterns as other official FactoryGirl alternative syntaxes
+
+## Usage
+
+```ruby
+require 'factory_girl_extensions'
+
+FactoryGirl.define do
+  factory :user do
+    name 'Bob Smith'
+  end
+end
+
+# Creates a saved instance without raising (same as saving the result of FactoryGirl.build)
+User.generate(:name => 'Johnny')
+
+# Creates a saved instance and raises when invalid (same as FactoryGirl.create)
+User.generate!
+
+# Creates an unsaved instance (same as FactoryGirl.build)
+User.build
+
+# Creates an instance and yields it to the passed block
+User.generate do |user|
+  # ...do something with user...
+end
+
+# Creates and returns a Hash of attributes from this factory (same as FactoryGirl.attributes_for).
+User.attributes
+
+# A few short aliases are included for convenience.
+User.gen
+User.gen!
+User.attrs
+
+# Factories with custom prefix/suffixes are also supported.
+FactoryGirl.define do
+  factory :admin_user, :parent => :user do
+    is_admin true
+  end
+
+  factory :user_with_profile, :parent => :user do
+    profile_complete true
+  end
+
+  factory :admin_user_with_profile, :parent => :admin_user do
+    profile_complete true
+  end
+end
+
+# Generates the :admin_user factory
+User.generate(:admin)
+User.generate(:admin, :name => 'Cool Admin')
+
+# Generates the :user_with_profile factory
+User.generate(:with_profile)
+
+# Generates the :admin_user_with_profile factory
+User.generate(:admin, :with_profile)
+User.generate(:admin, :with_profile, :name => 'Custom name')
+
+# User.build and User.attributes also support these custom prefix/suffixes.
+```
+
+## Why User.gen instead of FactoryGirl(:user)?
+
+Personally, I really dislike the `FactoryGirl(:user)` syntax.  When you have a lot of 
+factories, it's hard to see the names of the actual model classes.  I don't like this:
+
+```ruby
+FactoryGirl(:user).should be_valid
+FactoryGirl(:name, :string => 'something').should be_awesome
+FactoryGirl(:comment, :user => Factory(:user)).should be_cool
+FactoryGirl(:user).should do_some_stuff_with(:things)
+```
+
+To me, the thing that draws my attention in that code snippet is `FactoryGirl`. 
+I don't care about `Factory`, I care about the actual models!  I prefer:
+
+```ruby
+User.gen.should be_valid
+Name.gen(:string => 'something').should be_awesome
+Comment.gen(:user => User.gen).should be_cool
+User.gen.should do_some_stuff_with(:things)
+```
+
+When you syntax highlight the above code, the constants (model names) are usually 
+the things that really jump out at you.  Even in plain text, it's easier to 
+understand that code than the above `FactoryGirl(:code)` in my opinion.
+
+## Dude, why isn't this stuff included in the official FactoryGirl gem as an alternative syntax?
+
+Originally, when I made this, not many people were using this syntax.
+
+Now that I know many people using this syntax, I may send a pull request to FactoryGirl to see if they would consider accepting this.
+
+As of factory_girl_extensions 2.0, the code is actually written in the same style as official syntaxes, so it should be very easy to include this into the official FactoryGirl gem.
+
+## License
+
+factory_girl_extensions is released under the MIT license.

data/Rakefile

@@ -0,0 +1,10 @@
+require "rspec/core/rake_task"
+
+desc 'Default: run specs'
+task :default => :spec
+
+desc 'Run tests'
+task :test => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new

data/factory_girl_extensions.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/factory_girl_extensions/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "factory_girl_extensions"
+  gem.author      = "remi"
+  gem.email       = "remi@remitaylor.com"
+  gem.homepage    = "http://github.com/remi/factory_girl_extensions"
+  gem.summary     = "Alternative FactoryGirl API"
+
+  gem.description = <<-desc.gsub(/^\s+/, '')
+    Alternative FactoryGirl API allowing you to build/generate factories 
+    using your class constants, eg. User.gen instead of Factory(:user).
+  desc
+
+  files = `git ls-files`.split("\n")
+  gem.files         = files
+  gem.executables   = files.grep(%r{^bin/.*}).map {|f| File.basename(f) }
+  gem.test_files    = files.grep(%r{^spec/.*})
+  gem.require_paths = ["lib"]
+  gem.version       = FactoryGirlExtensions::VERSION
+
+  gem.add_dependency "factory_girl", ">= 2.0"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/lib/factory_girl_extensions/core.rb

@@ -0,0 +1,151 @@
+require "factory_girl_extensions/version"
+
+module FactoryGirl
+  module Syntax
+
+    # Extends any object to provide generation methods for factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl_extensions'
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       name 'Bob Smith'
+    #     end
+    #   end
+    #   
+    #   # Creates a saved instance without raising (same as saving the result of FactoryGirl.build)
+    #   User.generate(:name => 'Johnny')
+    #   
+    #   # Creates a saved instance and raises when invalid (same as FactoryGirl.create)
+    #   User.generate!
+    #   
+    #   # Creates an unsaved instance (same as FactoryGirl.build)
+    #   User.build
+    #   
+    #   # Creates an instance and yields it to the passed block
+    #   User.generate do |user|
+    #     # ...do something with user...
+    #   end
+    #
+    #   # Creates and returns a Hash of attributes from this factory (same as FactoryGirl.attributes_for).
+    #   User.attributes
+    #
+    #   # A few short aliases are included for convenience.
+    #   User.gen
+    #   User.gen!
+    #   User.attrs
+    #
+    #   # Factories with custom prefix/suffixes are also supported.
+    #   FactoryGirl.define do
+    #     factory :admin_user, :parent => :user do
+    #       is_admin true
+    #     end
+    #
+    #     factory :user_with_profile, :parent => :user do
+    #       profile_complete true
+    #     end
+    #
+    #     factory :admin_user_with_profile, :parent => :admin_user do
+    #       profile_complete true
+    #     end
+    #   end
+    #
+    #   # Generates the :admin_user factory
+    #   User.generate(:admin)
+    #   User.generate(:admin, :name => 'Cool Admin')
+    #
+    #   # Generates the :user_with_profile factory
+    #   User.generate(:with_profile)
+    #
+    #   # Generates the :admin_user_with_profile factory
+    #   User.generate(:admin, :with_profile)
+    #   User.generate(:admin, :with_profile, :name => 'Custom name')
+    #
+    #   # User.build and User.attributes also support these custom prefix/suffixes.
+    #   
+    # This syntax was derived from remi Taylor's factory_girl_extensions.
+    module ObjectMethods
+      
+      # Creates an unsaved instance (same as FactoryGirl.build)
+      def build(*args, &block)
+        factory, overrides = ObjectMethods.factory_and_overrides(name.underscore, args)
+        instance = factory.run(Strategy::Build, overrides, &block)
+        instance
+      end
+      
+      # Creates a saved instance without raising (same as saving the result of FactoryGirl.build)
+      def generate(*args, &block)
+        instance = build(*args)
+        instance.save
+        yield instance if block_given?
+        instance
+      end
+
+      # Creates a saved instance and raises when invalid (same as FactoryGirl.create)
+      def generate!(*args, &block)
+        factory, overrides = ObjectMethods.factory_and_overrides(name.underscore, args)
+        instance = factory.run(Strategy::Create, overrides, &block)
+        instance
+      end
+
+      # Creates and returns a Hash of attributes from this factory (same as FactoryGirl.attributes_for)
+      def attributes(*args, &block)
+        factory, overrides = ObjectMethods.factory_and_overrides(name.underscore, args)
+        attrs = factory.run(Strategy::AttributesFor, overrides, &block)
+        attrs
+      end
+
+      alias attrs attributes
+      alias gen   generate
+      alias gen!  generate!
+
+      # @private
+      #
+      # Helper to get the Factory object and overrides hash from the arguments passed to any ObjectMethods.
+      def self.factory_and_overrides(base_name, args)
+        overrides = args.last.is_a?(Hash) ? args.pop : {}
+        factory   = find_factory(base_name, args)
+        raise ArgumentError.new("Could not find factory for #{base_name.inspect} with #{args.inspect}") unless factory
+        [factory, overrides]
+      end
+
+      # @private
+      #
+      # Given the base_name for a class's factory and 0-2 parts (prefix/suffixes), 
+      # this finds the first matching factory that FactoryGirl has in its registry.
+      def self.find_factory(base_name, parts)
+        case parts.length
+        when 0
+          detect_factory base_name
+        when 1
+          detect_factory "#{parts.first}_#{base_name}", "#{base_name}_#{parts.first}"
+        when 2
+          detect_factory "#{parts.first}_#{base_name}_#{parts.last}", "#{parts.last}_#{base_name}_#{parts.first}"
+        else
+          raise ArgumentError.new("Don't know how to find factory for #{base_name.inspect} with #{parts.inspect}")
+        end
+      end
+
+      # @private
+      #
+      # Given any number of arguments representing the possible names for a factory that you 
+      # want to find, this iterates over the given names and returns the first FactoryGirl 
+      # factory object that FactoryGirl returns (skipping unregistered factory names).
+      def self.detect_factory(*possible_factory_names)
+        factory = nil
+        possible_factory_names.each do |factory_name|
+          begin
+            factory = FactoryGirl.factory_by_name(factory_name)
+            break
+          rescue ArgumentError => e
+            raise e unless e.message =~ /Factory not registered/
+            next
+          end
+        end
+        factory
+      end
+    end
+  end
+end

data/lib/factory_girl_extensions/version.rb

@@ -0,0 +1,8 @@
+module FactoryGirlExtensions
+  begin
+    old, $VERBOSE = $VERBOSE, nil
+    VERSION = "2.0.0"
+  ensure
+    $VERBOSE = old
+  end
+end

data/lib/factory_girl_extensions.rb

@@ -1,5 +1,3 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
+require "factory_girl_extensions/core"
 
-require 'factory_girl_extensions/module'
-
-Object.send :include, FactoryGirlExtensions
+Object.send :extend, FactoryGirl::Syntax::ObjectMethods

data/spec/factory_girl_extensions_spec.rb

@@ -0,0 +1,232 @@
+# If you require "factory_girl_extensions", it automatically extends Object with these extensions.
+#
+# If you require "factory_girl_extensions/core", it doesn't automatically include extensions anywhere 
+# so you can choose which classes/objects you want to extend to get the gen/build/etc methods.
+require "factory_girl_extensions/core"
+
+# Required after factory_girl_extensions to ensure that factory_girl_extensions doesn't 
+# blow up if factory_girl hasn't been required yet.
+require "factory_girl"
+
+require "rspec"
+
+# Example class
+class Dog
+  extend FactoryGirl::Syntax::ObjectMethods
+
+  attr_accessor :name, :saved
+
+  def save
+    self.saved = true
+  end
+
+  def saved?
+    saved == true
+  end
+
+  def save!
+    raise "Called save!" unless name == "Valid Name"
+    self.saved = true
+  end
+end
+
+# Example factories
+FactoryGirl.define do
+  factory :dog do
+    name "Rover"
+  end
+
+  factory :awesome_dog, :class => Dog do
+    name "Awesome Dog"
+  end
+
+  factory :dog_with_toys, :class => Dog do
+    name "Dog with toys"
+  end
+
+  factory :awesome_dog_with_toys, :class => Dog do
+    name "Awesome Dog with toys"
+  end
+end
+
+describe Dog do
+  it "should act as expected" do
+    dog = Dog.new
+    dog.name.should be_nil
+
+    dog.name = "Rover"
+    dog.name.should == "Rover"
+
+    dog.saved?.should == false
+    dog.save
+    dog.saved?.should == true
+
+    dog.saved = false
+    expect { dog.save! }.to raise_error(RuntimeError, /Called save!/)
+    dog.saved?.should == false
+
+    dog.name = "Valid Name" # this let's you call save!
+    dog.save!
+    dog.saved?.should == true
+  end
+end
+
+describe FactoryGirl::Syntax::ObjectMethods do
+
+  it "raises useful Exception when no matching factory can be found" do
+    expect { Dog.build(:foo, :bar)      }.to raise_error(ArgumentError, %{Could not find factory for "dog" with [:foo, :bar]})
+    expect { Dog.generate(:foo, :bar)   }.to raise_error(ArgumentError, %{Could not find factory for "dog" with [:foo, :bar]})
+    expect { Dog.attributes(:foo, :bar) }.to raise_error(ArgumentError, %{Could not find factory for "dog" with [:foo, :bar]})
+  end
+
+  describe "#build" do
+    after do
+      @dog.should_not be_saved if @dog
+    end
+
+    it "without arguments" do
+      @dog = Dog.build
+      @dog.name.should == "Rover"
+    end
+
+    it "with overrides" do
+      @dog = Dog.build(:name => "Spot")
+      @dog.name.should == "Spot"
+    end
+
+    it "yields the built instance to block" do
+      @dog = Dog.build(:name => "Spot"){|d| d.name += " Remover" }
+      @dog.name.should == "Spot Remover"
+    end
+
+    it "with prefix" do
+      @dog = Dog.build(:awesome)
+      @dog.name.should == "Awesome Dog"
+    end
+
+    it "with suffix" do
+      @dog = Dog.build(:with_toys)
+      @dog.name.should == "Dog with toys"
+    end
+
+    it "with prefix and suffix" do
+      @dog = Dog.build(:awesome, :with_toys)
+      @dog.name.should == "Awesome Dog with toys"
+    end
+
+    it "with prefix and suffix (reversed works too)" do
+      @dog = Dog.build(:with_toys, :awesome)
+      @dog.name.should == "Awesome Dog with toys"
+    end
+
+    it "cannot pass more than 2 prefix/suffix" do
+      expect { Dog.build(:one, :two, :three) }.to raise_error(ArgumentError, %{Don't know how to find factory for "dog" with [:one, :two, :three]})
+    end
+  end
+
+  describe "#generate" do
+    after do
+      @dog.should be_saved if @dog
+    end
+
+    it "can call #gen as a shortcut" do
+      @dog = Dog.gen
+      @dog.name.should == "Rover"
+      @dog.should be_saved
+    end
+
+    it "can call with a bang to save! (to raise an Exception on failure)" do
+      expect { Dog.generate! }.to raise_error(RuntimeError, /Called save!/)
+      expect { Dog.gen!      }.to raise_error(RuntimeError, /Called save!/)
+
+      Dog.gen!(:name => "Valid Name").name.should == "Valid Name"
+      Dog.gen!(:name => "Valid Name"){|d| d.name += " FOO" }.name.should == "Valid Name FOO"
+    end
+
+    it "without arguments" do
+      @dog = Dog.generate
+      @dog.name.should == "Rover"
+    end
+
+    it "with overrides" do
+      @dog = Dog.generate(:name => "Spot")
+      @dog.name.should == "Spot"
+    end
+
+    it "yields the built instance to block (after calling #save on it)" do
+      @dog = Dog.generate(:name => "Spot") do |dog|
+        dog.should be_saved
+        dog.name += " Remover"
+      end
+      @dog.name.should == "Spot Remover"
+    end
+
+    it "generate! yields the resulting instance (after calling save! on it)" do
+      Dog.gen!(:name => "Valid Name") do |dog|
+        dog.should be_saved
+      end
+    end
+
+    it "with prefix" do
+      @dog = Dog.generate(:awesome)
+      @dog.name.should == "Awesome Dog"
+    end
+
+    it "with suffix" do
+      @dog = Dog.generate(:with_toys)
+      @dog.name.should == "Dog with toys"
+    end
+
+    it "with prefix and suffix" do
+      @dog = Dog.generate(:awesome, :with_toys)
+      @dog.name.should == "Awesome Dog with toys"
+    end
+
+    it "with prefix and suffix (reversed works too)" do
+      @dog = Dog.generate(:with_toys, :awesome)
+      @dog.name.should == "Awesome Dog with toys"
+    end
+
+    it "cannot pass more than 2 prefix/suffix" do
+      expect { Dog.generate(:one, :two, :three) }.to raise_error(ArgumentError, %{Don't know how to find factory for "dog" with [:one, :two, :three]})
+    end
+  end
+
+  describe "#attributes" do
+    it "without arguments" do
+      Dog.attributes.should == { :name => "Rover" }
+    end
+
+    it "can call #attrs as a shortcut" do
+      Dog.attrs.should == { :name => "Rover" }
+    end
+
+    it "with overrides" do
+      Dog.attributes(:name => "Spot").should == { :name => "Spot" }
+    end
+
+    it "yields the built instance to block" do
+      Dog.attributes(:name => "Spot"){|hash| hash[:name] += " Remover" }.should == { :name => "Spot Remover" }
+    end
+
+    it "with prefix" do
+      Dog.attributes(:awesome).should == { :name => "Awesome Dog" }
+    end
+
+    it "with suffix" do
+      Dog.attributes(:with_toys).should == { :name => "Dog with toys" }
+    end
+
+    it "with prefix and suffix" do
+      Dog.attributes(:awesome, :with_toys).should == { :name => "Awesome Dog with toys" }
+    end
+
+    it "with prefix and suffix (reversed works too)" do
+      Dog.attributes(:with_toys, :awesome).should == { :name => "Awesome Dog with toys" }
+    end
+
+    it "cannot pass more than 2 prefix/suffix" do
+      expect { Dog.attributes(:one, :two, :three) }.to raise_error(ArgumentError, %{Don't know how to find factory for "dog" with [:one, :two, :three]})
+    end
+  end
+end

metadata

@@ -1,82 +1,89 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: factory_girl_extensions
-version: !ruby/object:Gem::Version 
-  hash: 15
+version: !ruby/object:Gem::Version
+  version: 2.0.0
   prerelease: 
-  segments: 
-  - 0
-  - 4
-  - 0
-  version: 0.4.0
 platform: ruby
-authors: 
+authors:
 - remi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-03-01 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: factory_girl
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &19502360 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 0
-        - 0
-        - 0
-        version: 0.0.0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
-  version_requirements: *id001
-description: helpful extensions for factory_girl
+  prerelease: false
+  version_requirements: *19502360
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &19501200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19501200
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &19499300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19499300
+description: ! "Alternative FactoryGirl API allowing you to build/generate factories
+  \nusing your class constants, eg. User.gen instead of Factory(:user).\n"
 email: remi@remitaylor.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/factory_girl_extensions/module.rb
+files:
+- .gemtest
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- factory_girl_extensions.gemspec
 - lib/factory_girl_extensions.rb
+- lib/factory_girl_extensions/core.rb
+- lib/factory_girl_extensions/version.rb
+- spec/factory_girl_extensions_spec.rb
 homepage: http://github.com/remi/factory_girl_extensions
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: helpful extensions for factory_girl
-test_files: []
-
-has_rdoc: 
+summary: Alternative FactoryGirl API
+test_files:
+- spec/factory_girl_extensions_spec.rb

data/lib/factory_girl_extensions/module.rb

@@ -1,91 +0,0 @@
-# Just the module.  You should require this if you don't want FactoryGirlExtensions 
-# automatically included into Object.
-
-# Adds helpful factory_girl methods to objects.
-#
-# This uses method_missing just incase the given Object
-# already responds to one of these methods.
-#
-# == Usage
-# 
-#   User.generate!             # this is equivalent to Factory(:user) or Factory.create(:user)
-#   User.gen!                  # this is a shortcut alias for #generate
-#   User.generate              # this is equivalent to Factory.build(:user) and then #save
-#   User.gen                   # this is equivalent to Factory.build(:user) and then #save
-#   User.build                 # this is equivalent to Factory.build(:user)
-#   User.gen! :name => 'Bob'   # this is equivalent to Factory(:user, :name => 'Bob')
-#   :email.next                # this is equivalent to Factory.next(:email)
-#   'email'.next               # this will NOT work because String#next already exists
-#   :admin_user.gen!           # this is equivalent to Factory.gen(:admin_user)
-#   'admin_user'.gen!          # this is equivalent to Factory.gen(:admin_user)
-#   User.attrs                 # this is equivalent to Factory.attributes_for(:user)
-#   'user'.attrs               # this is equivalent to Factory.attributes_for(:user)
-#   :user.attrs                # this is equivalent to Factory.attributes_for(:user)
-#
-# == TODO
-#
-# * properly implement <tt>respond_to?</tt>
-# * add syntax like User.gen_admin or User.gen(:admin) for generating an :admin_user
-#
-module FactoryGirlExtensions
-
-  # I was relying on String#underscore being available and it's not always.
-  # Copies this from ActiveSupport.
-  def underscore_string string
-    string.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-
-  # This is the actual (private) implementation
-  def self.__method_missing object, name, *args, &block
-    raise 'Factory is not defined.  Have you required factory_girl?' unless defined? Factory
-
-    messages = case name.to_s
-    when /^gen(erate)?\!$/
-      [:build, :save!]
-    when /^gen(erate)?$/
-      [:build, :save]
-    when 'build'
-      [:build]
-    when 'next'
-      [:next]
-    when /^attr(ibute)?s(_for)?$/
-      [:attributes_for]
-    end
-
-    if messages
-      # if this is an instance of String/Symbol use this instance as the factory name, else use the class name
-      factory_name = ( object.kind_of?(Symbol) || object.kind_of?(String) ) ? object.to_s.to_sym : underscore_string(object.name).to_sym
-
-      factory_method, instance_method = messages
-      instance = Factory.send factory_method, factory_name, *args
-
-      if instance_method
-        instance.send instance_method if instance.respond_to? instance_method
-      end
-      
-      instance
-
-    else
-      :no_extension_found
-    end
-  end
-
-  # This is the public implementation.  When you include 
-  # FactoryGirlExtensions into a class, this is what gives 
-  # you the #gen and other methods.
-  def method_missing name, *args, &block
-    object = FactoryGirlExtensions.__method_missing(self, name, *args, &block)
-    
-    # If no extensions were found, call super
-    if object == :no_extension_found
-      super
-    else
-      object
-    end
-  end
-
-end