stepford 0.13.0 → 0.14.0

data/README.md

@@ -92,6 +92,30 @@ Then run:
 
     bundle install
 
+### Configuration
+
+You don't have to use a `config/stepford.rb`, but if you have one, it will load it as needed both in CLI and via helpers, etc.
+
+If you don't use the CLI, you can just put it into your `test/test_helper.rb`, `spec/spec_helper.rb`, or similar for the deep_* methods, and with the CLI you could just put it into a Rails environment file.
+
+Debug option:
+
+    Stepford::FactoryGirl.debug = true
+
+Make Stepford think that the schema looks different than it does to allow virtual attributes, etc.:
+
+    Stepford::FactoryGirl.column_overrides = {
+      [:bartender, :experience] => {null: false},
+      [:patron, :time_entered_bar] => {null: false},
+      [:patron, :some_virtual_attribute] => {null: false, virtual: true, type: :string, limit: 5} # if you specify a virtual attribute, be sure to include virtual: true and a valid type
+    }
+
+Override options are: `:virtual`, `:type`, `:limit`, `:default`, `:null`, `:precision`, and `:scale`. Each is equivalent to their [ActiveRecord column equivalents][column_meta].
+
+You can reconfigure it at runtime during tests if you'd like, and you can just call this if you want, but it doesn't have to be loaded this way. No magic involved, but it caches a little, so faster than just doing a `load`:
+
+    Stepford::FactoryGirl.load_config(pathname)
+
 ### Usage
 
 #### Require
@@ -123,22 +147,12 @@ But, you might want to specify traits, and certain attributes or associations or
 
 Put this in your `spec/spec_helper.rb`:
 
-    require 'stepford/factory_girl_rspec_helpers'
+    require 'stepford/factory_girl/rspec_helpers'
 
 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.:
 
     deep_create(:foo)
 
-##### Forcing Attributes and Associations
-
-If you want to force attributes and associations to be set, use the not_null configuration setting, or hand-edit the factories.rb:
-
-    # each entry looks like [:model_name, :association_or_column_name]
-    Stepford::FactoryGirl.not_null = [
-      [:bartender, :experience],
-      [:patron, :time_entered_bar],
-    ]
-
 ##### Cleaning Up
 
 If you just want to run rspec at command-line, want to be able to create in before hooks, and don't want to mess with database cleaner, here is some code that you can add to your spec_helper to remove all model instances.
@@ -328,7 +342,7 @@ See [Testing all Factories (with RSpec)][test_factories] in the FactoryGirl wiki
 Here is a version that tests the FactoryGirl factories and the Stepford deep_creates:
 
     require 'spec_helper'
-    require 'stepford/factory_girl_rspec_helpers'
+    require 'stepford/factory_girl/rspec_helpers'
 
     describe 'validate factories build' do
       FactoryGirl.factories.each do |factory|
@@ -407,6 +421,7 @@ or referring to created objects through associations, though he said multiple ne
 
 Copyright (c) 2012 Gary S. Weaver, released under the [MIT license][lic].
 
+[column_meta]: http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html#method-i-column
 [composite_primary_keys]: https://github.com/drnic/composite_primary_keys
 [test_factories]: https://github.com/thoughtbot/factory_girl/wiki/Testing-all-Factories-%28with-RSpec%29
 [factory_girl]: https://github.com/thoughtbot/factory_girl/

data/lib/stepford/circular_ref_checker.rb

