factory_girl 3.2.0 → 3.3.0

data/lib/factory_girl/find_definitions.rb

@@ -1,5 +1,4 @@
 module FactoryGirl
-
   class << self
     # An Array of strings specifying locations that should be searched for
     # factory definitions. By default, factory_girl will attempt to require
@@ -7,9 +6,10 @@ module FactoryGirl
     # existing file will be loaded.
     attr_accessor :definition_file_paths
   end
+
   self.definition_file_paths = %w(factories test/factories spec/factories)
 
-  def self.find_definitions #:nodoc:
+  def self.find_definitions
     absolute_definition_file_paths = definition_file_paths.map {|path| File.expand_path(path) }
 
     absolute_definition_file_paths.uniq.each do |path|

data/lib/factory_girl/null_factory.rb

@@ -1,4 +1,5 @@
 module FactoryGirl
+  # @api private
   class NullFactory
     attr_reader :definition
 
@@ -6,7 +7,8 @@ module FactoryGirl
       @definition = Definition.new
     end
 
-    delegate :defined_traits, :callbacks, :attributes, :constructor, to: :definition
+    delegate :defined_traits, :callbacks, :attributes, :constructor,
+      :compiled_to_create, :compiled_constructor, to: :definition
 
     def compile; end
     def class_name; end

data/lib/factory_girl/null_object.rb

@@ -1,4 +1,5 @@
 module FactoryGirl
+  # @api private
   class NullObject < ::BasicObject
     def initialize(methods_to_respond_to)
       @methods_to_respond_to = methods_to_respond_to.map(&:to_s)

data/lib/factory_girl/reload.rb

@@ -1,10 +1,8 @@
 module FactoryGirl
   def self.reload
-    self.factories.clear
-    self.sequences.clear
-    self.traits.clear
-    self.strategies.clear
-    self.register_default_strategies
-    self.find_definitions
+    reset_configuration
+    register_default_strategies
+    register_default_callbacks
+    find_definitions
   end
 end

data/lib/factory_girl/sequence.rb

@@ -2,16 +2,17 @@ module FactoryGirl
 
   # Sequences are defined using sequence within a FactoryGirl.define block.
   # Sequence values are generated using next.
+  # @api private
   class Sequence
     attr_reader :name
 
-    def initialize(name, *args, &proc) #:nodoc:
+    def initialize(name, *args, &proc)
       @name    = name
       @proc    = proc
 
       options  = args.extract_options!
       @value   = args.first || 1
-      @aliases = options[:aliases] || []
+      @aliases = options.fetch(:aliases) { [] }
     end
 
     def next

data/lib/factory_girl/step_definitions.rb

@@ -1,3 +1,4 @@
+# @api private
 module FactoryGirlStepHelpers
   def convert_human_hash_to_attribute_hash(human_hash, associations = [])
     HumanHashToAttributeHash.new(human_hash, associations).attributes

data/lib/factory_girl/strategy/attributes_for.rb

@@ -2,7 +2,7 @@ module FactoryGirl
   module Strategy
     class AttributesFor
       def association(runner)
-        runner.run(Strategy::Null)
+        runner.run(:null)
       end
 
       def result(evaluation)

data/lib/factory_girl/strategy/stub.rb

@@ -4,7 +4,7 @@ module FactoryGirl
       @@next_id = 1000
 
       def association(runner)
-        runner.run(Strategy::Stub)
+        runner.run(:build_stubbed)
       end
 
       def result(evaluation)
@@ -36,23 +36,23 @@ module FactoryGirl
           end
 
           def save(*args)
-            raise "stubbed models are not allowed to access the database"
+            raise 'stubbed models are not allowed to access the database'
           end
 
           def destroy(*args)
-            raise "stubbed models are not allowed to access the database"
+            raise 'stubbed models are not allowed to access the database'
           end
 
           def connection
-            raise "stubbed models are not allowed to access the database"
+            raise 'stubbed models are not allowed to access the database'
           end
 
           def reload
