stepford 0.6.0 → 0.7.0

data/README.md

@@ -1,7 +1,26 @@
 Stepford
 =====
 
-Stepford is a CLI to create starter [Factory Girl][factory_girl] factories for all of your Rails models, e.g.
+Stepford is a wrapper and generator for FactoryGirl to automate stuff and make it easier to use.
+
+Stepford::FactoryGirl automatically recursively creates/builds/stubbed factories for null=false and/or presence validated associations. It also lets you specify method name and arguments/options to factory girl for associations.
+
+e.g. if the following is required:
+* Bar has a required association called house_special which uses the :beer factory, and we have a block we want to send into it
+* Beer has specials that you want to build as a list of 3 using the :tuesday_special_offer factory
+
+then you could set that up like this:
+
+    Stepford::FactoryGirl.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(:foo) would go here
+    end
+
+The `Stepford` CLI command will generate your factories.rb or multiple factory files for you.
+
+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:
 
     require 'factory_girl_rails'
 
@@ -23,6 +42,8 @@ Stepford is a CLI to create starter [Factory Girl][factory_girl] factories for a
 
     end
 
+and also let
+
 ### Setup
 
 In your Rails 3+ project, add this to your Gemfile:
@@ -39,7 +60,64 @@ Then run:
 
 ### Usage
 
-#### Factory Girl
+#### Factory Girl Wrapper
+
+##### Standard
+
+Stepford::FactoryGirl acts just like FactoryGirl, but it goes through all the null=false associations in the factory and/or its presence validated associations and attempts to create/build/build_stub depending on what you called originally, but also lets you pass in an `:with_factory_options` that can contain a hash of factory name symbols to the arguments and block you'd pass to it. You specify the block using a `:blk` option with a proc/lambda (probably a lambda) to use in that method.
+
+If you don't specify options, it's easy. If Foo requires Bar and Bar requires a list of Foobars and a Barfoo, and you have factories for each of those, you'd only have to do:
+
+    Stepford::FactoryGirl.create_list(:foo, 5)
+
+and that would create a list of 5 Foos, that each have a Bar, where each Bar has a list of 2 Foobars and a Barfoo. Easy!
+
+But, you might want to specify traits, and certain attributes or associations or a block or different methods to use. That's pretty easy, too. Let's say you only need to tweak bar and foobar on each item, but the rest gets created as it would with just `Stepford::FactoryGirl.create_list`, so if you wanted to create 5 with two traits `:fancy` and `:light` and only build the bar and build bar's foobar as a stub:
+
+    Stepford::FactoryGirl.create_list(:foo, 5, :fancy, :light, with_factory_options: {
+      bar: [:build, :bar],
+      foobar: [:build_stubbed, :foobar]
+    }) do
+      # any block you would send to FactoryGirl.create_list(:foo) would go here
+    end
+
+##### Cached
+
+In your Gemfile:
+
+    require 'factory_girl-cache'
+
+Then:
+
+    bundle install
+
+In your `spec/spec_helper.rb`, add:
+
+    require 'stepford/factory_girl_cache'
+
+It works just about the same as `Stepford::FactoryGirl` except it is called `Stepford::FactoryGirlCache` and acts more like `FactoryGirlCache`.
+
+##### RSpec Helpers
+
+`Stepford::FactoryGirl` and `Stepford::FactoryGirlCache` are a lot to type.
+
+Instead 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.):
+
+    create(:foo)
+
+For the cached version, add this to `spec/spec_helper.rb`:
+
+    require 'stepford/factory_girl_cache_rspec_helpers'
+
+Then you can just use `cache_create`, `cache_create_list`, `cache_build`, `cache_build_list`, or `cache_build_stubbed` in your rspec tests (`cache_create` becomes a shortcut for `::Stepford::FactoryGirlCache.create`, etc.):
+
+    cache_create(:foo)
+
+#### Factory Girl CLI
 
 ##### How NOT NULL, and Other Database Constraints and Active Record Validations Are Handled
 
@@ -89,7 +167,11 @@ If associations are deemed broken, it will output proposed changes.
 
 If working with a legacy schema, you may have models with foreign_key columns that you don't have associations defined for in the model. If that is the case, we don't want to assign arbitrary integers to them and try to create a record. If that is the case, try `--exclude-all-ids`, which will exclude those ids as attributes defined in the factories and you can add associations as needed to get things working.
 