@@ -76,7 +76,6 @@ module Stepford
       model_class.reflections.collect {|association_name, reflection|
         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
         
         begin
           next_class = reflection.class_name.constantize

data/lib/stepford/cli.rb

@@ -17,8 +17,8 @@ module Stepford
       # load Rails environment
       require './config/environment'
       # load FactoryGirl and generate factories
-      require 'stepford/factory_girl_generator'
-      exit Stepford::FactoryGirlGenerator.generate_factories(options) ? 0 : 1
+      require 'stepford/factory_girl/generator'
+      exit ::Stepford::FactoryGirl::Generator.generate_factories(options) ? 0 : 1
     end
 
     desc "circular", "check for circular refs"
@@ -28,9 +28,9 @@ module Stepford
       require './config/environment'
       # load FactoryGirl and generate factories
       require 'stepford/circular_ref_checker'
-      exit Stepford::CircularRefChecker.check_refs(options) ? 0 : 1
+      exit ::Stepford::CircularRefChecker.check_refs(options) ? 0 : 1
     end
   end
 end
 
-Stepford::CLI.start
+::Stepford::CLI.start

data/lib/stepford/column_representation.rb

@@ -0,0 +1,28 @@
+module Stepford
+  # Needed a column representation that would allow user to specify attributes that are used for sample data choice for virtual attributes
+  # e.g. if you have an object_id column in the schema, but in model you have virtual proxy attribute methods to set it like my_object_id/my_object_id=
+  # then you need a way to specify that it should set my_object_id= with a string vs. number, etc.
+  class ColumnRepresentation
+    attr_accessor :name, :type, :limit, :default, :null, :precision, :scale, :virtual
+
+    def initialize(args)
+      if args.is_a?(Symbol)
+        @name = args.to_sym
+      elsif !(args.nil?)
+        # assume initializing with column
+        # see: http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/TableDefinition.html#method-i-column
+        @name = args.name
+        @type = args.type
+        @limit = args.limit
+        @default = args.default
+        @null = args.null # should be called nullable, but using what Rails/AR calls it to be easier to work with as if were a "real" AR column
+        @precision = args.precision
+        @scale = args.scale
+      end
+    end
+
+    def merge_options(options)
+      options.each {|k,v|instance_variable_set("@#{k}", v)}
+    end
+  end
+end

data/lib/stepford/factory_girl.rb

@@ -1,213 +1 @@
-require 'factory_girl'
-require 'bigdecimal'
-
-module Stepford
-  # 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.
-  #
-  # 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
-    OPTIONS = [
-      :debug,
-      :not_null
-    ]
-
-    class << self
-      OPTIONS.each{|o|attr_accessor o; define_method("#{o}?".to_sym){!!send("#{o}")}}
-      def configure(&blk); class_eval(&blk); end
-
-      def handle_factory_girl_method(m, *args, &block)
-        
-        if args && args.size > 0
-          # call Stepford::FactoryGirl.* on any not null associations recursively
-          model_name = args[0]
-          begin
-            model_class = model_name.to_s.camelize.constantize
-          rescue => e
-            puts "Problem in #{model_name.to_s.camelize}" if model_name
-            raise e
-          end
-
-          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)
-            # 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
-
-          options[:with_factory_options] = {} unless options[:with_factory_options]
-          with_factory_options = options[:with_factory_options]
-          
-          orig_options[:nesting_breadcrumbs] = [] unless orig_options[:nesting_breadcrumbs]
-          breadcrumbs = orig_options[:nesting_breadcrumbs]
-          breadcrumbs << [args[0]]
-
-          orig_options[:to_reload] = [] unless orig_options[:to_reload]
-          to_reload = orig_options[:to_reload]
-            
-          if ::Stepford::FactoryGirl.debug?
-            puts "#{breadcrumbs.join('>')} start. args=#{debugargs(args)}"
-          end
-
-          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] # || 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
-            
-            has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
-            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 || Array.wrap(::Stepford::FactoryGirl.not_null).compact.include?([model_name.to_sym, assc_sym])
-              breadcrumbs << ["a:#{assc_sym}"]
-              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
-                begin
-                  if blk
-                    options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options, &blk)
-                  else
-                    options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options)
-                  end
-                  to_reload << options[assc_sym]
-                rescue => e
-                  puts "#{breadcrumbs.join('>')}: FactoryGirl.__send__(#{method_args_and_options.inspect}): #{e}#{::Stepford::FactoryGirl.debug? ? "\n#{e.backtrace.join("\n")}" : ''}"
-                  raise e
-                end
-              else
-                if reflection.macro == :has_many
-                  options[assc_sym] = ::Stepford::FactoryGirl.create_list(clas_sym, 2, orig_options)               
-                else
-                  options[assc_sym] = ::Stepford::FactoryGirl.create(clas_sym, orig_options)
-                end
-              end
-              breadcrumbs.pop
-            end
-          end
-        end
-
-        if defined?(breadcrumbs)
-          if ::Stepford::FactoryGirl.debug?
-            puts "#{breadcrumbs.join('>')} end"
-            puts "#{breadcrumbs.join('>')} FactoryGirl.#{m}(#{debugargs(args)})"
-          end
-          breadcrumbs.pop
-        end
-
-        # clean-up before sending to FactoryGirl
-        if args.last.is_a?(Hash)
-          (args.last).delete(:with_factory_options)
-          (args.last).delete(:nesting_breadcrumbs)
-          (args.last).delete(:to_reload)
-        end
-
-        begin
-          raise "#{breadcrumbs.join('>')} - Huh? args[0] was #{args[0]}. m=#{m.inspect}, args=#{args.inspect}" if args && args.size > 1 && !(args[0].is_a?(String) || args[0].is_a?(Symbol))
-          result = ::FactoryGirl.__send__(m, *args, &block)
-        rescue => e
-          puts "#{breadcrumbs.join('>')}: FactoryGirl.#{m}(#{args.inspect}): #{e}#{::Stepford::FactoryGirl.debug? ? "\n#{e.backtrace.join("\n")}" : ''}" if defined?(breadcrumbs)
-          raise e
-        end
-        
-        if args.last.is_a?(Hash) && defined?(breadcrumbs) && breadcrumbs.size > 0
-          # still handling association/subassociation
-          args.last[:nesting_breadcrumbs] = breadcrumbs
-          args.last[:to_reload] = to_reload
-          orig_options[:to_reload] << result
-        else
-          # ready to return the initially requested instances, so reload children with their parents, in reverse order added
-          orig_options[:to_reload].each do |i|
-            begin
-              i.reload
-            rescue => e
-              puts "#{i} reload failed: #{e}\n#{e.backtrace.join("\n")}" if ::Stepford::FactoryGirl.debug?
-            end
-          end
-        end
-
-        result
-      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)
-        result = []
-        args.each do |arg|
-          if arg.is_a?(Hash)
-            result << "{#{arg.keys.collect{|key|"#{key} = (#{arg[key].class.name})"}.join(', ')}}"
-          else
-            result << "#{arg.inspect},"
-          end
-        end
-        result.join('')
-      end
-    end
-  end
-end
+require 'stepford/factory_girl/methods'

