masa-iwasaki-factory_girl 1.2.1.1 → 1.2.3.1

data/README.rdoc

@@ -1,5 +1,5 @@
 = What this fork added to original factory_girl
-== Factory#find_or_create
+== Caching 
 By default, the association created by factory_girl is based on Factory#create. This means there would be twice creation for project_1 in the code shown below.
 
   # Factory definitions
@@ -26,9 +26,19 @@ By default, the association created by factory_girl is based on Factory#create.
     end
   end
 
-This fork added Factory#find_or_create. This method keeps an instance which has already created. This means you would not have the creation of a same factory and the code shown above turns green.
+This fork added @@instances to Factory::Proxy::Create. @@instances keeps instances which has already created. This means you would not have the creation of a same factory and the code shown above turns green. 
 
-This fork also changed default_strategy from create to find_or_create. This change affects the definitions written in some syntax. If you are using bluprint or sham syntax, you might need to use "Factory.create(factory_name)" explicityly instead of "Facotry(factory_name)". 
+== How to enable caching of instances
+At default, all instances will be cached.  But you can toggle this option by calling these methods:
+
+- Factory::Proxy::Create.disable_cache
+- Factory::Proxy::Create.enable_cache
+
+== Other changes
+These modification affects the definitions written in some syntax. 
+
+- If you are using bluprint or sham syntax, you might need to use "Factory.create(factory_name)" explicityly instead of "Facotry(factory_name)"
+- With generate syntas, Factory.generate will raise an exception as same as Factory.generate!
 
 = factory_girl
 
@@ -39,14 +49,13 @@ factory_girl is a fixtures replacement with a straightforward definition syntax,
 Github: http://github.com/thoughtbot/factory_girl/tree/master
 
 Gem:
-  gem install thoughtbot-factory_girl --source http://gems.github.com
+  gem install factory_girl --source http://gemcutter.org
 
-Note: if you install factory_girl using the gem from Github, you'll need this
+Note: if you install factory_girl using the gem from Gemcutter, you'll need this
 in your environment.rb if you want to use Rails 2.1+'s dependency manager:
 
-  config.gem "thoughtbot-factory_girl",
-             :lib    => "factory_girl",
-             :source => "http://gems.github.com"
+  config.gem "factory_girl", 
+			 :source => "http://gemcutter.org"
 
 == Defining factories
 
@@ -75,6 +84,8 @@ Each factory has a name and a set of attributes. The name is used to guess the c
 
 It is highly recommended that you have one factory for each class that provides the simplest set of attributes necessary to create an instance of that class. If you're creating ActiveRecord objects, that means that you should only provide attributes that are required through validations and that do not have defaults. Other factories can be created through inheritance to cover common scenarios for each class.
 
+Attempting to define multiple factories with the same name will raise an error.
+
 Factories can either be defined anywhere, but will automatically be loaded if they are defined in files at the following locations:
 
   test/factories.rb
@@ -112,7 +123,7 @@ The default strategy can be overriden:
 
   user = Factory(:user)
 
-No matter which startegy is used, it's possible to override the defined attributes by passing a hash:
+No matter which strategy is used, it's possible to override the defined attributes by passing a hash:
 
   # Build a User instance and override the first_name property
   user = Factory.build(:user, :first_name => 'Joe')
@@ -224,6 +235,41 @@ a particular factory:
     f.sequence(:email) {|n| "person#{n}@example.com" }
   end
 