-##### Singleton Values
+##### Ignored Required Assocations
+
+With `--ignore-required-associations` it won't include NOT NULL foreign key associations or presence validated associations by default.
+
+##### Cache Associations
 
 Use `--cache-associations` to store and use factories to avoid 'stack level too deep' errors.
 

data/lib/stepford/cli.rb

@@ -12,13 +12,14 @@ module Stepford
     method_option :attributes, :desc => "Include all attributes except foreign keys and primary keys, not just those that are required due to ActiveRecord presence validation or column not null restriction", :type => :boolean
     method_option :attribute_traits, :desc => "Include traits for attributes that would be output with --attributes that wouldn't be otherwise when --attributes is not specified", :type => :boolean
     method_option :association_traits, :desc => "Include traits for associations that would be output with --associations that wouldn't be otherwise when --associations is not specified", :type => :boolean
-    method_option :cache_associations, :desc => "Use singleton values to avoid 'stack level too deep' circular reference(s)", :type => :boolean    
+    method_option :cache_associations, :desc => "Use singleton values to avoid 'stack level too deep' circular reference(s)", :type => :boolean
+    method_option :ignore_required_associations, :desc => "Won't include NOT NULL foreign key associations or presence validated associations by default", :type => :boolean
     def factories()
       # load Rails environment
       require './config/environment'
       # load FactoryGirl and generate factories
-      require 'stepford/factory_girl'
-      exit Stepford::FactoryGirl.generate_factories(options) ? 0 : 1
+      require 'stepford/factory_girl_generator'
+      exit Stepford::FactoryGirlGenerator.generate_factories(options) ? 0 : 1
     end
   end
 end

data/lib/stepford/factory_girl.rb

@@ -1,169 +1,92 @@
-require 'stepford/common'
+require 'factory_girl'
 
 module Stepford