data/lib/stepford/factory_girl/config.rb

@@ -0,0 +1,54 @@
+module Stepford
+  module FactoryGirl
+    OPTIONS = [:debug, :column_overrides, :config_loaded, :column_overrides_tree]
+
+    class << self
+      OPTIONS.each{|o|attr_accessor o; define_method("#{o}?".to_sym){!!send("#{o}")}}
+      def configure(&blk); class_eval(&blk); end
+
+      # Loads the configuration from config/stepford.rb or a specified pathname unless has already been loaded.
+      def load_config(pathname = nil)
+        if !(pathname || ::Stepford::FactoryGirl.config_loaded) || (pathname && ::Stepford::FactoryGirl.config_loaded.to_sym != pathname.to_sym)
+          begin
+            if pathname
+              # load without checking if exists to raise error if user-specified file is missing
+              force_configure(pathname)
+            else
+              pathname = Rails.root.join('config', 'stepford.rb').to_s
+              if File.exist?(pathname)
+                force_configure(pathname)
+              end
+            end
+          rescue => e
+            puts "Failed to load #{pathname}:\n#{e.message}#{e.backtrace.join("\n")}"
+          end
+        end
+      end
+
+      def force_configure(pathname)
+        load pathname
+        puts "Loaded #{pathname}"
+        ::Stepford::FactoryGirl.config_loaded = pathname   
+      end
+
+      def column_overrides=(args)
+        # to avoid a lot of processing overhead, we preprocess the arrays into a hash that would look ugly to the user, e.g.
+        # {:model_name => {:attribute_name => {options or just empty}}}
+        result = {}
+        args.each do |k,v|
+          if k.is_a?(Array) && k.size == 2 && v.is_a?(Hash)
+            table_columns = (result[k[0].to_sym] ||= {})
+            table_column_options = (table_columns[k[1].to_sym] ||= {})
+            table_column_options.merge(v)
+          else
+            puts "Ignoring bad Stepford::FactoryGirl.column_overrides array value: #{a.inspect}. Should look like [:model_name, :attribute_name, {}]. See documentation for information on defining options hash."
+          end
+        end if args
+        @column_overrides = args
+        @column_overrides_tree = result
+      end
+    end
+  end
+end
+
+::Stepford::FactoryGirl.load_config

data/lib/stepford/factory_girl/generator.rb