+== Callbacks
+
+Factory_girl makes available three callbacks for injecting some code:
+
+* after_build  - called after a factory is built   (via Factory.build)
+* after_create - called after a factory is saved   (via Factory.create)
+* after_stub   - called after a factory is stubbed (via Factory.stub)  
+
+Examples:
+
+  # Define a factory that calls the generate_hashed_password method after it is built 
+  Factory.define :user do |u|
+    u.after_build { |user| do_something_to(user) } 
+  end
+
+Note that you'll have an instance of the user in the block.  This can be useful.
+
+You can also define multiple types of callbacks on the same factory:
+
+  Factory.define :user do |u|
+    u.after_build  { |user| do_something_to(user) } 
+    u.after_create { |user| do_something_else_to(user) }
+  end
+
+Factories can also define any number of the same kind of callback.  These callbacks will be executed in the order they are specified:
+
+  Factory.define :user do |u|
+    u.after_create { this_runs_first } 
+    u.after_create { then_this } 
+  end
+
+Calling Factory.create will invoke both after_build and after_create callbacks.  
+
+Also, like standard attributes, child factories will inherit (and can define additional) callbacks from their parent factory.
+
 == Alternate Syntaxes
 
 Users' tastes for syntax vary dramatically, but most users are looking for a common feature set. Because of this, factory_girl supports "syntax layers" which provide alternate interfaces. See Factory::Syntax for information about the various layers available.
@@ -250,6 +296,7 @@ factory_girl was written by Joe Ferris with contributions from several authors,
 * Jon Yurek
 * Josh Nichols
 * Josh Owens
+* Nate Sutton
 
 The syntax layers are derived from software written by the following authors:
 * Pete Yandell

data/Rakefile

@@ -6,9 +6,10 @@ require 'rcov/rcovtask'
 require 'date'
 
 require 'spec/rake/spectask'
+require 'cucumber/rake/task'
 
-desc 'Default: run the specs.'
-task :default => :spec
+desc 'Default: run the specs and features.'
+task :default => [:spec, :features]
 
 Spec::Rake::SpecTask.new do |t|
   t.spec_opts = ['--options', "spec/spec.opts"]
@@ -36,13 +37,14 @@ task :sync_docs => 'rdoc' do
 end
 
 spec = Gem::Specification.new do |s|
-  s.name        = %q{factory_girl}
-  s.version     = "1.2.0"
-  s.summary     = %q{factory_girl provides a framework and DSL for defining and
-                     using model instance factories.}
-  s.description = %q{factory_girl provides a framework and DSL for defining and
-                     using factories - less error-prone, more explicit, and
-                     all-around easier to work with than fixtures.}
+  s.name        = %q{masa-iwasaki-factory_girl}
+  s.version     = "1.2.3.1"
+  s.summary     = %q{factory_girl with singleton support}
+  s.description = %q{This forked factory_girl has been added a singleton 
+                     support. You can specify ':singleton => true' option
+                     on factory definition and an instance created by this
+                     definition will be an singleton instance.
+                    }
 
   s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'spec/**/*.rb']
   s.require_path = 'lib'
@@ -52,8 +54,9 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.rdoc"]
   s.rdoc_options = ['--line-numbers', "--main", "README.rdoc"]
 
-  s.authors = ["Joe Ferris"]
-  s.email   = %q{jferris@thoughtbot.com}
+  s.authors = ["Masatoshi Iwasaki"]
+  s.email   = %q{mstshiwasaki@gmail.com}
+  s.homepage = "http://github.com/masa-iwasaki/factory_girl"
 
   s.platform = Gem::Platform::RUBY
 end
@@ -72,3 +75,8 @@ task :gemspec do
     f.write spec.to_ruby
   end
 end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.fork = true
+  t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'progress')]
+end

data/lib/factory_girl.rb

@@ -1,4 +1,5 @@
 require 'active_support'
+require 'digest'
 require 'factory_girl/proxy'
 require 'factory_girl/proxy/build'
 require 'factory_girl/proxy/create'
@@ -9,6 +10,7 @@ require 'factory_girl/attribute'
 require 'factory_girl/attribute/static'
 require 'factory_girl/attribute/dynamic'
 require 'factory_girl/attribute/association'
+require 'factory_girl/attribute/callback'
 require 'factory_girl/sequence'
 require 'factory_girl/aliases'
 

data/lib/factory_girl/attribute/association.rb

@@ -3,6 +3,8 @@ class Factory
 
     class Association < Attribute  #:nodoc:
 
+      attr_reader :factory
+
       def initialize(name, factory, overrides)
         super(name)
         @factory   = factory

data/lib/factory_girl/attribute/callback.rb