-  class FactoryGirl
-    def self.generate_factories(options={})
-      factories = {}
-      expected = {}
-      included_models = options[:models] ? options[:models].split(',').collect{|s|s.strip}.compact : nil
-      Dir[File.join('app','models','*.rb').to_s].each do |filename|
-        model_name = File.basename(filename).sub(/.rb$/, '')
-        next if included_models && !included_models.include?(model_name)
-        load File.join('app','models',"#{model_name}.rb")
-        model_class = model_name.camelize.constantize
-        next unless model_class.ancestors.include?(ActiveRecord::Base)
-        factory = (factories[model_name.to_sym] ||= [])
-        excluded_attributes = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym} + [:updated_at, :created_at]
-        association_lines = model_class.reflections.collect {|association_name, reflection|
-          (expected[reflection.class_name.underscore.to_sym] ||= []) << model_name
-          excluded_attributes << reflection.foreign_key.to_sym if reflection.foreign_key
-          assc_sym = reflection.name.to_sym
-          clas_sym = reflection.class_name.underscore.to_sym
-          # 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)
-          required = reflection.foreign_key ? (has_presence_validator || model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym}) : false
-          should_be_trait = !(options[:associations] || required) && options[:association_traits]
-          if options[:associations] || required || should_be_trait
-            if options[:cache_associations]
-              if reflection.macro == :has_many
-                # 
-                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}after(:create) do |user, evaluator|; #{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym} = FactoryGirlCache.create_list(#{clas_sym.inspect}#{clas_sym == assc_sym ? '' : ", #{assc_sym.inspect}"}, 2); end#{should_be_trait ? '; end' : ''}"
-              else
-                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}before(:build) do |user, evaluator|; #{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym} = FactoryGirlCache.create(#{clas_sym.inspect}#{clas_sym == assc_sym ? '' : ", #{assc_sym.inspect}"}); end#{should_be_trait ? '; end' : ''}"
-              end
-            else
-              if reflection.macro == :has_many
-                # In factory girl v4.1.0:
-                # create_list must be done in an after(:create) or you get Trait not registered or Factory not registered errors.
-                # this means that validators that verify presence or size > 0 in a association list will not work with this method, and you'll need to
-                # use build, not create: http://stackoverflow.com/questions/11209347/has-many-with-at-least-two-entries
-                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || has_presence_validator ? '' : '#'}after(:create) do |user, evaluator|; FactoryGirl.create_list #{clas_sym.inspect}, 2; end#{should_be_trait ? '; end' : ''}#{should_be_trait ? '' : ' # commented to avoid circular reference'}"
-              elsif assc_sym != clas_sym
-                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || reflection.macro == :belongs_to || has_presence_validator ? '' : '#'}association #{assc_sym.inspect}#{assc_sym != clas_sym ? ", factory: #{clas_sym.inspect}" : ''}#{should_be_trait ? '; end' : ''}#{should_be_trait || reflection.macro == :belongs_to ? '' : ' # commented to avoid circular reference'}"
-              else
-                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || reflection.macro == :belongs_to || has_presence_validator ? '' : '#'}#{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym}#{should_be_trait ? '; end' : ''}#{should_be_trait || reflection.macro == :belongs_to ? '' : ' # commented to avoid circular reference'}"
-              end
-            end
-          else
-            nil
-          end
-        }.compact.sort.each {|l|factory << l}
-        model_class.columns.sort_by {|c|[c.name]}.each {|c|
-          if !excluded_attributes.include?(c.name.to_sym) && !(c.name.downcase.end_with?('_id') && options[:exclude_all_ids]) && (options[:attributes] || !c.null)
-            factory << "#{c.name} #{Stepford::Common.value_for(c)}"
-          elsif options[:attribute_traits]
-            if c.type == :boolean
-              factory << "trait #{c.name.underscore.to_sym.inspect} do; #{c.name} true; end"
-              factory << "trait #{"not_#{c.name.underscore}".to_sym.inspect} do; #{c.name} false; end"
-            else
-              factory << "trait #{"with_#{c.name.underscore}".to_sym.inspect} do; #{c.name} #{Stepford::Common.value_for(c)}; end"
-            end
-          end
-        }
-      end
-
-      if options[:associations] || options[:validate_associations]
-        failed = false
-        model_to_fixes_required = {}
-        expected.keys.sort.each do |factory_name|
-          unless factories[factory_name.to_sym]
-            puts "#{File.join('app','models',"#{factory_name}.rb")} missing. Model(s) with associations to it: #{expected[factory_name].sort.join(', ')}"
-            expected[factory_name].each do |model_name|
-              (model_to_fixes_required[model_name.to_sym] ||= []) << factory_name.to_sym
-            end
-            failed = true
-          end
-        end
-        model_to_fixes_required.keys.each do |model_to_fix|
-          puts ""
-          puts "In #{model_to_fix}:"
-          model_to_fixes_required[model_to_fix].each do |fix|
-            puts "- comment/remove/fix broken association to #{fix}"
-          end
-        end
-        return false if failed
-      end
-
-      path = get_factories_rb_pathname(options)
-      
-      if path.end_with?('.rb')
-        dirpath = File.dirname(path)
-        unless File.directory?(dirpath)
-          puts "Please create this directory first: #{dirpath}"
-          return false
-        end
-
-        File.open(path, "w") do |f|
-          write_header(f, options)           
-          factories.keys.sort.each do |factory_name|
-            factory = factories[factory_name]
-            write_factory(factory_name, factory, f)
-          end
-          write_footer(f)
-        end
-      else
-        unless File.directory?(path)
-          puts "Please create this directory first: #{path}"
-          return false
-        end
-
-        factories.keys.sort.each do |factory_name|
-          factory = factories[factory_name]
-          File.open(File.join(path,"#{factory_name}.rb"), "w") do |f|
-            write_header(f, options)
-            write_factory(factory_name, factory, f)
-            write_footer(f)
-          end
+  # A wrapper 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.
+  #
+  # e.g. if the following is required:
+  # * Bar has a required association called house_special which uses the :beer factory, and we have a block we want to send into it
+  # * Beer has specials that you want to build as a list of 3 using the :tuesday_special_offer factory
+  # then you could set that up like this:
+  #   Stepford::FactoryGirl.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
+  #     # the block you would send to FactoryGirl.create_list(:foo) would go here
+  #   end
+  module FactoryGirl
+    class << self
+      def method_missing(m, *args, &block)
+        puts "Stepford::FactoryGirl.#{m}(#{args.inspect})"
+        stepford_command_options = {}
+        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
+          args[(args.size - 1)] = options # need to set the dup'd options
+          with_factory_options = options.delete(:with_factory_options)
+          stepford_command_options = (with_factory_options ? {with_factory_options: with_factory_options} : {})
+        else
+          options = {}
+          args << options # need to add options to set associations
         end