-            raise "stubbed models are not allowed to access the database"
+            raise 'stubbed models are not allowed to access the database'
           end
 
           def update_attribute(*args)
-            raise "stubbed models are not allowed to access the database"
+            raise 'stubbed models are not allowed to access the database'
           end
         end
       end

data/lib/factory_girl/strategy_calculator.rb

@@ -1,4 +1,5 @@
 module FactoryGirl
+  # @api private
   class StrategyCalculator
     def initialize(name_or_object)
       @name_or_object = name_or_object

data/lib/factory_girl/strategy_syntax_method_registrar.rb

@@ -0,0 +1,37 @@
+module FactoryGirl
+  # @api private
+  class StrategySyntaxMethodRegistrar
+    def initialize(strategy_name)
+      @strategy_name = strategy_name
+    end
+
+    def define_strategy_methods
+      define_singular_strategy_method
+      define_list_strategy_method
+    end
+
+    private
+
+    def define_singular_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method(strategy_name) do |name, *traits_and_overrides, &block|
+        FactoryRunner.new(name, strategy_name, traits_and_overrides).run(&block)
+      end
+    end
+
+    def define_list_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method("#{strategy_name}_list") do |name, amount, *traits_and_overrides|
+        amount.times.map { send(strategy_name, name, *traits_and_overrides) }
+      end
+    end
+
+    def define_syntax_method(name, &block)
+      FactoryGirl::Syntax::Methods.module_exec do
+        define_method(name, &block)
+      end
+    end
+  end
+end

data/lib/factory_girl/syntax.rb

@@ -1,7 +1,8 @@
-require "active_support/deprecation"
-require "factory_girl/syntax/methods"
-require "factory_girl/syntax/default"
-require "factory_girl/syntax/vintage"
+require 'active_support/deprecation'
+
+require 'factory_girl/syntax/methods'
+require 'factory_girl/syntax/default'
+require 'factory_girl/syntax/vintage'
 
 module FactoryGirl
   # Provides alternate syntaxes for factory_girl. If you don't like the default

data/lib/factory_girl/syntax/blueprint.rb

@@ -16,25 +16,22 @@ module FactoryGirl
     #   FactoryGirl.create(:user, name: 'Johnny')
     #
     # This syntax was derived from Pete Yandell's machinist.
+    # @api private
     module Blueprint
-      module ActiveRecord #:nodoc:
-
-        def self.included(base) # :nodoc:
+      module ActiveRecord
+        def self.included(base)
           base.extend ClassMethods
         end
 
-        module ClassMethods #:nodoc:
-
+        module ClassMethods
           def blueprint(&block)
-            ActiveSupport::Deprecation.warn "Model.blueprint is deprecated; use the FactoryGirl.define syntax instead", caller
+            ActiveSupport::Deprecation.warn 'Model.blueprint is deprecated; use the FactoryGirl.define syntax instead', caller
             instance = Factory.new(name.underscore, class: self)
             proxy = FactoryGirl::DefinitionProxy.new(instance)
             proxy.instance_eval(&block)
             FactoryGirl.register_factory(instance)
           end
-
         end
-
       end
     end
   end

data/lib/factory_girl/syntax/default.rb

@@ -12,10 +12,6 @@ module FactoryGirl
       end
 
       class DSL
-        def self.run(block)
-          new.instance_eval(&block)
-        end
-
         def factory(name, options = {}, &block)
           factory = Factory.new(name, options)
           proxy = FactoryGirl::DefinitionProxy.new(factory.definition)
@@ -36,18 +32,34 @@ module FactoryGirl
         def trait(name, &block)
           FactoryGirl.register_trait(Trait.new(name, &block))
         end
-      end
 
-      class ModifyDSL
+        def to_create(&block)
+          FactoryGirl.to_create(&block)
+        end
+
+        def skip_create
+          FactoryGirl.skip_create
+        end
+
+        def initialize_with(&block)
+          FactoryGirl.initialize_with(&block)
+        end
+
         def self.run(block)
           new.instance_eval(&block)
         end
