stepford 0.9.3 → 0.11.0

data/README.md

@@ -1,32 +1,56 @@
 Stepford
 =====
 
-Stepford is an automatic required (non-null or presence validated) association resolving (creating/building/stubbing) wrapper and/or factory generator for [FactoryGirl][factory_girl].
+Now getting started with FactoryGirl is even more simple and DRY!
 
-For example, with the rspec helper:
+Stepford is an automatic required (non-null or presence validated) association resolver and factory generator for [FactoryGirl][factory_girl].
 
-    create(:foo)
+The Stepford CLI allows can generate a factories.rb or multiple files each defining a single factory, for every existing model or for those specified.
 
-Would take a :foo FactoryGirl factory that has no associations defined in it (only required attributes) and will travel the dependency tree of the models to create and create_list as needed. Or, you can build the same way:
+The following would create/overwrite `test/factories.rb` with a factory for every model in `app/models`:
 
-    build(:foo)
+    bundle exec stepford factories
+
+If you use rspec, it would be:
+
+    bundle exec stepford factories --path spec
+
+With our rspec helper, you can use this to create a bar and automatically create its dependencies and their dependencies, etc. providing ways to remedy circular dependencies:
+
+    deep_create(:bar)
 
-Need to just customize a few things? You can use the normal FactoryGirl behavior (args, options, block) but also specify options for each factory.
+You can also `create_list`, `build`, `build_list`, and `build_stubbed`:
 
-e.g. maybe Bar has a required association called house_special which uses the :beer factory, and we have a block we want to send into it; oh, and Beer has specials that you want to build as a list of 3 using the :tuesday_special_offer factory. Just set it up like:
+    deep_build_list(:bar, 5)
 
