stepford 0.8.2 → 0.9.0

data/README.md

@@ -1,24 +1,30 @@
 Stepford
 =====
 
-Stepford is a wrapper and generator for [FactoryGirl][factory_girl] and [FactoryGirl Cache][factory_girl-cache] to automate stuff and make it easier to use.
+Stepford is an automatic required (non-null or presence validated) association resolving (creating/building/stubbing) wrapper and/or factory generator for [FactoryGirl][factory_girl].
 
-`Stepford::FactoryGirl` (and there is a short rspec helper) 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 FactoryGirl for associations.
+For example, with the rspec helper:
 
-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
+    create(:foo)
+
+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:
+
+    build(:foo)
+
+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 could set that up like this:
+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:
 
     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
+      # any block you would send to FactoryGirl.create_list(:bar) would go here
     end
 
-The Stepford CLI command will generate your factories.rb or multiple factory files for you.
+What if you have an existing schema, and you want to use FactoryGirl, but don't have any factories yet?
+
+The Stepford CLI allows you to 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:
 
@@ -58,13 +64,17 @@ Then run:
 
 ### Usage
 
-#### Factory Girl Wrapper
+#### Require
+
+Put this in your `test/spec_helper.rb`, `spec/spec_helper.rb`, or some other file used by your tests:
+
+    require 'stepford/factory_girl'
 
-##### Standard
+#### Stepford::FactoryGirl
 
 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:
+If you don't specify options, it's easy (note: it is even easier with the rspec helper- see below). 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)
 
@@ -79,45 +89,45 @@ But, you might want to specify traits, and certain attributes or associations or
       # 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
 
 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.):
+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.:
 
     create(:foo)
 
-For the cached version, add this to `spec/spec_helper.rb`:
+##### Stopping Circular References
 
-    require 'stepford/factory_girl_cache_rspec_helpers'
+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:
 
-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)
+    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)},
+    }
 
 #### CLI
 
-Stepford has a CLI generator to automatically create your factories file(s).
+Stepford has a CLI with a circular reference checker and a generator to automatically create your factories file(s).
+
+##### Refs
+
+Check ActiveRecord circular dependencies:
+
+    bundle exec stepford circular
+
+##### Factories
 
-##### Creating Factories
+###### Creating Factories
 
 Autogenerate `test/factories.rb` from all model files in `app/models`:
 
@@ -127,7 +137,7 @@ If you want one file per model, use `--multiple`. The default path is `test/fact
 
     bundle exec stepford factories --path spec/factories --multiple
 
-##### RSpec
+###### RSpec
 
 To put all of your factories into `spec/factories.rb`:
 
@@ -137,7 +147,7 @@ This also works:
 
     bundle exec stepford factories --path spec/support/factories.rb
 
-##### Specifying Models
+###### Specifying Models
 
 By default, Stepford processes all models found in `app/models`.
 
@@ -145,7 +155,7 @@ Specify `--models` and a comma-delimited list of models to only output the model
 
     bundle exec stepford factories --path spec/support/put_into_factories.rb --models foo,bar,foo_bar
 
-##### Traits
+###### Traits
 
 To generate traits for each attribute that would be included with `--attributes`, but isn't because `--attributes` is not specified:
 
@@ -155,47 +165,35 @@ To generate traits for each association that would be included with `--associati
 
     bundle exec stepford factories --association-traits
 
-##### Associations
+###### 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. 
 
 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.
 
-###### Include Required Assocations
+####### Include Required Assocations
 
 To include NOT NULL foreign key associations or presence validated associations:
 
     bundle exec stepford factories --include-required-associations
 
-###### Include All Associations
+####### Include All Associations
 
 To include all associations even if they aren't deemed to be required by not null ActiveRecord constraints defined in the model:
 
     bundle exec stepford factories --associations
 
-###### Checking Model Associations
+####### Checking Model Associations
 
 If `--associations` or `--validate-associations` is specified, Stepford first loads Rails and attempts to check your models for broken associations.
 
 If associations are deemed broken, it will output proposed changes.
 
-###### Caching Associations
-
-Use `--cache-associations` will use the [factory_girl-cache][factory_girl-cache] gem in the autogenerated factories, so you will need to include it also in your Gemfile:
-
-    gem 'factory_girl-cache'
-
-and
-
-    bundle install
-
-See the Factory Girl Wrapper section for a possibly more useful way to use FactoryGirlCache.
-
-##### No IDs
+###### No IDs
 
 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.
 
-##### How NOT NULL, and Other Database Constraints and Active Record Validations Are Handled
+###### How NOT NULL, and Other Database Constraints and Active Record Validations Are Handled
 
 If the ActiveRecord column `null` property for the attribute is true for the attribute or foreign key for the association, or if there is a presence validator for an attribute or foreign key for the association, then that attribute or association will be defined by the default factory.
 
@@ -203,7 +201,7 @@ 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 FG wiki.
 
@@ -268,7 +266,6 @@ This is the reason we wrote the Stepford Factory Girl Wrapper (see above). It au
 
 Copyright (c) 2012 Gary S. Weaver, released under the [MIT license][lic].
 
-[factory_girl-cache]: https://github.com/garysweaver/factory_girl-cache
 [test_factories]: https://github.com/thoughtbot/factory_girl/wiki/Testing-all-Factories-%28with-RSpec%29
 [factory_girl]: https://github.com/thoughtbot/factory_girl/
 [lic]: http://github.com/garysweaver/stepford/blob/master/LICENSE

data/lib/stepford/circular_ref_checker.rb