+      end
 
+      class ModifyDSL
         def factory(name, options = {}, &block)
           factory = FactoryGirl.factory_by_name(name)
           proxy = FactoryGirl::DefinitionProxy.new(factory.definition.overridable)
           proxy.instance_eval(&block)
         end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
       end
     end
   end

data/lib/factory_girl/syntax/generate.rb

@@ -32,39 +32,36 @@ module FactoryGirl
     #
     # This syntax was derived from Rick Bradley and Yossef Mendelssohn's
     # object_daddy.
+    # @api private
     module Generate
-      module ActiveRecord #:nodoc:
-
-        def self.included(base) # :nodoc:
+      module ActiveRecord
+        def self.included(base)
           base.extend ClassMethods
         end
 
-        module ClassMethods #:nodoc:
-
+        module ClassMethods
           def generate(overrides = {}, &block)
-            ActiveSupport::Deprecation.warn "Model.generate is deprecated; use the FactoryGirl.define syntax instead", caller
-            instance = FactoryRunner.new(name.underscore, FactoryGirl.strategy_by_name(:build), [overrides]).run
+            ActiveSupport::Deprecation.warn 'Model.generate is deprecated; use FactoryGirl.build(:name) instead.', caller
+            instance = FactoryRunner.new(name.underscore, :build, [overrides]).run
             instance.save
             yield(instance) if block_given?
             instance
           end
 
           def generate!(overrides = {}, &block)
-            ActiveSupport::Deprecation.warn "Model.generate! is deprecated; use the FactoryGirl.define syntax instead", caller
-            instance = FactoryRunner.new(name.underscore, FactoryGirl.strategy_by_name(:create), [overrides]).run
+            ActiveSupport::Deprecation.warn 'Model.generate! is deprecated; use FactoryGirl.create(:name) instead.', caller
+            instance = FactoryRunner.new(name.underscore, :create, [overrides]).run
             yield(instance) if block_given?
             instance
           end
 
           def spawn(overrides = {}, &block)
-            ActiveSupport::Deprecation.warn "Model.spawn is deprecated; use the FactoryGirl.define syntax instead", caller
-            instance = FactoryRunner.new(name.underscore, FactoryGirl.strategy_by_name(:build), [overrides]).run
+            ActiveSupport::Deprecation.warn 'Model.spawn is deprecated; use FactoryGirl.build(:name) instead.', caller
+            instance = FactoryRunner.new(name.underscore, :build, [overrides]).run
             yield(instance) if block_given?
             instance
           end
-
         end
-
       end
     end
   end

data/lib/factory_girl/syntax/make.rb

@@ -18,27 +18,24 @@ module FactoryGirl
     #   User.make(name: 'Johnny')
     #
     # This syntax was derived from Pete Yandell's machinist.
+    # @api private
     module Make
-      module ActiveRecord #:nodoc:
-
-        def self.included(base) # :nodoc:
+      module ActiveRecord
+        def self.included(base)
           base.extend ClassMethods
         end
 
-        module ClassMethods #:nodoc:
-
+        module ClassMethods
           def make(overrides = {})
-            ActiveSupport::Deprecation.warn "Model.make is deprecated; use the FactoryGirl.define syntax instead", caller
-            FactoryRunner.new(name.underscore, FactoryGirl.strategy_by_name(:build), [overrides]).run
+            ActiveSupport::Deprecation.warn 'Model.make is deprecated; use FactoryGirl.build(:model) instead.', caller
+            FactoryRunner.new(name.underscore, :build, [overrides]).run
           end
 
           def make!(overrides = {})
-            ActiveSupport::Deprecation.warn "Model.make! is deprecated; use the FactoryGirl.define syntax instead", caller
-            FactoryRunner.new(name.underscore, FactoryGirl.strategy_by_name(:create), [overrides]).run
+            ActiveSupport::Deprecation.warn 'Model.make! is deprecated; use FactoryGirl.create(:model) instead.', caller
+            FactoryRunner.new(name.underscore, :create, [overrides]).run
           end