-    Stepford::FactoryGirl.create_list(:bar, with_factory_options: {
+Need to customize it? You can use the normal FactoryGirl behavior (args, options, block), but in addition, you may specify options for each factories that would create direct or indirect associations.
+
+e.g. maybe Bar has a required association called house_special which uses the beer factory, and we have a block we want to send into it, and Beer has specials that you want to build as a list of 3, using the tuesday_special_offer factory. In rspec, you'd do:
+
+    deep_create_list(:bar, with_factory_options: {
       house_special: [:create, :beer, {blk: ->(beer) do; beer.bubbles.create(attributes_for(:bubbles)); end}],
       specials: [:build_list, :tuesday_special_offer, 3]
     }) do
       # any block you would send to FactoryGirl.create_list(:bar) would go here
     end
 
-What if you have an existing schema, and you want to use FactoryGirl, but don't have any factories yet?
+By default autogenerated factories just have required attributes, e.g.:
 
-The Stepford CLI allows you to generate your factories.rb or multiple factory files for you.
+    require 'factory_girl_rails'
+
+    FactoryGirl.define do
+    
+      factory :post do
+        created_at { 2.weeks.ago }
+        name 'Test Name'
+        price 1.23
+        trait :with_summary do; template 'Test Summary'; end
+        updated_at { 2.weeks.ago }
+      end
+
+    end
 
-e.g. maybe one of your models is called post, then you could generate a factory for post and all of the other models with a one-liner, maybe with the following in the `some/path/factories/post.rb` file:
+But you can have it autogenerate lots of the FactoryGirl bells and whistles:
 
     require 'factory_girl_rails'
 
@@ -48,6 +72,10 @@ e.g. maybe one of your models is called post, then you could generate a factory
 
     end
 
+But, everything from author to with_notes may have association interdependency issues unless you hand edit the generated versions.
+
+Stepford's FactoryGirl (and optionally its rspec helper) can help you avoid the heavy lifting.
+
 ### Setup
 
 In your Rails 3+ project, add this to your Gemfile:
@@ -95,9 +123,9 @@ Put this in your `spec/spec_helper.rb`:
 
     require 'stepford/factory_girl_rspec_helpers'
 
-Then you can just use `create`, `create_list`, `build`, `build_list`, or `build_stubbed` in your rspec tests (`create` becomes a shortcut for `::Stepford::FactoryGirl.create`, etc.), e.g.:
+Then you can just use `deep_create`, `deep_create_list`, `deep_build`, `deep_build_list`, or `deep_build_stubbed` in your rspec tests (`deep_create` becomes a shortcut for `::Stepford::FactoryGirl.create`, etc.), e.g.:
 
-    create(:foo)
+    deep_create(:foo)
 
 ##### Stopping Circular References
 
@@ -108,6 +136,14 @@ If you have a circular reference (A has NOT NULL foreign key to B that has NOT N
        [:waiter, :bar] => {on_loop: 2, set_to: Waiter.find(123)},
     }
 
+Leave out :on_loop or set :on_loop to 0 to use the set instead of attempting to build/create.
+
+##### Debugging
+
+Add somewhere after the require:
+
+    Stepford::FactoryGirl.debug = true
+
 #### CLI
 
 Stepford has a CLI with a circular reference checker and a generator to automatically create your factories file(s).
@@ -186,9 +222,9 @@ To generate traits for each association that would be included with `--associati
 
 ###### Associations
 
-If you use the (cache) wrapper to automatically generate factories, you may not need to generate associations. We had interdependence issues with factories. When there are NOT NULLs on foreign keys and/or presence validations, etc. you can't just use `after(:create)` or `after(:build)` to set associations, and without those you can have issues with "Trait not registered" or "Factory not registered" with interdependent factory associations. 
+If you use Stepford::FactoryGirl (or deep_* methods in rspec) to automatically generate factories, you may not need to generate associations, because that sets them for you. If you do choose to use associations, note that these will likely create factories with interdependence issues. When there are NOT NULLs on foreign keys and/or presence validations, etc. you can't just use `after(:create)` or `after(:build)` to set associations, and without those you can have issues with "Trait not registered" or "Factory not registered". Later versions of FactoryGirl may make this easier, and be sure to see notes from Josh down in the troubleshooting section.
 
-However, if you don't have anything that complex or don't mind hand-editing the factories to try to fix issues, these might help.
+If you are ready to hand-edit to fix things, then copy paste stuff, rename it, etc. instead of just using Stepford::FactoryGirl (or deep_* methods in rspec), then keep reading.
 
 ####### Include Required Assocations
 
@@ -220,9 +256,39 @@ Currently uniqueness constraints are ignored and must be handled by FactoryGirl
 
     sequence(:username) {|n| "user#{n}" }
 
-###### Testing Factories
+##### Testing Factories
+
+See [Testing all Factories (with RSpec)][test_factories] in the FactoryGirl wiki.
+
+Here are a few rspecs that test the FactoryGirl factories and the Stepford deep_builds:
+
+    require 'spec_helper'
+    require 'stepford/factory_girl_rspec_helpers'
+
+    describe 'validate factories build' do
+      FactoryGirl.factories.each do |factory|
+        context "with factory for :#{factory.name}" do
+          subject { build(factory.name) }
+
+          it "is valid" do
+            subject.valid?.should be, subject.errors.full_messages
+          end
+        end
+      end
+    end
+
+    describe 'validate factories deep build' do
+      FactoryGirl.factories.each do |factory|
+        context "with factory for :#{factory.name}" do
+          subject { deep_build(factory.name) }
+
+          it "is valid" do
+            subject.valid?.should be, subject.errors.full_messages
+          end
+        end
+      end
+    end
 
-See [Testing all Factories (with RSpec)][test_factories] in the FG wiki.
 
 ##### Troubleshooting
 
@@ -279,7 +345,13 @@ or referring to created objects through associations, though he said multiple ne
     comment = FactoryGirl.create(:comment, :authored_by_post_author)
     comment.author == comment.post.author # true
 
-This is the reason we wrote the Stepford Factory Girl Wrapper (see above). It automatically determines what needs to be set in what order and does create, create_list or build, build_list, etc. automatically.
+This is the reason we wrote the Stepford's Factory Girl proxy and helper rspec methods (see above). It automatically determines what needs to be set in what order and does create, create_list or build, build_list, etc. automatically.
+
+Unfortunately, it still has trouble with fkey constraints:
+
+    insert or update on table "foobars" violates foreign key constraint "some_foreign_key_contraint_name"
+
+Working on that.
 
 ### License
 

data/lib/stepford/circular_ref_checker.rb

@@ -67,19 +67,24 @@ module Stepford
 
     def self.check_associations(model_class, model_and_association_names = [])
       model_class.reflections.collect {|association_name, reflection|
-        next unless reflection.macro == :belongs_to
         puts "warning: #{model_class}'s association #{reflection.name}'s foreign_key was nil. can't check." unless reflection.foreign_key
         assc_sym = reflection.name.to_sym
         clas_sym = reflection.class_name.underscore.to_sym
         next_class = clas_sym.to_s.camelize.constantize
 
-        # if has a foreign key, then if NOT NULL or is a presence validate, the association is required and should be output. unfortunately this could mean a circular reference that will have to be manually fixed
         has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
-        # note: supports composite_primary_keys gem which stores primary_key as an array
-        foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
-        is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
+        required = false
+        if reflection.macro == :belongs_to
+          # note: supports composite_primary_keys gem which stores primary_key as an array
+          foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
+          is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
+          required = is_not_null_fkey_that_is_not_primary_key || has_presence_validator
+        else
+          # no nullable metadata on column if no foreign key in this table. we'd figure out the null requirement on the column if inspecting the child model
+          required = has_presence_validator
+        end
 
-        if is_not_null_fkey_that_is_not_primary_key || has_presence_validator
+        if required
           key = [model_class.table_name.to_sym, reflection.foreign_key.to_sym, next_class.table_name.to_sym]
           if model_and_association_names.include?(key)
             @@offenders << model_and_association_names.last unless @@offenders.include?(model_and_association_names.last)

data/lib/stepford/factory_girl.rb

@@ -1,7 +1,8 @@
 require 'factory_girl'
+require 'bigdecimal'
 
 module Stepford
-  # A wrapper for FactoryGirl that automatically recursively creates/builds/stubbed factories for null=false and/or presence validated associations.
+  # A proxy for FactoryGirl that automatically recursively creates/builds/stubbed factories for null=false and/or presence validated associations.
   #
   # Lets you specify method name and arguments/options to factory girl for associations.
   #
@@ -15,33 +16,24 @@ module Stepford
   #   }) do
   #     # the block you would send to FactoryGirl.create_list(:foo) would go here
   #   end
-  #
-  # If you have a circular reference (A has NOT NULL foreign key to B that has NOT NULL foreign key to C that has NOT NULL foreign key to A) in the
-  # schema, there is a workaround. First, prepopulate one of the models involved in the interdependency chain in the database as part of test setup,
-  # or if the ids are NOT NULL but are not foreign key constrained (i.e. if you can enter an invalid ID into the foreign key column, which implies possible 
-  # referential integrity issues) then you may be able to set them with an invalid id. Take that foreign id and then use the following to ensure
-  # that it will set that foreign id or instance. This is done at a global level which may not work for you, but it makes it convenient to put into
-  # your spec/spec_helper.rb, etc. For example, let's say your bar has NOT NULL on bartender_id and waiter_id, and in turn bartender and waiter
-  # both have a NOT NULL bar_id, and neither enforce foreign keys. Maybe you have preloaded data for waiter somehow as the id '123', but want to set bartender to
-  # just use an invalid id '-1', and you want to do it when they are on their second loop. You could use:
-  #
-  #   Stepford::FactoryGirl.stop_circular_refs = {
-  #      [:bartender, :bar] => {on_loop: 2, set_foreign_key_to: -1},
-  #      [:waiter, :bar] => {on_loop: 2, set_to: Waiter.find(123)},
-  #   }
   module FactoryGirl
     OPTIONS = [
+      :debug,
       :stop_circular_refs
     ]
 
     class << self
+      @@breadcrumbs = []
+
       OPTIONS.each{|o|attr_accessor o; define_method("#{o}?".to_sym){!!send("#{o}")}}
       def configure(&blk); class_eval(&blk); end
 
-      def method_missing(m, *args, &block)
-        puts "starting Stepford::FactoryGirl.#{m}(#{args.inspect})"
+      def handle_factory_girl_method(m, *args, &block)
+        @@breadcrumbs << [args[0]] if ::Stepford::FactoryGirl.debug?
+        #puts "#{'  ' * @@indent}handling Stepford::FactoryGirl.#{m}(#{args.inspect})" if ::Stepford::FactoryGirl.debug?
+        puts "#{@@breadcrumbs.join('>')} start" if ::Stepford::FactoryGirl.debug?
 
-        if [:build, :build_list, :build_stubbed, :create, :create_list].include?(m) && args && args.size > 0
+        if args && args.size > 0
           # call Stepford::FactoryGirl.* on any not null associations recursively
           model_sym = args[0].to_sym
           model_class = args[0].to_s.camelize.constantize
@@ -49,100 +41,68 @@ module Stepford
           args = args.dup # need local version because we'll be dup'ing the options hash to add things to set prior to create/build
           options = args.last
           if options.is_a?(Hash)
-            options = options.dup
+            # keep them separate
+            orig_options = options
+            options = deep_dup(options)
             args[(args.size - 1)] = options # need to set the dup'd options
           else
+            # keep them separate
+            orig_options = {}
             options = {}
             args << options # need to add options to set associations
           end
 
+          if ::Stepford::FactoryGirl.debug?
+            print "#{@@breadcrumbs.join('>')} args="
+            debugargs(args)
+            puts
+          end
+
           options[:with_factory_options] = {} unless options[:with_factory_options]
           with_factory_options = options[:with_factory_options]
-          with_factory_options[:circular_ref_counts] = {} unless with_factory_options[:circular_ref_counts]
+
           model_class.reflections.each do |association_name, reflection|
             assc_sym = reflection.name.to_sym
-            next if options[assc_sym] || options[reflection.foreign_key.to_sym]
+            next if options[assc_sym] || options[reflection.foreign_key.to_sym] # || reflection.macro != :belongs_to
+            
             clas_sym = reflection.class_name.underscore.to_sym
             has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(::ActiveModel::Validations::PresenceValidator)
             required = reflection.foreign_key ? (has_presence_validator || model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym}) : false
             orig_method_args_and_options = with_factory_options ? (with_factory_options[[clas_sym, assc_sym]] || with_factory_options[clas_sym]) : nil
-            # if has a foreign key, then if NOT NULL or is a presence validate, the association is required and should be output. unfortunately this could mean a circular reference that will have to be manually fixed
+            
             has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
-            # note: supports composite_primary_keys gem which stores primary_key as an array
-            foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
-            is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
-
-            if is_not_null_fkey_that_is_not_primary_key || has_presence_validator
-              circular_ref_key = [model_sym, assc_sym]
-              all_opts = ::Stepford::FactoryGirl.stop_circular_refs
-              if all_opts.is_a?(Hash) && all_opts.size > 0
-                circ_options = all_opts[circular_ref_key]
-                if circ_options
-                  #puts "::Stepford::FactoryGirl.stop_circular_refs[circular_ref_key]=#{circ_options.inspect}"
-                  count = with_factory_options[:circular_ref_counts][circular_ref_key]
-                  if count
-                    count += 1
-                  else
-                    count = 0
-                  end
-                  with_factory_options[:circular_ref_counts][circular_ref_key] = count
-                  if count > 100
-                    puts "over 100 loops. need to add this to Stepford::FactoryGirl.stop_circular_refs: {#{circular_ref_key.inspect} => {on_loop: 2, set_foreign_key_to: -1}}"
-                  end
-
-                  if count >= (circ_options[:on_loop] || 1)
-                    if circ_options.has_key?(:set_to)
-                      puts "Circular dependency override enabled. Returning :set_to instance to set as #{model_sym}.#{assc_sym}. instance was #{circ_options[:set_to]}"
-                      return circ_options[:set_to]
-                    elsif circ_options.has_key?(:set_foreign_key_to)
-                      # (CHILD) return hash to set on parent
-                      puts "Circular dependency override enabled. Returning :set_foreign_key_to to set as #{model_sym}.#{reflection.foreign_key}. value was '#{circ_options[:set_foreign_key_to]}'"
-                      return {reflection.foreign_key.to_sym => circ_options[:set_foreign_key_to]}
-                    end
-                  end
-                end
-              end
+            required = false
+            if reflection.macro == :belongs_to
+              # note: supports composite_primary_keys gem which stores primary_key as an array
+              foreign_key_is_also_primary_key = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}.include?(reflection.foreign_key.to_sym)
+              is_not_null_fkey_that_is_not_primary_key = model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym && !foreign_key_is_also_primary_key}
+              required = is_not_null_fkey_that_is_not_primary_key || has_presence_validator
+            else
+              # no nullable metadata on column if no foreign key in this table. we'd figure out the null requirement on the column if inspecting the child model
+              required = has_presence_validator
+            end
 
+            if required
+              @@breadcrumbs << ["a:#{assc_sym}"] if ::Stepford::FactoryGirl.debug?
               if orig_method_args_and_options
                 method_args_and_options = orig_method_args_and_options.dup
                 method_options = args.last
                 blk = method_options.is_a?(Hash) ? method_args_and_options.delete(:blk) : nil
                 if blk
-                  puts "FactoryGirl.__send__(#{method_args_and_options.inspect}, &blk)"
+                  #puts "#{'  ' * @@indent}FactoryGirl.__send__(#{method_args_and_options.inspect}, &blk)" if ::Stepford::FactoryGirl.debug?
                   options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options, &blk)
                 else
-                  puts "FactoryGirl.__send__(#{method_args_and_options.inspect})"
+                  #puts "#{'  ' * @@indent}FactoryGirl.__send__(#{method_args_and_options.inspect})" if ::Stepford::FactoryGirl.debug?
                   options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options)
                 end
               else
                 if reflection.macro == :has_many
-                  case m
-                  when :create, :create_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.create_list(clas_sym, 2, options)
-                  when :build, :build_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.build_list(clas_sym, 2, options)
-                  when :build_stubbed
-                    #TODO: need to test building something stubbed that has a PresenceValidator on a has_many
-                    options[assc_sym] = ::Stepford::FactoryGirl.build_stubbed(clas_sym, options)
-                  end                
+                  options[assc_sym] = ::Stepford::FactoryGirl.create_list(clas_sym, 2, orig_options)               
                 else
-                  case m
-                  when :create, :create_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.create(clas_sym, options)
-                  when :build, :build_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.build(clas_sym, options)
-                  when :build_stubbed
-                    options[assc_sym] = ::Stepford::FactoryGirl.build_stubbed(clas_sym, options)
-                  end
-
-                  # (PARENT) we passed this back as a hash which means that the child model needed to set foreign key on the parent model
-                  if options[assc_sym].is_a?(Hash)
-                    value = options.delete(assc_sym)
-                    options.merge!()
-                    puts "Overrode foreign key #{model_sym}.#{assc_sym} = #{value}"
-                  end
+                  options[assc_sym] = ::Stepford::FactoryGirl.create(clas_sym, orig_options)
                 end
               end
+              @@breadcrumbs.pop if ::Stepford::FactoryGirl.debug?
             end
           end
         end
@@ -150,9 +110,69 @@ module Stepford
         # clean-up before sending to FactoryGirl
         (args.last).delete(:with_factory_options) if args.last.is_a?(Hash)
 
-        puts "FactoryGirl.#{m}(#{args.inspect}) (via __send__)"
+        if ::Stepford::FactoryGirl.debug?
+          puts "#{@@breadcrumbs.join('>')} end"
+          puts
+          print "#{@@breadcrumbs.join('>')} FactoryGirl.#{m}("
+          debugargs(args)
+          puts ")"
+          puts
+          @@breadcrumbs.pop
+        end
+
         ::FactoryGirl.__send__(m, *args, &block)
       end
+
+      # switched to this from method_missing to avoid method trying to handle mistaken calls
+      def create(*args, &block); handle_factory_girl_method(:create, *args, &block); end
+      def create_list(*args, &block); handle_factory_girl_method(:create_list, *args, &block); end
+      def build(*args, &block); handle_factory_girl_method(:build, *args, &block); end
+      def build_list(*args, &block); handle_factory_girl_method(:build_list, *args, &block); end
+      def build_stubbed(*args, &block); handle_factory_girl_method(:build_stubbed, *args, &block); end
+      # pass everything else to FactoryGirl to try to handle (can't reflect in current version to find what it handles)
+      def method_missing(m, *args, &block); ::FactoryGirl.__send__(m, *args, &block); end
+
+      def deep_dup(o)
+        result = nil
+        if o.is_a?(Hash)
+          result = {}
+          o.keys.each do |key|
+            result[deep_dup(key)] = deep_dup(o[key])
+          end
+        elsif o.is_a?(Array)
+          result = []
+          o.each do |value|
+            result << deep_dup(value)
+          end
+        elsif [NilClass,FalseClass,TrueClass,Symbol,Numeric,Class,Module].any?{|c|o.is_a?(c)}
+          result = o
+        elsif o.is_a?(BigDecimal)
+          # ActiveSupport v3.2.8 checks duplicable? for BigDecimal by testing it, so we'll just try to dup the value itself
+          result = o
+          begin
+            result = o.dup
+          rescue TypeError
+            # can't dup
+          end
+        elsif o.is_a?(Object)
+          result = o.dup
+        else
+          result = o
+        end
+        result
+      end
+
+      def debugargs(args)
+        args.each do |arg|
+          if arg.is_a?(Hash)
+            print "{"
+            print arg.keys.collect{|key|"#{key} = (#{arg[key].class.name})"}.join(', ')
+            print "}"
+          else
+            print "#{arg.inspect},"
+          end
+        end
+      end
     end
   end
 end

data/lib/stepford/factory_girl_rspec_helpers.rb

@@ -4,7 +4,7 @@ module Stepford
   module FactoryGirlRspecHelpers
     [:create, :create_list, :build, :build_list, :build_stubbed].each do |s|
       class_eval %Q"
-        def #{s}(*args, &block)
+        def deep_#{s}(*args, &block)
           ::Stepford::FactoryGirl.#{s}(*args, &block)
         end
       " 

data/lib/stepford/version.rb

@@ -1,3 +1,3 @@
 module Stepford
-  VERSION = '0.9.3'
+  VERSION = '0.11.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stepford
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-09 00:00:00.000000000 Z
+date: 2012-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -43,7 +43,9 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A CLI to create starter FactoryGirl factories for all of your Rails models.
+description: Has deep_* methods for automating FactoryGirl creation with required
+  association trees and small tweaks, ActiveRecord circular required reference checker
+  CLI, and a nice flexible FactoryGirl factories code generator CLI.
 email:
 - garysweaver@gmail.com
 executables:
@@ -86,5 +88,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Autocreate FactoryGirl factories from models.
+summary: FactoryGirl becomes easier and automated.
 test_files: []