@@ -0,0 +1,76 @@
+module Stepford
+  class CircularRefChecker
+
+    @@model_and_association_names = []
+    @@level = 0
+    @@offenders = []
+    @@circles = []
+
+    # Check refs on all models or models specified in comma delimited list in options like:
+    #   Stepford.CircularRefChecker.check_refs models: 'user, post, comment'
+    def self.check_refs(options={})
+      models = []
+      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)
+        models << model_class
+      end
+
+      models.each do |model_class|
+        check_associations(model_class)
+      end
+
+      puts "Circles of shame:"
+      @@circles.sort.each do |c|
+        puts
+        puts "#{c}"
+      end
+      puts
+      puts
+      puts "Possible offenders. Either set nullable to true on these fields, or see if any of the fields above can be nullable:"
+      puts
+      @@offenders.sort.each do |c|
+        puts "#{c[0]}.#{c[1]}"
+      end
+
+      return (@@offenders.size == 0)
+    end
+
+    def self.check_associations(model_class)
+      @@level += 1
+
+      model_class.reflections.collect {|association_name, reflection|
+        @@model_and_association_names = [] if @@level == 1
+        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
+        if required
+          key = [model_class.to_s.underscore.to_sym, assc_sym]
+          if @@model_and_association_names.include?(key)
+            @@offenders << @@model_and_association_names.last unless @@offenders.include?(@@model_and_association_names.last)
+            # add to end
+            @@model_and_association_names << key
+            short = @@model_and_association_names.dup
+            # drop all preceding keys that have nothing to do with the circle
+            (short.index(key)).times {short.delete_at(0)}
+            string_representation = "#{short.collect{|b|"#{b[0]}.#{b[1]}"}.join(' -> ')}"
+            #puts string_representation
+            @@circles << string_representation.to_sym unless @@circles.include?(string_representation.to_sym)
+          else
+            @@model_and_association_names << key
+            check_associations(reflection.class_name.constantize)
+          end
+        end
+      }
+
+      @@level -= 1
+    end
+  end
+end

data/lib/stepford/cli.rb

@@ -12,7 +12,6 @@ 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 :include_required_associations, :desc => "Include NOT NULL foreign key associations or presence validated associations by default", :type => :boolean
     def factories()
       # load Rails environment
@@ -21,6 +20,16 @@ module Stepford
       require 'stepford/factory_girl_generator'
       exit Stepford::FactoryGirlGenerator.generate_factories(options) ? 0 : 1
     end
+
+    desc "circular", "check for circular refs"
+    method_option :models, :desc => "A comma delimited list of only the models you want to include"
+    def circular()
+      # load Rails environment
+      require './config/environment'
+      # load FactoryGirl and generate factories
+      require 'stepford/circular_ref_checker'
+      exit Stepford::CircularRefChecker.check_refs(options) ? 0 : 1
+    end
   end
 end
 

data/lib/stepford/factory_girl.rb

@@ -15,38 +15,88 @@ 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 = [
+      :stop_circular_refs
+    ]
+
     class << self
+      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 "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
+        puts "starting Stepford::FactoryGirl.#{m}(#{args.inspect})"
 
         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::FactoryGirl.* on any not null associations recursively
+          model_sym = args[0].to_sym
           model_class = args[0].to_s.camelize.constantize
+
+          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
+          else
+            options = {}
+            args << options # need to add options to set associations
+          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]
+            next if options[assc_sym] || options[reflection.foreign_key.to_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
+            orig_method_args_and_options = with_factory_options ? (with_factory_options[[clas_sym, assc_sym]] || with_factory_options[clas_sym]) : nil
             if required || orig_method_args_and_options
+              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
+
               if orig_method_args_and_options
                 method_args_and_options = orig_method_args_and_options.dup
                 method_options = args.last
@@ -62,21 +112,28 @@ module Stepford
                 if reflection.macro == :has_many
                   case m
                   when :create, :create_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.create_list(*[clas_sym, 2, stepford_command_options])
+                    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, stepford_command_options])
+                    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, stepford_command_options])
+                    options[assc_sym] = ::Stepford::FactoryGirl.build_stubbed(clas_sym, options)
                   end                
                 else
                   case m
                   when :create, :create_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.create(*[clas_sym, stepford_command_options])
+                    options[assc_sym] = ::Stepford::FactoryGirl.create(clas_sym, options)
                   when :build, :build_list
-                    options[assc_sym] = ::Stepford::FactoryGirl.build(*[clas_sym, stepford_command_options])
+                    options[assc_sym] = ::Stepford::FactoryGirl.build(clas_sym, options)
                   when :build_stubbed
-                    options[assc_sym] = ::Stepford::FactoryGirl.build_stubbed(*[clas_sym, stepford_command_options])
+                    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
                 end
               end
@@ -84,7 +141,10 @@ module Stepford
           end
         end
 
-        puts "FactoryGirl.__send__(#{([m] + Array.wrap(args)).inspect}, &block)"        
+        # 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__)"
         ::FactoryGirl.__send__(m, *args, &block)
       end
     end

data/lib/stepford/factory_girl_generator.rb

@@ -24,25 +24,16 @@ module Stepford
           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[:include_required_associations] && required)) && options[:association_traits]
           if options[:associations] || (options[:include_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
+            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
-              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
+              "#{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
           else
             nil

data/lib/stepford/version.rb

@@ -1,3 +1,3 @@
 module Stepford
-  VERSION = '0.8.2'
+  VERSION = '0.9.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stepford
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -51,11 +51,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/stepford/circular_ref_checker.rb
 - 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

data/lib/stepford/factory_girl_cache.rb

@@ -1,92 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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