@@ -0,0 +1,16 @@
+class Factory
+  class Attribute #:nodoc:
+
+    class Callback < Attribute  #:nodoc:
+      def initialize(name, block)
+        @name  = name.to_sym
+        @block = block
+      end
+
+      def add_to(proxy)
+        proxy.add_callback(name, @block)
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute/dynamic.rb

@@ -8,7 +8,7 @@ class Factory
       end
 
       def add_to(proxy)
-        value = @block.call(proxy)
+        value = @block.arity.zero? ? @block.call : @block.call(proxy)
         if Factory::Sequence === value
           raise SequenceAbuseError
         end

data/lib/factory_girl/factory.rb

@@ -4,13 +4,17 @@ class Factory
   class AssociationDefinitionError < RuntimeError
   end
   
+  # Raised when a callback is defined that has an invalid name
+  class InvalidCallbackNameError < RuntimeError
+  end
+
+  # Raised when a factory is defined with the same name as a previously-defined factory.
+  class DuplicateDefinitionError < RuntimeError
+  end
+
   class << self
     attr_accessor :factories #:nodoc:
 
-    # An array of used in find_or_create to keep AR instances created 
-    # by Proxy::Create
-    attr_accessor :instances
-
     # An Array of strings specifying locations that should be searched for
     # factory definitions. By default, factory_girl will attempt to require
     # "factories," "test/factories," and "spec/factories." Only the first
@@ -19,10 +23,10 @@ class Factory
   end
 
   self.factories = {}
-  self.instances = {}
   self.definition_file_paths = %w(factories test/factories spec/factories)
 
   attr_reader :factory_name #:nodoc:
+  attr_reader :singleton #:nodoc:
   attr_reader :attributes #:nodoc:
 
   # Defines a new factory that can be used by the build strategies (create and
@@ -52,8 +56,20 @@ class Factory
     if parent = options.delete(:parent)
       instance.inherit_from(Factory.factory_by_name(parent))
     end    
+    if singleton = options.delete(:singleton)
+      instance.singleton = true
+    end
+    if self.factories[instance.factory_name] 
+      raise DuplicateDefinitionError, "Factory already defined: #{name}"
+    end
+    
     self.factories[instance.factory_name] = instance
   end
+
+  # Call Proxy::Create.clear_caches
+  def self.clear_caches
+    ::Factory::Proxy::Create.clear_caches
+  end
   
   def class_name #:nodoc:
     @options[:class] || factory_name
@@ -64,13 +80,14 @@ class Factory
   end
   
   def default_strategy #:nodoc:
-    @options[:default_strategy] || :find_or_create
+    @options[:default_strategy] || :create
   end
 
   def initialize (name, options = {}) #:nodoc:
     assert_valid_options(options)
     @factory_name = factory_name_for(name)
     @options      = options      
+    @singleton    = false
     @attributes   = []
   end
   
@@ -189,6 +206,25 @@ class Factory
     add_attribute(name) { s.next }
   end
   
+  def after_build(&block)
+    callback(:after_build, &block)
+  end
+  
+  def after_create(&block)
+    callback(:after_create, &block)
+  end
+  
+  def after_stub(&block)
+    callback(:after_stub, &block)
+  end
+  
+  def callback(name, &block)
+    unless [:after_build, :after_create, :after_stub].include?(name.to_sym)
+      raise InvalidCallbackNameError, "#{name} is not a valid callback name. Valid callback names are :after_build, :after_create, and :after_stub"
+    end
+    @attributes << Attribute::Callback.new(name.to_sym, block)
+  end
+  
   # Generates and returns a Hash of attributes from this factory. Attributes
   # can be individually overridden by passing in a Hash of attribute => value
   # pairs.
@@ -241,37 +277,7 @@ class Factory
   def self.create (name, overrides = {})
     factory_by_name(name).run(Proxy::Create, overrides)
   end