@@ -0,0 +1,198 @@
+require 'stepford/column_representation'
+require 'stepford/common'
+require 'stepford/factory_girl/config'
+
+module Stepford
+  module FactoryGirl
+    class Generator
+      def self.generate_factories(options={})
+        factories = {}
+        expected = {}
+        included_model_syms = options[:models] ? options[:models].split(',').collect{|s|s.strip.to_sym}.compact : nil
+        puts "Rails.root=#{Rails.root}"
+        Dir[Rails.root.join('app','models','*.rb').to_s].each do |filename|
+          model_name = File.basename(filename).sub(/.rb$/, '')
+          model_name_sym = model_name.to_sym
+          next if included_model_syms && !included_model_syms.include?(model_name_sym)
+          load filename
+          
+          begin
+            model_class = model_name.camelize.constantize
+          rescue => e
+            puts "Problem in #{model_name.camelize}"
+            raise e
+          end
+
+          next unless model_class.ancestors.include?(ActiveRecord::Base)
+          factory = (factories[model_name_sym] ||= [])
+          pkey_syms = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}
+          excluded_attribute_syms = [:updated_at, :created_at, :object_id]
+          excluded_attribute_syms_and_pkeys = pkey_syms + [:updated_at, :created_at, :object_id]
+          model_class.reflections.collect {|association_name, reflection|
+            (expected[reflection.class_name.underscore.to_sym] ||= []) << model_name_sym
+            fkey_sym = reflection.foreign_key.try(:to_sym)
+            excluded_attribute_syms_and_pkeys << fkey_sym if reflection.foreign_key && !(excluded_attribute_syms_and_pkeys.include?(fkey_sym))
+            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 == fkey_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 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
+            else
+              nil
+            end
+          }.compact.sort.each {|l|factory << l}
+
+          sequenceless_table = false
+          begin
+            sequenceless_table = true unless m.sequence_name
+          rescue => e
+            # bug in Rails 3.2.8, at least: undefined method `split' for nil:NilClass in activerecord-3.2.8/lib/active_record/connection_adapters/postgresql_adapter.rb:911:in `default_sequence_name'
+            sequenceless_table = true
+          end
+
+          model_column_name_sym_to_column_representation = {}
+          model_class.columns.each {|c|model_column_name_sym_to_column_representation[c.name.to_sym] = ::Stepford::ColumnRepresentation.new(c)}
+          ::Stepford::FactoryGirl.column_overrides_tree[model_name_sym].each do |column_override_attr_sym, column_override_options|
+            (model_column_name_sym_to_column_representation[column_override_attr_sym] ||= ::Stepford::ColumnRepresentation.new(column_override_attr_sym)).merge_options(column_override_options)
+          end if ::Stepford::FactoryGirl.column_overrides_tree[model_name_sym]
+              
+          model_column_name_sym_to_column_representation.values {|c|[c.name]}.each {|c|
+            # without a sequence, FactoryGirl will need to have sequences for pkeys
+            if sequenceless_table && excluded_attribute_syms.include?(c.name.to_sym)
+              factory << ::Stepford::Common.sequence_for(c)
+            elsif !excluded_attribute_syms_and_pkeys.include?(c.name.to_sym) && !(c.name.to_s.downcase.end_with?('_id') && options[:exclude_all_ids]) && (options[:attributes] || !c.null)
+              has_uniqueness_validator = model_class.validators_on(c.name.to_sym).collect{|v|v.class}.include?(ActiveRecord::Validations::UniquenessValidator)
+              if has_uniqueness_validator
+                #TODO: specialize for different data types
+                factory << ::Stepford::Common.sequence_for(c)
+              else
+                factory << "#{is_reserved?(c.name) ? 'self.' : ''}#{c.name} #{Stepford::Common.value_for(c)}"
+              end
+            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_sym|
+            unless factories[factory_name_sym]
+              puts "#{Rails.root.join('app','models',"#{factory_name_sym}.rb")} missing. Model(s) with associations to it: #{expected[factory_name_sym].sort.join(', ')}"
+              expected[factory_name_sym].each do |model_name|
+                (model_to_fixes_required[model_name_sym] ||= []) << factory_name_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_sym|
+              factory = factories[factory_name_sym]
+              write_factory(factory_name_sym, 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_sym|
+            factory = factories[factory_name_sym]
+            File.open(File.join(path,"#{factory_name_sym}.rb"), "w") do |f|
+              write_header(f, options)
+              write_factory(factory_name_sym, 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 = Rails.root.join('test','factories.rb')
+        if options[:path]
+          if options[:path].end_with?('.rb')
+            path = options[:path]
+          else
+            if options[:multiple]
+              path = options[:path]
+            else
+              path = Rails.root.join(options[:path],'factories.rb')
+            end
+          end
+        end
+        # convert Pathname to string
+        path.to_s
+      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
+end

data/lib/stepford/factory_girl/methods.rb

@@ -0,0 +1,205 @@
+require 'factory_girl'
+require 'bigdecimal'
+require 'stepford/factory_girl/config'
+
+module Stepford
+  # Automatically recursively creates/builds/stubbed associations using FactoryGirl.
+  #
+  # You can specify the method name and arguments/options to factory girl for the 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
+  # you could do that with:
+  #   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 handle_factory_girl_method(m, *args, &block)        
+        if args && args.size > 0
+          # call Stepford::FactoryGirl.* on any not null associations recursively
+          model_name = args[0]
+          begin
+            model_class = model_name.to_s.camelize.constantize
+          rescue => e
+            puts "Problem in #{model_name.to_s.camelize}" if model_name
+            raise e
+          end
+
+          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)
+            # 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
+
+          options[:with_factory_options] = {} unless options[:with_factory_options]
+          with_factory_options = options[:with_factory_options]
+          
+          orig_options[:nesting_breadcrumbs] = [] unless orig_options[:nesting_breadcrumbs]
+          breadcrumbs = orig_options[:nesting_breadcrumbs]
+          breadcrumbs << [args[0]]
+
+          orig_options[:to_reload] = [] unless orig_options[:to_reload]
+          to_reload = orig_options[:to_reload]
+            
+          if ::Stepford::FactoryGirl.debug?
+            puts "#{breadcrumbs.join('>')} start. args=#{debugargs(args)}"
+          end
+
+          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] # || 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
+            
+            has_presence_validator = model_class.validators_on(assc_sym).collect{|v|v.class}.include?(ActiveModel::Validations::PresenceValidator)
+            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 || Array.wrap(::Stepford::FactoryGirl.column_overrides).compact.include?([model_name.to_sym, assc_sym])
+              breadcrumbs << ["a:#{assc_sym}"]
+              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
+                begin
+                  if blk
+                    options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options, &blk)
+                  else
+                    options[assc_sym] = ::FactoryGirl.__send__(*method_args_and_options)
+                  end
+                  to_reload << options[assc_sym]
+                rescue => e
+                  puts "#{breadcrumbs.join('>')}: FactoryGirl.__send__(#{method_args_and_options.inspect}): #{e}#{::Stepford::FactoryGirl.debug? ? "\n#{e.backtrace.join("\n")}" : ''}"
+                  raise e
+                end
+              else
+                if reflection.macro == :has_many
+                  options[assc_sym] = ::Stepford::FactoryGirl.create_list(clas_sym, 2, orig_options)               
+                else
+                  options[assc_sym] = ::Stepford::FactoryGirl.create(clas_sym, orig_options)
+                end
+              end
+              breadcrumbs.pop
+            end
+          end
+
+          if defined?(breadcrumbs)
+            if ::Stepford::FactoryGirl.debug?
+              puts "#{breadcrumbs.join('>')} end"
+              puts "#{breadcrumbs.join('>')} FactoryGirl.#{m}(#{debugargs(args)})"
+            end
+            breadcrumbs.pop
+          end
+
+          # clean-up before sending to FactoryGirl
+          if args.last.is_a?(Hash)
+            (args.last).delete(:with_factory_options)
+            (args.last).delete(:nesting_breadcrumbs)
+            (args.last).delete(:to_reload)
+          end
+        end
+
+        begin
+          raise "#{breadcrumbs.join('>')} - Huh? args[0] was #{args[0]}. m=#{m.inspect}, args=#{args.inspect}" if args && args.size > 1 && !(args[0].is_a?(String) || args[0].is_a?(Symbol))
+          result = ::FactoryGirl.__send__(m, *args, &block)
+        rescue => e
+          puts "#{breadcrumbs.join('>')}: FactoryGirl.#{m}(#{args.inspect}): #{e}#{::Stepford::FactoryGirl.debug? ? "\n#{e.backtrace.join("\n")}" : ''}" if defined?(breadcrumbs)
+          raise e
+        end
+        
+        if args.last.is_a?(Hash) && defined?(breadcrumbs) && breadcrumbs.size > 0
+          # still handling association/subassociation
+          args.last[:nesting_breadcrumbs] = breadcrumbs
+          args.last[:to_reload] = to_reload
+          orig_options[:to_reload] << result
+        else
+          # ready to return the initially requested instances, so reload children with their parents, in reverse order added
+          orig_options[:to_reload].each do |i|
+            begin
+              i.reload
+            rescue => e
+              puts "#{i} reload failed: #{e}\n#{e.backtrace.join("\n")}" if ::Stepford::FactoryGirl.debug?
+            end
+          end
+        end
+
+        result
+      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)
+        result = []
+        args.each do |arg|
+          if arg.is_a?(Hash)
+            result << "{#{arg.keys.collect{|key|"#{key} = (#{arg[key].class.name})"}.join(', ')}}"
+          else
+            result << "#{arg.inspect},"
+          end
+        end
+        result.join('')
+      end
+    end
+  end
+end