-
         end
-
       end
     end
   end

data/lib/factory_girl/syntax/methods.rb

@@ -1,43 +1,83 @@
 module FactoryGirl
   module Syntax
+    ## This module is a container for all strategy methods provided by
+    ## FactoryGirl. This includes all the default strategies provided ({Methods#build},
+    ## {Methods#create}, {Methods#build_stubbed}, and {Methods#attributes_for}), as well as
+    ## the complementary *_list methods.
+    ## @example singular factory execution
+    ##   # basic use case
+    ##   build(:completed_order)
+    ##
+    ##   # factory yielding its result to a block
+    ##   create(:post) do |post|
+    ##     create(:comment, post: post)
+    ##   end
+    ##
+    ##   # factory with attribute override
+    ##   attributes_for(:post, title: "I love Ruby!")
+    ##
+    ##   # factory with traits and attribute override
+    ##   build_stubbed(:user, :admin, :male, name: "John Doe")
+    ##
+    ## @example multiple factory execution
+    ##   # basic use case
+    ##   build_list(:completed_order, 2)
+    ##   create_list(:completed_order, 2)
+    ##
+    ##   # factory with attribute override
+    ##   attributes_for_list(:post, 4, title: "I love Ruby!")
+    ##
+    ##   # factory with traits and attribute override
+    ##   build_stubbed_list(:user, 15, :admin, :male, name: "John Doe")
     module Methods
-      # Builds and returns multiple instances from this factory as an array. Attributes can be
-      # individually overridden by passing in a Hash of attribute => value pairs.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory to be used.
-      # * amount: +Integer+
-      #   number of instances to be built.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this instance.
-      #
-      # Returns: +Array+
-      # An array of instances of the class this factory generates, with generated attributes
-      # assigned.
-      def build_list(name, amount, *traits_and_overrides)
-        amount.times.map { build(name, *traits_and_overrides) }
-      end
+      # @!parse FactoryGirl.register_default_strategies
+      # @!method build(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Builds a registered factory by name.
+      # @return [Object] instantiated object defined by the factory
 
-      # Creates and returns multiple instances from this factory as an array. Attributes can be
-      # individually overridden by passing in a Hash of attribute => value pairs.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory to be used.
-      # * amount: +Integer+
-      #   number of instances to be created.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this instance.
-      #
-      # Returns: +Array+
-      # An array of instances of the class this factory generates, with generated attributes
-      # assigned.
-      def create_list(name, amount, *traits_and_overrides)
-        amount.times.map { create(name, *traits_and_overrides) }
-      end
+      # @!method create(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Creates a registered factory by name.
+      # @return [Object] instantiated object defined by the factory
+
+      # @!method build_stubbed(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Builds a stubbed registered factory by name.
+      # @return [Object] instantiated object defined by the factory
+
+      # @!method attributes_for(name, *traits_and_overrides, &block)
+      # (see #strategy_method)
+      # Generates a hash of attributes for a registered factory by name.
+      # @return [Hash] hash of attributes for the factory
+
+      # @!method build_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of built objects defined by the factory
+
+      # @!method create_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of created objects defined by the factory
+
+      # @!method build_stubbed_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array] array of stubbed objects defined by the factory
+
+      # @!method attributes_for_list(name, amount, *traits_and_overrides)
+      # (see #strategy_method_list)
+      # @return [Array<Hash>] array of attribute hashes for the factory
+
+      # @!method strategy_method
+      # @!visibility private
+      # @param [Symbol] name name of the factory to build
+      # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
+      # @param [Proc] block block to be executed
+
+      # @!method strategy_method_list
+      # @!visibility private
+      # @param [Symbol] name name of the factory to execute
+      # @param [Integer] amount the number of instances to execute
+      # @param [Array<Symbol, Symbol, Hash>] traits_and_overrides splat args traits and a hash of overrides
 
       # Generates and returns the next value in a sequence.
       #