-
-  # Returns an object if an instance from this factory was already created. 
-  # Or call self.create and register an instance to the list of instances.
-  #
-  # Arguments:
-  # * name: +Symbol+ or +String+
-  #   The name of the factory that should be used.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this instance.
-  #
-  # Returns: +Object+
-  # A saved instance of the class this factory generates, with generated
-  # attributes assigned.
-  def self.find_or_create(name, overrides = {})
-    if self.instances[name].nil?
-      self.instances[name] = self.create(name, overrides)
-    else
-      # Need reloading in terms of tearing down of fixtures on each test
-      begin
-        self.instances[name].reload
-      rescue  ActiveRecord::RecordNotFound
-        self.instances[name] = self.create(name, overrides)
-      rescue
-        # TODO: Better handling for other exceptions if it is needed
-        self.instances[name] = self.create(name, overrides)
-      end
-    end
-
-    self.instances[name]
-  end
-
+  
   # Generates and returns an object with all attributes from this factory
   # stubbed out. Attributes can be individually overridden by passing in a Hash
   # of attribute => value pairs.
@@ -287,7 +293,7 @@ class Factory
   def self.stub (name, overrides = {})
     factory_by_name(name).run(Proxy::Stub, overrides)
   end
-
+  
   # Executes the default strategy for the given factory. This is usually create,
   # but it can be overridden for each factory.
   #
@@ -325,15 +331,29 @@ class Factory
         attribute.add_to(proxy)
       end
     end
+    proxy.factory_name = factory_name
+    proxy.singleton = singleton
     proxy.result
   end
 
-  private
-
   def self.factory_by_name (name)
     factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
   end
 
+  def human_name(*args, &block)
+    if args.size == 0 && block.nil?
+      factory_name.to_s.gsub('_', ' ')
+    else
+      add_attribute(:human_name, *args, &block)
+    end
+  end
+
+  def associations
+    attributes.select {|attribute| attribute.is_a?(Attribute::Association) }
+  end
+
+  private
+
   def class_for (class_or_to_s)
     if class_or_to_s.respond_to?(:to_sym)
       Object.const_get(variable_name_to_class_name(class_or_to_s))
@@ -351,7 +371,7 @@ class Factory
   end
 
   def attribute_defined? (name)
-    !@attributes.detect {|attr| attr.name == name }.nil?
+    !@attributes.detect {|attr| attr.name == name && !attr.is_a?(Factory::Attribute::Callback) }.nil?
   end
 
   def assert_valid_options(options)
@@ -361,7 +381,7 @@ class Factory
     end
     assert_valid_strategy(options[:default_strategy]) if options[:default_strategy]
   end
-
+  
   def assert_valid_strategy(strategy)
     unless Factory::Proxy.const_defined? variable_name_to_class_name(strategy)
       raise ArgumentError, "Unknown strategy: #{strategy}"
@@ -381,14 +401,14 @@ class Factory
   def variable_name_to_class_name(name)
     name.to_s.
       gsub(/\/(.?)/) { "::#{$1.upcase}" }.
-    gsub(/(?:^|_)(.)/) { $1.upcase }
+      gsub(/(?:^|_)(.)/) { $1.upcase }
   end
 
   # From ActiveSupport
   def symbolize_keys(hash)
     hash.inject({}) do |options, (key, value)|
       options[(key.to_sym rescue key) || key] = value
-    options
+      options
     end
   end
 

data/lib/factory_girl/proxy.rb

@@ -1,6 +1,11 @@
 class Factory
 
   class Proxy #:nodoc:
+
+    attr_reader :callbacks
+    attr_accessor :factory_name
+    attr_accessor :singleton
+
     def initialize(klass)
     end
 
@@ -14,6 +19,20 @@ class Factory
     def associate(name, factory, attributes)
     end
 
+    def add_callback(name, block)
+      @callbacks ||= {}
+      @callbacks[name] ||= []
+      @callbacks[name] << block
+    end
+
+    def run_callbacks(name)
+      if @callbacks && @callbacks[name]
+        @callbacks[name].each do |block|
+          block.arity.zero? ? block.call : block.call(@instance)
+        end
+      end
+    end
+
     # Generates an association using the current build strategy.
     #
     # Arguments: