factory_bot 4.11.1 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14d67d2d0498cdfe3d47717279561f299566ecd20084af6958e3c5143188ccae
-  data.tar.gz: bb6daffb31d969293032bbb2d655c3628095bdd285708fdc93fe2a60e4cd072e
+  metadata.gz: 802da48aa95dce3321f20d0173c5dcf041c5393fb0c270fb8ae2029ce12b6ed9
+  data.tar.gz: 0aa227896ef66ccf100f88b1aa4e9aa26c5bc657fee76739a73e15072bc80572
 SHA512:
-  metadata.gz: 24178c541ce3b726ad7274febd2bbf69ccaff9446a15a79b9bfce5525b0e2f63cc4af50a48950abe5b8b80397151bf86c31263463b0d7309093c870cb925c97d
-  data.tar.gz: 630e120e664a503de162d11d9dc36f83a7fc5602a8935875cacfb905b28c3cf1c8f0978137281b5aa8d2fed3fa40c236dd567cb7544bca44cb85e1f43fb2ac83
+  metadata.gz: 63554d6765398f0c524cb8cd45b1a0da83da1d8aba9f359d0e4c44e42cdbd0d93edb8e38c668e0310ad709905c5cd6a3c35e640ad8c45a06a8b7d4090b4e6161
+  data.tar.gz: fe3be69bdd601384da0a7f2ec7e1fcf00ae7d4984c65423e31e94c1b7f3d7bb04345371daaea19d794365972b59f69f9f3403b0ef8b8ef7d7349d89404284ac2

data/GETTING_STARTED.md

@@ -4,16 +4,16 @@ Getting Started
 Update Your Gemfile
 -------------------
 
-If you're using Rails, you'll need to change the required version of `factory_bot_rails`:
+If you're using Rails:
 
 ```ruby
-gem "factory_bot_rails", "~> 4.0"
+gem "factory_bot_rails"
 ```
 
-If you're *not* using Rails, you'll just have to change the required version of `factory_bot`:
+If you're *not* using Rails:
 
 ```ruby
-gem "factory_bot", "~> 4.0"
+gem "factory_bot"
 ```
 
 JRuby users: factory_bot works with JRuby starting with 1.6.7.2 (latest stable, as per July 2012).
@@ -30,7 +30,7 @@ Configure your test suite
 
 ### RSpec
 
-If you're using Rails:
+If you're using Rails, add the following configuration to `spec/support/factory_bot.rb` and be sure to require that file in `rails_helper.rb`:
 
 ```ruby
 RSpec.configure do |config|
@@ -102,7 +102,7 @@ If you do not include `FactoryBot::Syntax::Methods` in your test suite, then all
 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:
+Each factory has a name and a set of attributes. The name is used to guess the class of the object by default:
 
 ```ruby
 # This will guess the User class
@@ -112,16 +112,26 @@ FactoryBot.define do
     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
 end
 ```
 
+It is also possible to explicitly specify the class:
+
+```ruby
+# This will use the User class (otherwise Admin would have been guessed)
+factory :admin, class: User
+```
+
+If the constant is not available
+(if you are using a Rails engine that waits to load models, for example),
+you can also pass a symbol or string,
+which factory_bot will constantize later, once you start building objects:
+
+```ruby
+# It's OK if Doorkeeper::AccessToken isn't loaded yet
+factory :access_token, class: "Doorkeeper::AccessToken"
+```
+
 Because of the block syntax in Ruby, defining attributes as `Hash`es (for
 serialized/JSON columns, for example) requires two sets of curly brackets:
 
@@ -177,21 +187,15 @@ user.first_name
 # => "Joe"
 ```
 
+Note that objects created with `build_stubbed` cannot be serialized with
+`Marshal.dump`, since factory_bot defines singleton methods on these objects.
+
 Static Attributes
 ------------------
 
-Static attributes, without a block, are deprecated and will be removed in
-factory\_bot 5. 
-
-```ruby
-factory :user do
-  # Do not use deprecated static attributes
-  admin true
-
-  # Use dynamic attributes instead
-  admin { true }
-end
-```
+Static attributes (without a block) are no longer available in factory\_bot 5.
+You can read more about the decision to remove them in
+[this blog post](https://robots.thoughtbot.com/deprecating-static-attributes-in-factory_bot-4-11).
 
 Aliases
 -------
@@ -261,8 +265,8 @@ create(:user, upcased: true).name
 #=> "JOHN DOE - ROCKSTAR"
 ```
 
-Static and dynamic attributes can be created as transient attributes. Transient
-attributes will be ignored within attributes\_for and won't be set on the model,
+Transient 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_bot's dynamic attributes, you can access transient attributes as
@@ -273,7 +277,7 @@ transient attributes from there.
 Method Name / Reserved Word Attributes
 -------------------------------
 
-If your attributes conflict with existing methods or reserved words you can define them with `add_attribute`.
+If your attributes conflict with existing methods or reserved words (all methods in the [DefinitionProxy](https://github.com/thoughtbot/factory_bot/blob/master/lib/factory_bot/definition_proxy.rb) class) you can define them with `add_attribute`.
 
 ```ruby
 factory :dna do
@@ -343,9 +347,35 @@ factory :post do
 end
 ```
 
-The behavior of the association method varies depending on the build strategy used for the parent object.
+In factory\_bot 5, associations default to using the same build strategy as
+their parent object:
 
 ```ruby
+FactoryBot.define do
+  factory :author
+
+  factory :post do
+    author
+  end
+end
+
+post = build(:post)
+post.new_record?        # => true
+post.author.new_record? # => true
+
+post = create(:post)
+post.new_record?        # => false
+post.author.new_record? # => false
+```
+
+This is different than the default behavior for previous versions of
+factory\_bot, where the association strategy would not always match the strategy
+of the parent object. If you want to continue using the old behavior, you can
+set the `use_parent_strategy` configuration option to `false`.
+
+```ruby
+FactoryBot.use_parent_strategy = false
+
 # Builds and saves a User and a Post
 post = create(:post)
 post.new_record?        # => false
@@ -357,9 +387,11 @@ post.new_record?        # => true
 post.author.new_record? # => false
 ```
 
-To not save the associated object, specify strategy: :build in the factory:
+To not save the associated object, specify `strategy: :build` in the factory:
 
 ```ruby
+FactoryBot.use_parent_strategy = false
+
 factory :post do
   # ...
   association :author, factory: :user, strategy: :build
@@ -476,6 +508,36 @@ create(:profile_with_languages).languages.length # 5
 create(:profile_with_languages, languages_count: 15).languages.length # 15
 ```
 
+Polymorphic associations can be handled with traits:
+
+```ruby
+FactoryBot.define do
+  factory :video
+  factory :photo
+
+  factory :comment do
+    for_photo # default to the :for_photo trait if none is specified
+
+    trait :for_video do
+      association :commentable, factory: :video
+    end
+
+    trait :for_photo do
+      association :commentable, factory: :photo
+    end
+  end
+end
+```
+
+This allows us to do:
+
+```ruby
+create(:comment)
+create(:comment, :for_video)
+create(:comment, :for_photo)
+```
+
+
 Sequences
 ---------
 
@@ -515,6 +577,9 @@ factory :user do
 end
 ```
 
+Note that defining sequences as implicit attributes will not work if you have a
+factory with the same name as the sequence.
+
 And it's also possible to define an in-line sequence that is only used in
 a particular factory:
 
@@ -623,7 +688,7 @@ factory :story do
 end
 ```
 
-Traits can be used as attributes:
+Traits can be used as implicit attributes:
 
 ```ruby
 factory :week_long_published_story_with_title, parent: :story do
@@ -633,6 +698,9 @@ factory :week_long_published_story_with_title, parent: :story do
 end
 ```
 
+Note that defining traits as implicit attributes will not work if you have a
+factory or sequence with the same name as the trait.
+
 Traits that define the same attributes won't raise AttributeDefinitionErrors;
 the trait that defines the attribute latest gets precedence.
 
@@ -893,7 +961,7 @@ If a gem were to give you a User factory:
 ```ruby
 FactoryBot.define do
   factory :user do
-    full_name "John Doe"
+    full_name { "John Doe" }
     sequence(:username) { |n| "user#{n}" }
     password { "password" }
   end
@@ -950,6 +1018,14 @@ To set the attributes for each of the factories, you can pass in a hash as you n
 twenty_year_olds = build_list(:user, 25, date_of_birth: 20.years.ago)
 ```
 
+In order to set different attributes for each factory, these methods may be passed a block, with the factory and the index as parameters:
+
+```ruby
+twenty_somethings = build_list(:user, 10) do |user, i|
+  user.date_of_birth = (20 + i).years.ago
+end
+```
+
 `build_stubbed_list` will give you fully stubbed out instances:
 
 ```ruby
@@ -999,8 +1075,10 @@ namespace :factory_bot do
   desc "Verify that all FactoryBot factories are valid"
   task lint: :environment do
     if Rails.env.test?
-      DatabaseCleaner.cleaning do
+      conn = ActiveRecord::Base.connection
+      conn.transaction do
         FactoryBot.lint
+        raise ActiveRecord::Rollback
       end
     else
       system("bundle exec rake factory_bot:lint RAILS_ENV='test'")
@@ -1012,8 +1090,7 @@ end
 
 After calling `FactoryBot.lint`, you'll likely want to clear out the
 database, as records will most likely be created. The provided example above
-uses the database_cleaner gem to clear out the database; be sure to add the
-gem to your Gemfile under the appropriate groups.
+uses an sql transaction and rollback to leave the database clean.
 
 You can lint factories selectively by passing only factories you want linted:
 
@@ -1047,6 +1124,13 @@ You can also specify the strategy used for linting:
 FactoryBot.lint strategy: :build
 ```
 
+Verbose linting will include full backtraces for each error, which can be
+helpful for debugging:
+
+```ruby
+FactoryBot.lint verbose: true
+```
+
 Custom Construction
 -------------------
 
@@ -1337,12 +1421,12 @@ with associations, as below:
 
 ```ruby
 FactoryBot.define do
-  factory :united_states, class: Location do
+  factory :united_states, class: "Location" do
     name { 'United States' }
     association :location_group, factory: :north_america
   end
 
-  factory :north_america, class: LocationGroup do
+  factory :north_america, class: "LocationGroup" do
     name { 'North America' }
   end
 end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2017 Joe Ferris and thoughtbot, inc.
+Copyright (c) 2008-2019 Joe Ferris and thoughtbot, inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/NEWS.md

@@ -0,0 +1,351 @@
+# News
+
+## 5.2.0 (April 24, 2020)
+  * Added: Pass index to block for `*_list` methods
+  * Deprecated: top-level methods meant only for internal use: `callbacks`, `configuration`, `constructor`, `initialize_with`, `register_sequence`, `resent_configuration`, `skip_create`, `to_create`
+
+## 5.1.2 (March 25, 2020)
+  * Fixed: Ruby 2.7 keyword deprecation warning in FactoryBot.lint
+
+## 5.1.1 (October 2, 2019)
+  * Improved: performance of traits
+  * Fixed: registering strategies on JRuby
+
+## 5.1.0 (September 21, 2019)
+  * Added: "Did you mean?" style error message to help with typos in association declarations
+  * Changed: `NoMethodError` for static attributes now offers a "Did you mean?" style message
+  * Fixed: avoid undefining inherited evaluator methods
+  * Fixed: avoid stubbing id for records without a primary key
+  * Fixed: raise a helpful error for self-referencing traits to avoid a `SystemStackError`
+  * Deprecated: top-level methods meant only for internal use: `allow_class_lookup`, `allow_class_lookup`=, `register_trait`, `trait_by_name`, `traits`, `sequence_by_name`, `sequences`, `factory_by_name`, `register_factory`, `callback_names`, `register_callback`, `register_default_callbacks`, `register_default_strategies`, `strategies`
+
+## 5.0.2 (February 22, 2019)
+  * Bugfix: raise "Trait not registered" error when passing invalid trait arguments
+
+## 5.0.1 (February 15, 2019)
+  * Bugfix: Do not raise error when two sequences have the same name
+    in two traits that have the same name
+
+## 5.0.0 (February 1, 2019)
+  * Added: Verbose option to include full backtraces in the linting output
+  * Changed: use_parent_strategy now defaults to true, so by default the
+    build strategy will build, rather than create associations
+  * Changed: Passing a block when defining associations now raises an error
+  * Bugfix: use_parent_strategy is no longer reset by FactoryBot.reload
+  * Bugfix: rewind_sequences will now rewind local sequences along with the global ones
+  * Bugfix: the build_stubbed strategy now sets timestamps without changing the
+    the original behavior of the timestamp methods
+  * Bugfix: avoid a stack error when referring to an "attributes" attribute in initialize_with
+  * Removed: support for EOL versions of Ruby and Rails
+  * Removed: static attributes (use dynamic attributes with a block instead)
+  * Removed: looking up factories by class
+  * Removed: ignore method (use transient instead)
+  * Removed: duplicate_attribute_assignment_from_initialize_with configuration option
+  * Deprecated: allow_class_lookup configuration option
+
+## 4.11.1 (September 7, 2018)
+  * Documentation: Include .yardopts in the gem to fix broken RubyDoc links
+
+## 4.11.0 (August, 15, 2018)
+  * Bugfix: Do not raise error for valid build_stubbed methods: decrement, increment, and toggle
+  * Bugfix: Do not add timestamps with build_stubbed for objects that shouldn't have timestamps
+  * Deprecate static attributes
+
+## 4.10.0 (May 25, 2018)
+  * Allow sequences to be rewound
+
+## 4.9.0 (skipped - FactoryGirl only release)
+
+## 4.8.2 (October 20, 2017)
+  * Rename factory_girl to factory_bot
+
+## 4.8.1 (September 28, 2017)
+  * Explicitly define `#destroyed?` within the `Stub` strategy to return `nil` instead of raising
+  * Update various dependencies
+  * Update internal test suite to use RSpec's mocking/stubbing instead of mocha
+
+## 4.8.0 (December 16, 2016)
+  * Improve documentation
+  * Add `FactoryGirl.generate_list` to be consistent with `build_list`/`create_list` and friends
+  * Add `FactoryGirl.use_parent_strategy` configuration to allow associations to leverage parent build strategy
+
+## 4.7.0 (April 1, 2016)
+  * Improve documentation
+  * Improve instrumentation payload to include traits, overrides, and the factory itself
+  * Allow linting of traits
+  * Deprecate factory lookup by class name in preparation for 5.0
+  * Improve internal performance by using flat_map instead of map and compact
+  * Improve handling of dirty attributes after building a stubbed object
+  * Reduce warnings from redefining methods
+
+## 4.6.0 (skipped)
+
+## 4.5.0 (October 17, 2014)
+  * Improve FactoryGirl.lint by including exception and message in output
+  * Allow selective linting
+  * Use more explicit #public_send when doing attribute assignment
+  * Improve documentation around FactoryGirl.lint and initialize_with
+  * Deprecate #ignore in favor of #transient
+
+## 4.4.0 (February 10, 2014)
+  * Add FactoryGirl.lint
+  * Fix memory leak in duplicate traits
+  * Update documentation
+
+## 4.3.0 (November 3, 2013)
+  * Start testing against Rails 4.0 and Ruby 2.0.0
+  * Stop testing against Rails 3.0 and Ruby 1.9.2
+  * Add `*_pair` methods to only build two objects
+  * Raise if a method is defined with a FactoryGirl block (factory or trait)
+  * Allow use of Symbol#to_proc in callbacks
+  * Add global callbacks
+  * Improve GETTING_STARTED and README
+
+## 4.2.0 (January 18, 2013)
+  * Improve documentation
+  * Allow `*_list` syntax methods to accept a block
+  * Update gem dependencies
+  * Allow setting id for objects created with `build_stubbed`
+  * Fix Stub strategy to mimic ActiveRecord regarding `created_at`
+  * Evaluate sequences within the context of an Evaluator
+  * Fix Mocha deprecation warning
+  * Fix some warnings when running RUBYOPT=-w rake
+  * Convert test suite to RSpec's "expect" syntax
+
+## 4.1.0 (September 11, 2012)
+  * Allow multiple callbacks to bind to the same block
+  * Fix documentation surrounding the stub strategy
+
+## 4.0.0 (August 3, 2012)
+  * Remove deprecated cucumber_steps
+  * Remove deprecated alternate syntaxes
+  * Deprecate duplicate_attribute_assignment_from_initialize_with, which is now unused
+    as attributes assigned within initialize_with are not subsequently assigned
+
+## 3.6.1 (August 2, 2012)
+  Update README to include info about running with JRuby
+  * Update dependencies on RSpec and tiny versions of Rails in Appraisal
+  * Improve flexibility of using traits with associations and add documentation
+  * Stub update_column to raise to mirror ActiveRecord's change from update_attribute
+
+## 3.6.0 (July 27, 2012)
+  * Code/spec cleanup
+  * Allow factories with traits to be used in associations
+  * Refactor Factory to use DefinitionHierarchy to handle managing callbacks,
+    custom constructor, and custom to_create
+  * Add memoization to speed up factories providing attribute overrides
+  * Add initial support of JRuby when running in 1.9 mode
+  * Improve docs on what happens when including FactoryGirl::Syntax::Methods
+
+## 3.5.0 (June 22, 2012)
+  * Allow created_at to be set when using build_stubbed
+  * Deprecate FactoryGirl step definitions
+
+## 3.4.2 (June 19, 2012)
+  * Fix bug in traits with callbacks called implicitly in factories whose
+    callbacks trigger multiple times
+
+## 3.4.1 (June 18, 2012)
+  * Fix traits so they can be nested and referred to from other traits
+
+## 3.4.0 (June 11, 2012)
+  * Sequences support Enumerators
+  * Optionally disable duplicate assignment of attributes in initialize_with
+  * Make hash of public attributes available in initialize_with
+  * Support referring to a factory based on class name
+
+## 3.3.0 (May 13, 2012)
+  * Allow to_create, skip_create, and initialize_with to be defined globally
+  * Allow to_create, skip_create, and initialize_with to be defined within traits
+  * Fix deprecation messages for alternate syntaxes (make, generate, etc.)
+  * Improve library documentation
+  * Deprecate after_build, after_create, before_create, after_stub in favor of new callbacks
+  * Introduce new callback syntax: after(:build) {}, after(:custom) {}, or callback(:different) {}
+    This allows for declaring any callback, usable with custom strategies
+  * Add attributes_for_list and build_stubbed_list with the StrategySyntaxMethodRegistrar
+  * Allow use of syntax methods (build, create, generate, etc) implicitly in callbacks
+  * Internal refactoring of a handful of components
+
+## 3.2.0 (April 24, 2012)
+  * Use AS::Notifications for pub/sub to track running factories
+  * Call new within initialize_with implicitly on the build class
+  * Skip to_create with skip_create
+  * Allow registration of custom strategies
+  * Deprecate alternate syntaxes
+  * Implicitly call factory_bot's syntax methods from dynamic attributes
+
+## 3.1.0 (April 6, 2012)
+  * Sequences support aliases, which reference the same block
+  * Update documentation
+  * Add before_create callback
+  * Support use of #attribute_names method to determine available attributes for steps
+  * Use ActiveSupport::Deprecation for all deprecations
+
+## 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 trailing 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 FactoryGirl 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 FactoryGirl 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_bot.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