-      end
-
-      return true
-    end
 
-    private
-
-    def self.is_reserved?(s)
-      # from http://stackoverflow.com/questions/6461303/built-in-way-to-determine-whether-a-string-is-a-ruby-reserved-word/6461673#6461673
-      %w{__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield}.include? s.to_s
-    end
+        if [:build, :build_list, :build_stubbed, :create, :create_list].include?(m) && args && args.size > 0
+          # key in the with_factory_options is association class symbol OR [association class symbol, association name symbol]
+          # value is *args (array and possible hash)
+          key_to_method_args_and_options = stepford_command_options[:with_factory_options]
 
-    def self.get_factories_rb_pathname(options)
-      path = File.join('test','factories.rb')
-      if options[:path]
-        if options[:path].end_with?('.rb')
-          path = options[:path]
-        else
-          if options[:single]
-            path = File.join(options[:path],'factories.rb')
-          else
-            path = options[:path]
+          # call Stepford::FactoryGirl.* on any not null associations recursively
+          model_class = args[0].to_s.camelize.constantize
+          model_class.reflections.each do |association_name, reflection|
+            assc_sym = reflection.name.to_sym
+            next if options[assc_sym]
+            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 = key_to_method_args_and_options ? (key_to_method_args_and_options[[clas_sym, assc_sym]] || key_to_method_args_and_options[clas_sym]) : nil
+            if required || orig_method_args_and_options
+              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)"
+                  options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options, &blk)
+                else
+                  puts "FactoryGirl.__send__(#{method_args_and_options.inspect})"
+                  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, stepford_command_options])
+                  when :build, :build_list
+                    options[assc_sym] = ::Stepford::FactoryGirl.build_list(*[clas_sym, 2, stepford_command_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, stepford_command_options])
+                  end                
+                else
+                  case m
+                  when :create, :create_list
+                    options[assc_sym] = ::Stepford::FactoryGirl.create(*[clas_sym, stepford_command_options])
+                  when :build, :build_list
+                    options[assc_sym] = ::Stepford::FactoryGirl.build(*[clas_sym, stepford_command_options])
+                  when :build_stubbed
+                    options[assc_sym] = ::Stepford::FactoryGirl.build_stubbed(*[clas_sym, stepford_command_options])
+                  end
+                end
+              end
+            end
           end
         end
-      end
-      path
-    end
 
-    def self.write_header(f, options)
-      f.puts 'require \'factory_girl_rails\''
-      f.puts 'require \'factory_girl-cache\'' if options[:cache_associations]
-      f.puts ''
-      f.puts '# original version autogenerated by Stepford: https://github.com/garysweaver/stepford'
-      f.puts ''
-      f.puts 'FactoryGirl.define do'
-      f.puts '  '
-    end
-    
-    def self.write_factory(factory_name, factory, f)
-      f.puts "  factory #{factory_name.inspect} do"
-      factory.each do |line|
-        f.puts "    #{line}"
+        puts "FactoryGirl.__send__(#{([m] + Array.wrap(args)).inspect}, &block)"        
+        ::FactoryGirl.__send__(m, *args, &block)
       end
-      f.puts '  end'
-      f.puts '  '
-    end
-
-    def self.write_footer(f)
-      f.puts 'end'
     end
   end
 end

data/lib/stepford/factory_girl_cache.rb