data/lib/stepford/factory_girl/rspec_helpers.rb

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

data/lib/stepford/version.rb

@@ -1,3 +1,3 @@
 module Stepford
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stepford
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-13 00:00:00.000000000 Z
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -55,10 +55,13 @@ extra_rdoc_files: []
 files:
 - lib/stepford/circular_ref_checker.rb
 - lib/stepford/cli.rb
+- lib/stepford/column_representation.rb
 - lib/stepford/common.rb
+- lib/stepford/factory_girl/config.rb
+- lib/stepford/factory_girl/generator.rb
+- lib/stepford/factory_girl/methods.rb
+- lib/stepford/factory_girl/rspec_helpers.rb
 - lib/stepford/factory_girl.rb
-- lib/stepford/factory_girl_generator.rb
-- lib/stepford/factory_girl_rspec_helpers.rb
 - lib/stepford/version.rb
 - lib/stepford.rb
 - Rakefile

data/lib/stepford/factory_girl_generator.rb

@@ -1,184 +0,0 @@
-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")
-        
-        begin
-          model_class = model_name.camelize.constantize
-        rescue => e
-          puts "Problem in #{model_name.camelize}"
-          raise e
-        end
-
-        next unless model_class.ancestors.include?(ActiveRecord::Base)
-        factory = (factories[model_name.to_sym] ||= [])
-        pk_syms = Array.wrap(model_class.primary_key).collect{|pk|pk.to_sym}
-        excluded_attributes = pk_syms + [:updated_at, :created_at, :object_id]
-        model_class.reflections.collect {|association_name, reflection|
-          (expected[reflection.class_name.underscore.to_sym] ||= []) << model_name
-          fkey_sym = reflection.foreign_key.try(:to_sym)
-          excluded_attributes << fkey_sym if reflection.foreign_key && !(excluded_attributes.include?(fkey_sym))
-          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 == fkey_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 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
-          else
-            nil
-          end
-        }.compact.sort.each {|l|factory << l}
-
-        sequenceless_table = false
-        begin
-          sequenceless_table = true unless m.sequence_name
-        rescue => e
-          # bug in Rails 3.2.8, at least: undefined method `split' for nil:NilClass in activerecord-3.2.8/lib/active_record/connection_adapters/postgresql_adapter.rb:911:in `default_sequence_name'
-          sequenceless_table = true
-        end
-
-        model_class.columns.sort_by {|c|[c.name]}.each {|c|
-          # intentional not checking excluded_attributes/exclude_all_ids when sequenceless. it needs these for create to work.
-          if sequenceless_table && pk_syms.include?(c.name.to_sym)
-            factory << Stepford::Common.sequence_for(c)
-          elsif !excluded_attributes.include?(c.name.to_sym) && !(c.name.to_s.downcase.end_with?('_id') && options[:exclude_all_ids]) && (options[:attributes] || !c.null)
-            has_uniqueness_validator = model_class.validators_on(c.name.to_sym).collect{|v|v.class}.include?(ActiveRecord::Validations::UniquenessValidator)
-            if has_uniqueness_validator
-              #TODO: specialize for different data types
-              factory << Stepford::Common.sequence_for(c)
-            else
-              factory << "#{is_reserved?(c.name) ? 'self.' : ''}#{c.name} #{Stepford::Common.value_for(c)}"
-            end
-          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[:multiple]
-            path = options[:path]
-          else
-            path = File.join(options[:path],'factories.rb')
-          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

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