challah 0.5.2 → 0.5.3

data/vendor/bundle/gems/factory_girl-3.0.0/Appraisals

@@ -0,0 +1,11 @@
+appraise "3.0" do
+  gem "activerecord", "~> 3.0"
+end
+
+appraise "3.1" do
+  gem "activerecord", "~> 3.1"
+end
+
+appraise "3.2" do
+  gem "activerecord", "~> 3.2"
+end

data/vendor/bundle/gems/factory_girl-3.0.0/CONTRIBUTION_GUIDELINES.md

@@ -0,0 +1,10 @@
+Contributing to factory\_girl:
+
+1. Fork the [official repository](https://github.com/thoughtbot/factory_girl/tree/master).
+2. Make your changes in a topic branch.
+3. Send a pull request.
+
+Notes:
+
+* Contributions without tests won't be accepted.
+* Please don't update the Gem version.

data/vendor/bundle/gems/factory_girl-3.0.0/Changelog

@@ -0,0 +1,168 @@
+3.0.0 (March 23, 2012)
+  Deprecate the vintage syntax
+  Remove Rails 2.x support
+  Remove Ruby 1.8 support
+  Remove deprecated features, including default_strategy, factory_name,
+    :method for defining default strategy, ignore on individual attributes, and
+    interacting with Factory the way you would FactoryGirl
+
+2.6.4 (March 16, 2012)
+  Do not ignore names of transient attributes
+  Ensure attributes set on instance are calculated uniquely
+
+2.6.3 (March 9, 2012)
+  Fix issue with traits not being present the first time a factory is accessed
+  Update available Cucumber step definitions to not require a trialing colon
+    when building a table of attributes to instantiate records with
+
+2.6.2 (March 9, 2012)
+  Allow factories to use all their ancestors' traits
+  Ignore bin dir generated by bundler
+  Namespace ::Factory as top-level to fix vintage syntax issue with
+    Ruby 1.9.2-p3p18
+
+2.6.1 (March 2, 2012)
+  Use FactoryGirl.reload in specs
+  Clean up running named factories with a particular strategy with
+    FactoryGirl::FactoryRunner
+
+2.6.0 (February 17, 2012)
+  Improve documentation of has_many associations in the GETTING_STARTED
+    document
+  Deprecate :method in favor of :strategy when overriding an association's
+    build strategy
+
+2.5.2 (February 10, 2012)
+  Fix step definitions to use associations defined in parent factories
+  Add inline trait support to (build|create)_list
+  Update ActiveSupport dependency to >= 2.3.9, which introduced
+    class_attribute
+
+2.5.1 (February 3, 2012)
+  Fix attribute evaluation when the attribute isn't defined in the factory but
+    is a private method on Object
+  Update rubygems on Travis before running tests
+  Fix spec name
+  Update GETTING_STARTED with correct usage of build_stubbed
+  Update README with more info on initialize_with
+  Honor :parent on factory over block nesting
+
+2.5.0 (January 20, 2012)
+  Revert 'Deprecate build_stubbed and attributes_for'
+  Implement initialize_with to allow overriding object instantiation
+  Ensure FG runs against Rails 3.2.0
+
+2.4.2 (January 18, 2012)
+  Fix inline traits' interaction with defaults on the factory
+
+2.4.1 (January 17, 2012)
+  Deprecate build_stubbed and attributes_for
+  Fix inline traits
+
+2.4.0 (January 13, 2012)
+  Refactor internals of Factory Girl to use anonymous class on which attributes
+    get defined
+  Explicitly require Ruby 1.8.7 or higher in gemspec
+  Fix documentation
+  Add Gemnasium status to documentation
+  Supplying a Class to a factory that overrides to_s no longer results in
+    getting the wrong Class constructed
+  Be more agnostic about ORMs when using columns in Factory Girl step
+    definitions
+  Test against Active Record 3.2.0.rc2
+  Update GETTING_STARTED to use Ruby syntax highlighting
+
+2.3.2 (November 26, 2011)
+  Move logic of where instance.save! is set to Definition
+  Fix method name from aliases_for? to alias_for?
+  Refactor internal attribute handling to use an anonymous class instead of
+    faking Ruby's variable resolution. This allows for more sane usage of
+    attributes without having to manage sorting priority because attributes
+    can turn themselves into procs, which are used with define_method on a
+    class so attributes work correctly all the time.
+
+2.3.1 (November 23, 2011)
+  Remove internally-used associate method from all the FactoryGirl::Proxy subclasses
+  Move around requiring of files
+  Consolidate errors into factory_girl.rb
+  Refactor AttributeList to deal with priority only when iterating over
+    attributes
+  Refactor internals of some of the Proxy subclasses
+  Ensure callbacks on traits are executed in the correct order
+
+2.3.0 (November 18, 2011)
+  Registries are named, resulting in better messages when factories, traits,
+    or sequences cannot be found
+  Fix incorrect tests
+  Internals refactoring introducing FactoryGirl::NullFactory,
+    FactoryGirl::Definition, and FactoryGirl::DeclarationList
+  Use ActiveSupport for Hash#except and its delegation capabilities
+  Fix usage of callbacks when added via implicit traits
+  Use Bundler tasks and clean up dependencies
+  Fix failing spec for big letters in factory name passed as symbol
+  Add ability for traits to be added dynamically when creating an instance via
+    build, create, build_stubbed, or attributes_for
+
+2.2.0 (October 14, 2011)
+  Clean up RSpec suite to not use 'should'
+  Use create_list in step definitions
+  Syntax methods that deal with ORM interaction (attributes_for, build, build_stubbed,
+    and create) now accept a block that yields the result. This results in a
+    more convenient way to interact with the result than using Object.tap.
+  Standardize deprecation warnings
+  Update transient attribute syntax to use blocks instead of calling ignore on
+    each attribute declaration
+  Parents can be defined after children because factories are evaluated when
+    they're used; this means breaking up factories across multiple files will
+    behave as expected
+  Large internal refactoring, including changing access modifiers for a
+    handful of methods for a more clearly defined API
+
+2.1.2 (September 23, 2011)
+  Bugfix: Vintage syntax fixed after bug introduced in 2.1.1
+  Introduce dependency on activesupport to remove code from Factory class
+
+2.1.1 (September 23, 2011) (yanked)
+  Bugfix: Parent object callbacks are run before child object callbacks
+  Declarations: allow overriding/modification of individual traits in child factories
+  Callbacks refactored to not be attributes
+  Updating documentation for formatting and clarity (incl. new specificity for cucumber)
+
+2.1.0 (September 02, 2011)
+  Bugfix: created_at now defined for stubbed models
+  Gemspec updated for use with Rails 3.1
+  Factories can now be modified post-definition (useful for overriding defaults from gems/plugins)
+  All factories can now be reloaded with Factory.reload
+  Add :method => build to factory associations to prevent saving of associated objects
+  Factories defined in {Rails.root}/factories are now loaded by default
+  Various documentation updates
+
+1.1.4 (November 28, 2008)
+  Factory.build now uses Factory.create for associations of the built object
+  Factory definitions are now detected in subdirectories, such as
+		factories/person_factory.rb (thanks to Josh Nichols)
+  Factory definitions are now loaded after the environment in a Rails project
+		(fixes some issues with dependencies being loaded too early) (thanks to
+		Josh Nichols)
+  Factory names ending in 's' no longer cause problems (thanks to Alex Sharp
+		and Josh Owens)
+
+1.1.3 (September 12, 2008)
+  Automatically pull in definitions from factories.rb, test/factories.rb, or
+	spec/factories.rb
+1.1.2 (July 30, 2008)
+  Improved error handling for invalid and undefined factories/attributes
+	Improved handling of strings vs symbols vs classes
+	Added a prettier syntax for handling associations
+  Updated documentation and fixed compatibility with Rails 2.1
+
+1.1.1 (June 23, 2008)
+  The attribute "name" no longer requires using #add_attribute
+
+1.1.0 (June 03, 2008)
+	Added support for dependent attributes
+	Fixed the attributes_for build strategy to not build associations
+  Added support for sequences
+
+1.0.0 (May 31, 2008)
+  First version

data/vendor/bundle/gems/factory_girl-3.0.0/GETTING_STARTED.md

@@ -0,0 +1,735 @@
+Getting Started
+===============
+
+Update Your Gemfile
+-------------------
+
+If you're using Rails, you'll need to change the required version of `factory_girl_rails`:
+
+```ruby
+gem "factory_girl_rails", "~> 2.0"
+```
+
+If you're *not* using Rails, you'll just have to change the required version of `factory_girl`:
+
+```ruby
+gem "factory_girl", "~> 3.0"
+```
+
+Once your Gemfile is updated, you'll want to update your bundle.
+
+Defining factories
+------------------
+
+Each factory has a name and a set of attributes. The name is used to guess the class of the object by default, but it's possible to explicitly specify it:
+
+```ruby
+# This will guess the User class
+FactoryGirl.define do
+  factory :user do
+    first_name 'John'
+    last_name  'Doe'
+    admin false
+  end
+
+  # This will use the User class (Admin would have been guessed)
+  factory :admin, :class => User do
+    first_name 'Admin'
+    last_name  'User'
+    admin true
+  end
+
+  # The same, but using a string instead of class constant
+  factory :admin, :class => 'user' do
+    first_name 'Admin'
+    last_name  'User'
+    admin true
+  end
+end
+```
+
+It is highly recommended that you have one factory for each class that provides the simplest set of attributes necessary to create an instance of that class. If you're creating ActiveRecord objects, that means that you should only provide attributes that are required through validations and that do not have defaults. Other factories can be created through inheritance to cover common scenarios for each class.
+
+Attempting to define multiple factories with the same name will raise an error.
+
+Factories can be defined anywhere, but will be automatically loaded if they
+are defined in files at the following locations:
+
+    test/factories.rb
+    spec/factories.rb
+    test/factories/*.rb
+    spec/factories/*.rb
+
+Using factories
+---------------
+
+factory\_girl supports several different build strategies: build, create, attributes\_for and stub:
+
+```ruby
+# Returns a User instance that's not saved
+user = FactoryGirl.build(:user)
+
+# Returns a saved User instance
+user = FactoryGirl.create(:user)
+
+# Returns a hash of attributes that can be used to build a User instance
+attrs = FactoryGirl.attributes_for(:user)
+
+# Returns an object with all defined attributes stubbed out
+stub = FactoryGirl.build_stubbed(:user)
+
+# Passing a block to any of the methods above will yield the return object
+FactoryGirl.create(:user) do |user|
+  user.posts.create(attributes_for(:post))
+end
+```
+
+No matter which strategy is used, it's possible to override the defined attributes by passing a hash:
+
+```ruby
+# Build a User instance and override the first_name property
+user = FactoryGirl.build(:user, :first_name => 'Joe')
+user.first_name
+# => "Joe"
+```
+
+If repeating "FactoryGirl" is too verbose for you, you can mix the syntax methods in:
+
+```ruby
+# rspec
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+end
+
+# Test::Unit
+class Test::Unit::TestCase
+  include Factory::Syntax::Methods
+end
+```
+
+This would allow you to write:
+
+```ruby
+describe User, "#full_name" do
+  subject { create(:user, :first_name => "John", :last_name => "Doe") }
+
+  its(:full_name) { should == "John Doe" }
+end
+```
+
+Lazy Attributes
+---------------
+
+Most factory attributes can be added using static values that are evaluated when
+the factory is defined, but some attributes (such as associations and other
+attributes that must be dynamically generated) will need values assigned each
+time an instance is generated. These "lazy" attributes can be added by passing a
+block instead of a parameter:
+
+```ruby
+factory :user do
+  # ...
+  activation_code { User.generate_activation_code }
+  date_of_birth   { 21.years.ago }
+end
+```
+
+Aliases
+-------
+
+Aliases allow you to use named associations more easily.
+
+```ruby
+factory :user, :aliases => [:author, :commenter] do
+  first_name    "John"
+  last_name     "Doe"
+  date_of_birth { 18.years.ago }
+end
+
+factory :post do
+  author
+  # instead of
+  # association :author, :factory => :user
+  title "How to read a book effectively"
+  body  "There are five steps involved."
+end
+
+factory :comment do
+  commenter
+  # instead of
+  # association :commenter, :factory => :user
+  body "Great article!"
+end
+```
+
+Dependent Attributes
+--------------------
+
+Attributes can be based on the values of other attributes using the evaluator that is yielded to lazy attribute blocks:
+
+```ruby
+factory :user do
+  first_name 'Joe'
+  last_name  'Blow'
+  email { "#{first_name}.#{last_name}@example.com".downcase }
+end
+
+FactoryGirl.create(:user, :last_name => 'Doe').email
+# => "joe.doe@example.com"
+```
+
+Transient Attributes
+--------------------
+
+There may be times where your code can be DRYed up by passing in transient attributes to factories.
+
+```ruby
+factory :user do
+  ignore do
+    rockstar true
+    upcased { false }
+  end
+
+  name  { "John Doe#{" - Rockstar" if rockstar}" }
+  email { "#{name.downcase}@example.com" }
+
+  after_create do |user, evaluator|
+    user.name.upcase! if evaluator.upcased
+  end
+end
+
+FactoryGirl.create(:user, :upcased => true).name
+#=> "JOHN DOE - ROCKSTAR"
+```
+
+Static and dynamic attributes can be ignored. Ignored attributes will be ignored
+within attributes\_for and won't be set on the model, even if the attribute
+exists or you attempt to override it.
+
+Within Factory Girl's dynamic attributes, you can access ignored attributes as
+you would expect. If you need to access the evaluator in a Factory Girl callback,
+you'll need to declare a second block argument (for the evaluator) and access
+ignored attributes from there.
+
+Associations
+------------
+
+It's possible to set up associations within factories. If the factory name is the same as the association name, the factory name can be left out.
+
+```ruby
+factory :post do
+  # ...
+  author
+end
+```
+
+You can also specify a different factory or override attributes:
+
+```ruby
+factory :post do
+  # ...
+  association :author, :factory => :user, :last_name => 'Writely'
+end
+```
+
+The behavior of the association method varies depending on the build strategy used for the parent object.
+
+```ruby
+# Builds and saves a User and a Post
+post = FactoryGirl.create(:post)
+post.new_record?        # => false
+post.author.new_record? # => false
+
+# Builds and saves a User, and then builds but does not save a Post
+post = FactoryGirl.build(:post)
+post.new_record?        # => true
+post.author.new_record? # => false
+```
+
+To not save the associated object, specify :strategy => :build in the factory:
+
+```ruby
+factory :post do
+  # ...
+  association :author, :factory => :user, :strategy => :build
+end
+
+# Builds a User, and then builds a Post, but does not save either
+post = FactoryGirl.build(:post)
+post.new_record?        # => true
+post.author.new_record? # => true
+```
+
+Generating data for a `has_many` relationship is a bit more involved,
+depending on the amount of flexibility desired, but here's a surefire example
+of generating associated data.
+
+```ruby
+FactoryGirl.define do
+
+  # post factory with a `belongs_to` association for the user
+  factory :post do
+    title "Through the Looking Glass"
+    user
+  end
+
+  # user factory without associated posts
+  factory :user do
+    name "John Doe"
+
+    # user_with_posts will create post data after the user has been created
+    factory :user_with_posts do
+      # posts_count is declared as an ignored attribute and available in
+      # attributes on the factory, as well as the callback via the evaluator
+      ignore do
+        posts_count 5
+      end
+
+      # the after_create yields two values; the user instance itself and the
+      # evaluator, which stores all values from the factory, including ignored
+      # attributes; `create_list`'s second argument is the number of records
+      # to create and we make sure the user is associated properly to the post
+      after_create do |user, evaluator|
+        FactoryGirl.create_list(:post, evaluator.posts_count, :user => user)
+      end
+    end
+  end
+end
+```
+
+This allows us to do:
+
+```ruby
+FactoryGirl.create(:user).posts.length # 0
+FactoryGirl.create(:user_with_posts).posts.length # 5
+FactoryGirl.create(:user_with_posts, :posts_count => 15).posts.length # 15
+```
+
+Inheritance
+-----------
+
+You can easily create multiple factories for the same class without repeating common attributes by nesting factories:
+
+```ruby
+factory :post do
+  title 'A title'
+
+  factory :approved_post do
+    approved true
+  end
+end
+
+approved_post = FactoryGirl.create(:approved_post)
+approved_post.title # => 'A title'
+approved_post.approved # => true
+```
+
+You can also assign the parent explicitly:
+
+```ruby
+factory :post do
+  title 'A title'
+end
+
+factory :approved_post, :parent => :post do
+  approved true
+end
+```
+
+As mentioned above, it's good practice to define a basic factory for each class
+with only the attributes required to create it. Then, create more specific
+factories that inherit from this basic parent. Factory definitions are still
+code, so keep them DRY.
+
+Sequences
+---------
+
+Unique values in a specific format (for example, e-mail addresses) can be
+generated using sequences. Sequences are defined by calling sequence in a
+definition block, and values in a sequence are generated by calling
+FactoryGirl.generate:
+
+```ruby
+# Defines a new sequence
+FactoryGirl.define do
+  sequence :email do |n|
+    "person#{n}@example.com"
+  end
+end
+
+FactoryGirl.generate :email
+# => "person1@example.com"
+
+FactoryGirl.generate :email
+# => "person2@example.com"
+```
+
+Sequences can be used as attributes:
+
+```ruby
+factory :user do
+  email
+end
+```
+
+Or in lazy attributes:
+
+```ruby
+factory :invite do
+  invitee { FactoryGirl.generate(:email) }
+end
+```
+
+And it's also possible to define an in-line sequence that is only used in
+a particular factory:
+
+```ruby
+factory :user do
+  sequence(:email) {|n| "person#{n}@example.com" }
+end
+```
+
+You can also override the initial value:
+
+```ruby
+factory :user do
+  sequence(:email, 1000) {|n| "person#{n}@example.com" }
+end
+```
+
+Without a block, the value will increment itself, starting at its initial value:
+
+```ruby
+factory :post do
+  sequence(:position)
+end
+```
+
+Traits
+------
+
+Traits allow you to group attributes together and then apply them
+to any factory.
+
+```ruby
+factory :user, :aliases => [:author]
+
+factory :story do
+  title "My awesome story"
+  author
+
+  trait :published do
+    published true
+  end
+
+  trait :unpublished do
+    published false
+  end
+
+  trait :week_long_publishing do
+    start_at { 1.week.ago }
+    end_at   { Time.now }
+  end
+
+  trait :month_long_publishing do
+    start_at { 1.month.ago }
+    end_at   { Time.now }
+  end
+
+  factory :week_long_published_story,    :traits => [:published, :week_long_publishing]
+  factory :month_long_published_story,   :traits => [:published, :month_long_publishing]
+  factory :week_long_unpublished_story,  :traits => [:unpublished, :week_long_publishing]
+  factory :month_long_unpublished_story, :traits => [:unpublished, :month_long_publishing]
+end
+```
+
+Traits can be used as attributes:
+
+```ruby
+factory :week_long_published_story_with_title, :parent => :story do
+  published
+  week_long_publishing
+  title { "Publishing that was started at {start_at}" }
+end
+```
+
+Traits that define the same attributes won't raise AttributeDefinitionErrors;
+the trait that defines the attribute latest gets precedence.
+
+```ruby
+factory :user do
+  name "Friendly User"
+  login { name }
+
+  trait :male do
+    name   "John Doe"
+    gender "Male"
+    login { "#{name} (M)" }
+  end
+
+  trait :female do
+    name   "Jane Doe"
+    gender "Female"
+    login { "#{name} (F)" }
+  end
+
+  trait :admin do
+    admin true
+    login { "admin-#{name}" }
+  end
+
+  factory :male_admin,   :traits => [:male, :admin]   # login will be "admin-John Doe"
+  factory :female_admin, :traits => [:admin, :female] # login will be "Jane Doe (F)"
+end
+```
+
+You can also override individual attributes granted by a trait in subclasses.
+
+```ruby
+factory :user do
+  name "Friendly User"
+  login { name }
+
+  trait :male do
+    name   "John Doe"
+    gender "Male"
+    login { "#{name} (M)" }
+  end
+
+  factory :brandon do
+    male
+    name "Brandon"
+  end
+end
+```
+
+Traits can also be passed in as a list of symbols when you construct an instance from FactoryGirl.
+
+```ruby
+factory :user do
+  name "Friendly User"
+
+  trait :male do
+    name   "John Doe"
+    gender "Male"
+  end
+
+  trait :admin do
+    admin true
+  end
+end
+
+# creates an admin user with gender "Male" and name "Jon Snow"
+FactoryGirl.create(:user, :admin, :male, :name => "Jon Snow")
+```
+
+This ability works with `build`, `build_stubbed`, `attributes_for`, and `create`.
+
+`create_list` and `build_list` methods are supported as well. Just remember to pass
+the number of instances to create/build as second parameter, as documented in the
+"Building or Creating Multiple Records" section of this file.
+
+```ruby
+factory :user do
+  name "Friendly User"
+
+  trait :admin do
+    admin true
+  end
+end
+
+# creates 3 admin users with gender "Male" and name "Jon Snow"
+FactoryGirl.create_list(:user, 3, :admin, :male, :name => "Jon Snow")
+```
+
+
+Callbacks
+---------
+
+factory\_girl makes available three callbacks for injecting some code:
+
+* after_build  - called after a factory is built   (via FactoryGirl.build)
+* after_create - called after a factory is saved   (via FactoryGirl.create)
+* after_stub   - called after a factory is stubbed (via FactoryGirl.build_stubbed)
+
+Examples:
+
+```ruby
+# Define a factory that calls the generate_hashed_password method after it is built
+factory :user do
+  after_build { |user| generate_hashed_password(user) }
+end
+```
+
+Note that you'll have an instance of the user in the block. This can be useful.
+
+You can also define multiple types of callbacks on the same factory:
+
+```ruby
+factory :user do
+  after_build  { |user| do_something_to(user) }
+  after_create { |user| do_something_else_to(user) }
+end
+```
+
+Factories can also define any number of the same kind of callback.  These callbacks will be executed in the order they are specified:
+
+```ruby
+factory :user do
+  after_create { this_runs_first }
+  after_create { then_this }
+end
+```
+
+Calling FactoryGirl.create will invoke both after\_build and after\_create callbacks.
+
+Also, like standard attributes, child factories will inherit (and can also define) callbacks from their parent factory.
+
+Modifying factories
+-------------------
+
+If you're given a set of factories (say, from a gem developer) but want to change them to fit into your application better, you can
+modify that factory instead of creating a child factory and adding attributes there.
+
+If a gem were to give you a User factory:
+
+```ruby
+FactoryGirl.define do
+  factory :user do
+    full_name "John Doe"
+    sequence(:username) {|n| "user#{n}" }
+    password "password"
+  end
+end
+```
+
+Instead of creating a child factory that added additional attributes:
+
+```ruby
+FactoryGirl.define do
+  factory :application_user, :parent => :user do
+    full_name     { Faker::Name.name }
+    date_of_birth { 21.years.ago }
+    gender        "Female"
+    health        90
+  end
+end
+```
+
+You could modify that factory instead.
+
+```ruby
+FactoryGirl.modify do
+  factory :user do
+    full_name     { Faker::Name.name }
+    date_of_birth { 21.years.ago }
+    gender        "Female"
+    health        90
+  end
+end
+```
+
+When modifying a factory, you can change any of the attributes you want (aside from callbacks).
+
+`FactoryGirl.modify` must be called outside of a `FactoryGirl.define` block as it operates on factories differently.
+
+A caveat: you can only modify factories (not sequences or traits) and callbacks *still compound as they normally would*. So, if
+the factory you're modifying defines an `after_create` callback, you defining an `after_create` won't override it, it'll just get run after the first callback.
+
+Building or Creating Multiple Records
+-------------------------------------
+
+Sometimes, you'll want to create or build multiple instances of a factory at once.
+
+```ruby
+built_users   = FactoryGirl.build_list(:user, 25)
+created_users = FactoryGirl.create_list(:user, 25)
+```
+
+These methods will build or create a specific amount of factories and return them as an array.
+To set the attributes for each of the factories, you can pass in a hash as you normally would.
+
+```ruby
+twenty_year_olds = FactoryGirl.build_list(:user, 25, :date_of_birth => 20.years.ago)
+```
+
+Custom Construction
+-------------------
+
+If you want to use factory_girl to construct an object where some attributes
+are passed to `initialize` or if you want to do something other than simply
+calling `new` on your build class, you can override the default behavior by
+defining `to_initialize` on your factory. Example:
+
+```ruby
+# user.rb
+class User
+  attr_accessor :name, :email
+
+  def initialize(name)
+    @name = name
+  end
+end
+
+# factories.rb
+sequence(:name) {|n| "person#{n}@example.com" }
+
+factory :user do
+  ignore do
+    name { Faker::Name.name }
+  end
+
+  email
+  initialize_with { User.new(name) }
+end
+
+FactoryGirl.build(:user).name # Bob Hope
+```
+
+Notice that I ignored the `name` attribute. If you don't want attributes
+reassigned after your object has been instantiated, you'll want to `ignore` them.
+
+Although factory_girl is written to work with ActiveRecord out of the box, it
+can also work with any Ruby class. For maximum compatibiltiy with ActiveRecord,
+the default initializer builds all instances by calling new on your build class
+without any arguments. It then calls attribute writer methods to assign all the
+attribute values. While that works fine for ActiveRecord, it actually doesn't
+work for almost any other Ruby class.
+
+You can override the initializer in order to:
+
+* Build non-ActiveRecord objects that require arguments to `initialize`
+* Use a method other than `new` to instantiate the instance
+* Do crazy things like decorate the instance after it's built
+
+Cucumber Integration
+--------------------
+
+factory\_girl ships with step definitions that make calling factories from Cucumber easier. To use them, add the following to features/support/env.rb:
+
+```ruby
+require 'factory_girl/step_definitions'
+```
+
+Alternate Syntaxes
+------------------
+
+Users' tastes for syntax vary dramatically, but most users are looking for a
+common feature set. Because of this factory\_girl supports "syntax layers" which
+provide alternate interfaces. See Factory::Syntax for information about the
+various layers available. For example, the Machinist-style syntax is popular:
+
+```ruby
+require 'factory_girl/syntax/blueprint'
+require 'factory_girl/syntax/make'
+require 'factory_girl/syntax/sham'
+
+Sham.email {|n| "#{n}@example.com" }
+
+User.blueprint do
+  name  { 'Billy Bob' }
+  email { Sham.email  }
+end
+
+User.make(:name => 'Johnny')
+```