@@ -0,0 +1,92 @@
+require 'factory_girl'
+
+module Stepford
+  # A wrapper 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.
+  #
+  # e.g. if the following is required:
+  # * Bar has a required association called house_special which uses the :beer factory, and we have a block we want to send into it
+  # * Beer has specials that you want to build as a list of 3 using the :tuesday_special_offer factory
+  # then you could set that up like this:
+  #   Stepford::FactoryGirl.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
+  #     # the block you would send to FactoryGirl.create_list(:foo) would go here
+  #   end
+  module FactoryGirlCache
+    class << self
+      def method_missing(m, *args, &block)
+        puts "Stepford::FactoryGirlCache.#{m}(#{args.inspect})"
+        stepford_command_options = {}
+        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
+          args[(args.size - 1)] = options # need to set the dup'd options
+          with_factory_options = options.delete(:with_factory_options)
+          stepford_command_options = (with_factory_options ? {with_factory_options: with_factory_options} : {})
+        else
+          options = {}
+          args << options # need to add options to set associations
+        end
+
+        if [:build, :build_list, :build_stubbed, :create, :create_list].include?(m) && args && args.size > 0
+          # key in the with_factory_options is association class symbol OR [association class symbol, association name symbol]
+          # value is *args (array and possible hash)
+          key_to_method_args_and_options = stepford_command_options[:with_factory_options]
+
+          # call Stepford::FactoryGirlCache.* on any not null associations recursively, and create an options hash with those as values, if not already passed in
+          model_class = args[0].to_s.camelize.constantize
+          model_class.reflections.each do |association_name, reflection|
+            assc_sym = reflection.name.to_sym
+            next if options[assc_sym]            
+            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 = key_to_method_args_and_options ? (key_to_method_args_and_options[[clas_sym, assc_sym]] || key_to_method_args_and_options[clas_sym]) : nil
+            if required || orig_method_args_and_options
+              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 "FactoryGirlCache.__send__(#{method_args_and_options.inspect}, &blk)"
+                  options[assc_sym] = ::FactoryGirlCache.__send__(*method_args_and_options, &blk)
+                else
+                  puts "FactoryGirlCache.__send__(#{method_args_and_options.inspect})"
+                  options[assc_sym] = ::FactoryGirlCache.__send__(*method_args_and_options)
+                end
+              else
+                if reflection.macro == :has_many
+                  case m
+                  when :create, :create_list
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.create_list(*[clas_sym, 2, stepford_command_options])
+                  when :build, :build_list
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.build_list(*[clas_sym, 2, stepford_command_options])
+                  when :build_stubbed
+                    #TODO: need to test building something stubbed that has a PresenceValidator on a has_many
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.build_stubbed(*[clas_sym, stepford_command_options])
+                  end                
+                else
+                  case m
+                  when :create, :create_list
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.create(*[clas_sym, stepford_command_options])
+                  when :build, :build_list
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.build(*[clas_sym, stepford_command_options])
+                  when :build_stubbed
+                    options[assc_sym] = ::Stepford::FactoryGirlCache.build_stubbed(*[clas_sym, stepford_command_options])
+                  end
+                end
+              end
+            end
+          end
+        end
+        
+        puts "FactoryGirlCache.__send__(#{([m] + Array.wrap(args)).inspect}, &block)"
+        ::FactoryGirlCache.__send__(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/stepford/factory_girl_cache_rspec_helpers.rb

@@ -0,0 +1,17 @@
+require 'stepford/factory_girl_cache'
+
+module Stepford
+  module FactoryGirlCacheRspecHelpers
+    [:create, :create_list, :build, :build_list, :build_stubbed].each do |s|
+      class_eval %Q"
+        def cache_#{s}(*args, &block)
+          ::Stepford::FactoryGirlCache.#{s}(*args, &block)
+        end
+      " 
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include ::Stepford::FactoryGirlCacheRspecHelpers
+end

data/lib/stepford/factory_girl_generator.rb

@@ -0,0 +1,166 @@
+require 'stepford/common'
+
+module Stepford
+  class FactoryGirlGenerator
+    def self.generate_factories(options={})
+      factories = {}
+      expected = {}
+      included_models = options[:models] ? options[:models].split(',').collect{|s|s.strip}.compact : nil
+      Dir[File.join('app','models','*.rb').to_s].each do |filename|
+        model_name = File.basename(filename).sub(/.rb$/, '')
+        next if included_models && !included_models.include?(model_name)
+        load File.join('app','models',"#{model_name}.rb")
+        model_class = model_name.camelize.constantize
+        next unless model_class.ancestors.include?(ActiveRecord::Base)
+        factory = (factories[model_name.to_sym] ||= [])
+        excluded_attributes = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym} + [:updated_at, :created_at, :object_id]
+        model_class.reflections.collect {|association_name, reflection|
+          (expected[reflection.class_name.underscore.to_sym] ||= []) << model_name
+          excluded_attributes << reflection.foreign_key.to_sym if reflection.foreign_key
+          assc_sym = reflection.name.to_sym
+          clas_sym = reflection.class_name.underscore.to_sym
+          # 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)
+          required = reflection.foreign_key ? (has_presence_validator || model_class.columns.any?{|c| !c.null && c.name.to_sym == reflection.foreign_key.to_sym}) : false
+          should_be_trait = !(options[:associations] || (!options[:ignore_required] && required)) && options[:association_traits]
+          if options[:associations] || (!options[:ignore_required_associations] && required) || should_be_trait
+            if options[:cache_associations]
+              if reflection.macro == :has_many
+                is_default_plural_association_name = (clas_sym.to_s.pluralize.to_sym == assc_sym)
+                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}after(:create) do |user, evaluator|; #{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym} = FactoryGirlCache.create_list(#{clas_sym.inspect}#{is_default_plural_association_name ? '' : ", #{assc_sym.inspect}"}, 2); end#{should_be_trait ? '; end' : ''}"
+              else
+                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym} = FactoryGirlCache.create(#{clas_sym.inspect}#{clas_sym == assc_sym ? '' : ", #{assc_sym.inspect}"})#{should_be_trait ? '; end' : ''}"
+              end
+            else
+              if reflection.macro == :has_many
+                # In factory girl v4.1.0:
+                # create_list must be done in an after(:create) or you get Trait not registered or Factory not registered errors.
+                # this means that validators that verify presence or size > 0 in a association list will not work with this method, and you'll need to
+                # use build, not create: http://stackoverflow.com/questions/11209347/has-many-with-at-least-two-entries
+                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || has_presence_validator ? '' : '#'}after(:create) do |user, evaluator|; FactoryGirl.create_list #{clas_sym.inspect}, 2; end#{should_be_trait ? '; end' : ''}#{should_be_trait ? '' : ' # commented to avoid circular reference'}"
+              elsif assc_sym != clas_sym
+                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || reflection.macro == :belongs_to || has_presence_validator ? '' : '#'}association #{assc_sym.inspect}#{assc_sym != clas_sym ? ", factory: #{clas_sym.inspect}" : ''}#{should_be_trait ? '; end' : ''}#{should_be_trait || reflection.macro == :belongs_to ? '' : ' # commented to avoid circular reference'}"
+              else
+                "#{should_be_trait ? "trait #{"with_#{assc_sym}".to_sym.inspect} do; " : ''}#{should_be_trait || reflection.macro == :belongs_to || has_presence_validator ? '' : '#'}#{is_reserved?(assc_sym) ? 'self.' : ''}#{assc_sym}#{should_be_trait ? '; end' : ''}#{should_be_trait || reflection.macro == :belongs_to ? '' : ' # commented to avoid circular reference'}"
+              end
+            end
+          else
+            nil
+          end
+        }.compact.sort.each {|l|factory << l}
+        model_class.columns.sort_by {|c|[c.name]}.each {|c|
+          if !excluded_attributes.include?(c.name.to_sym) && !(c.name.downcase.end_with?('_id') && options[:exclude_all_ids]) && (options[:attributes] || !c.null)
+            factory << "#{is_reserved?(c.name) ? 'self.' : ''}#{c.name} #{Stepford::Common.value_for(c)}"
+          elsif options[:attribute_traits]
+            if c.type == :boolean
+              factory << "trait #{c.name.underscore.to_sym.inspect} do; #{is_reserved?(c.name) ? 'self.' : ''}#{c.name} true; end"
+              factory << "trait #{"not_#{c.name.underscore}".to_sym.inspect} do; #{is_reserved?(c.name) ? 'self.' : ''}#{c.name} false; end"
+            else
+              factory << "trait #{"with_#{c.name.underscore}".to_sym.inspect} do; #{is_reserved?(c.name) ? 'self.' : ''}#{c.name} #{Stepford::Common.value_for(c)}; end"
+            end
+          end
+        }
+      end
+
+      if options[:associations] || options[:validate_associations]
+        failed = false
+        model_to_fixes_required = {}
+        expected.keys.sort.each do |factory_name|
+          unless factories[factory_name.to_sym]
+            puts "#{File.join('app','models',"#{factory_name}.rb")} missing. Model(s) with associations to it: #{expected[factory_name].sort.join(', ')}"
+            expected[factory_name].each do |model_name|
+              (model_to_fixes_required[model_name.to_sym] ||= []) << factory_name.to_sym
+            end
+            failed = true
+          end
+        end
+        model_to_fixes_required.keys.each do |model_to_fix|
+          puts ""
+          puts "In #{model_to_fix}:"
+          model_to_fixes_required[model_to_fix].each do |fix|
+            puts "- comment/remove/fix broken association to #{fix}"
+          end
+        end
+        return false if failed
+      end
+
+      path = get_factories_rb_pathname(options)
+      
+      if path.end_with?('.rb')
+        dirpath = File.dirname(path)
+        unless File.directory?(dirpath)
+          puts "Please create this directory first: #{dirpath}"
+          return false
+        end
+
+        File.open(path, "w") do |f|
+          write_header(f, options)           
+          factories.keys.sort.each do |factory_name|
+            factory = factories[factory_name]
+            write_factory(factory_name, factory, f)
+          end
+          write_footer(f)
+        end
+      else
+        unless File.directory?(path)
+          puts "Please create this directory first: #{path}"
+          return false
+        end
+
+        factories.keys.sort.each do |factory_name|
+          factory = factories[factory_name]
+          File.open(File.join(path,"#{factory_name}.rb"), "w") do |f|
+            write_header(f, options)
+            write_factory(factory_name, factory, f)
+            write_footer(f)
+          end
+        end
+      end
+
+      return true
+    end
+
+    private
+
+    def self.is_reserved?(s)
+      # modified from http://stackoverflow.com/questions/6461303/built-in-way-to-determine-whether-a-string-is-a-ruby-reserved-word/6461673#6461673
+      %w{__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield}.include? s.to_s
+    end
+
+    def self.get_factories_rb_pathname(options)
+      path = File.join('test','factories.rb')
+      if options[:path]
+        if options[:path].end_with?('.rb')
+          path = options[:path]
+        else
+          if options[:single]
+            path = File.join(options[:path],'factories.rb')
+          else
+            path = options[:path]
+          end
+        end
+      end
+      path
+    end
+
+    def self.write_header(f, options)
+      f.puts '# original version autogenerated by Stepford: https://github.com/garysweaver/stepford'
+      f.puts ''
+      f.puts 'FactoryGirl.define do'
+      f.puts '  '
+    end
+    
+    def self.write_factory(factory_name, factory, f)
+      f.puts "  factory #{factory_name.inspect} do"
+      factory.each do |line|
+        f.puts "    #{line}"
+      end
+      f.puts '  end'
+      f.puts '  '
+    end
+
+    def self.write_footer(f)
+      f.puts 'end'
+    end
+  end
+end

data/lib/stepford/factory_girl_rspec_helpers.rb

@@ -0,0 +1,17 @@
+require 'stepford/factory_girl'
+
+module Stepford
+  module FactoryGirlRspecHelpers
+    [:create, :create_list, :build, :build_list, :build_stubbed].each do |s|
+      class_eval %Q"
+        def #{s}(*args, &block)
+          ::Stepford::FactoryGirl.#{s}(*args, &block)
+        end
+      " 
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include ::Stepford::FactoryGirlRspecHelpers
+end

data/lib/stepford/version.rb

@@ -1,3 +1,3 @@
 module Stepford
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/stepford.rb

@@ -1,3 +1 @@
 require 'stepford/version'
-require 'stepford/common'
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stepford
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2012-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -54,6 +54,10 @@ files:
 - lib/stepford/cli.rb
 - lib/stepford/common.rb
 - lib/stepford/factory_girl.rb
+- lib/stepford/factory_girl_cache.rb
+- lib/stepford/factory_girl_cache_rspec_helpers.rb
+- lib/stepford/factory_girl_generator.rb
+- lib/stepford/factory_girl_rspec_helpers.rb
 - lib/stepford/version.rb
 - lib/stepford.rb
 - Rakefile