factory_girl 3.1.1 → 3.2.0

data/lib/factory_girl/callback.rb

@@ -1,6 +1,6 @@
 module FactoryGirl
   class Callback
-    attr_reader :name, :block
+    attr_reader :name
 
     def initialize(name, block)
       @name  = name.to_sym
@@ -21,6 +21,9 @@ module FactoryGirl
         block == other.block
     end
 
+    protected
+    attr_reader :block
+
     private
 
     def check_name

data/lib/factory_girl/{callback_runner.rb → callbacks_observer.rb}

@@ -1,5 +1,5 @@
 module FactoryGirl
-  class CallbackRunner
+  class CallbacksObserver
     def initialize(callbacks, evaluator)
       @callbacks = callbacks
       @evaluator = evaluator

data/lib/factory_girl/definition.rb

@@ -6,7 +6,7 @@ module FactoryGirl
       @declarations      = DeclarationList.new(name)
       @callbacks         = []
       @defined_traits    = []
-      @to_create         = lambda {|instance| instance.save! }
+      @to_create         = ->(instance) { instance.save! }
       @base_traits       = base_traits
       @additional_traits = []
       @constructor       = nil

data/lib/factory_girl/definition_proxy.rb

@@ -144,6 +144,10 @@ module FactoryGirl
       @definition.to_create(&block)
     end
 
+    def skip_create
+      @definition.to_create {|instance| }
+    end
+
     def factory(name, options = {}, &block)
       @child_factories << [name, options, block]
     end

data/lib/factory_girl/disallows_duplicates_registry.rb

@@ -0,0 +1,17 @@
+module FactoryGirl
+  class DisallowsDuplicatesRegistry
+    def initialize(component)
+      @component = component
+    end
+
+    delegate :clear, :each, :find, :[], :registered?, to: :@component
+
+    def register(name, item)
+      if registered?(name)
+        raise DuplicateDefinitionError, "#{@component.name} already registered: #{name}"
+      else
+        @component.register(name, item)
+      end
+    end
+  end
+end

data/lib/factory_girl/evaluator.rb

@@ -17,24 +17,23 @@ module FactoryGirl
       undef_method(method) unless method =~ /^__|initialize/
     end
 
-    def initialize(build_strategy, overrides = {})
+    def initialize(build_class, build_strategy, overrides = {})
+      @build_class       = build_class
       @build_strategy    = build_strategy
       @overrides         = overrides
       @cached_attributes = overrides
 
       @overrides.each do |name, value|
-        singleton_class.send :define_method, name, lambda { value }
+        singleton_class.send :define_method, name, -> { value }
       end
     end
 
+    delegate :new, to: :@build_class
+
     def association(factory_name, overrides = {})
-      build_strategy = if overrides.has_key?(:strategy)
-                         overrides[:strategy]
-                       else
-                         Strategy::Create
-                       end
+      strategy_override = overrides.fetch(:strategy) { FactoryGirl.strategy_by_name(:create) }
 
-      build_strategy = StrategyCalculator.new(build_strategy).strategy
+      build_strategy = StrategyCalculator.new(strategy_override).strategy
       runner = FactoryRunner.new(factory_name, build_strategy, [overrides.except(:strategy)])
       @build_strategy.association(runner)
     end
@@ -47,12 +46,16 @@ module FactoryGirl
       if @cached_attributes.key?(method_name)
         @cached_attributes[method_name]
       else
-        @instance.send(method_name, *args, &block)
+        if @instance.respond_to?(method_name)
+          @instance.send(method_name, *args, &block)
+        else
+          SyntaxRunner.new.send(method_name, *args, &block)
+        end
       end
     end
 
-    def __overrides
-      @overrides
+    def __override_names__
+      @overrides.keys
     end
   end
 end

data/lib/factory_girl/factory.rb

@@ -27,16 +27,16 @@ module FactoryGirl
     end
 
     def run(strategy_class, overrides, &block) #:nodoc:
-      block ||= lambda {|result| result }
+      block ||= ->(result) { result }
       compile
 
       strategy = strategy_class.new
 
-      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
-      attribute_assigner = AttributeAssigner.new(evaluator, &instance_builder)
+      evaluator = evaluator_class.new(build_class, strategy, overrides.symbolize_keys)
+      attribute_assigner = AttributeAssigner.new(evaluator, build_class, &instance_builder)
 
       evaluation = Evaluation.new(attribute_assigner, to_create)
-      evaluation.add_observer(CallbackRunner.new(callbacks, evaluator))
+      evaluation.add_observer(CallbacksObserver.new(callbacks, evaluator))
 
       strategy.result(evaluation).tap(&block)
     end
@@ -136,7 +136,7 @@ module FactoryGirl
 
     def instance_builder
       build_class = self.build_class
-      constructor || lambda { build_class.new }
+      constructor || -> { build_class.new }
     end
 
     def initialize_copy(source)

data/lib/factory_girl/null_object.rb

@@ -1,7 +1,19 @@
 module FactoryGirl
   class NullObject < ::BasicObject
-    def method_missing(*args)
-      nil
+    def initialize(methods_to_respond_to)
+      @methods_to_respond_to = methods_to_respond_to.map(&:to_s)
+    end
+
+    def method_missing(name, *args, &block)
+      if respond_to?(name)
+        nil
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_private=false)
+      @methods_to_respond_to.include? method.to_s
     end
   end
 end

data/lib/factory_girl/registry.rb

@@ -2,45 +2,37 @@ module FactoryGirl
   class Registry
     include Enumerable
 
+    attr_reader :name
+
     def initialize(name)
       @name  = name
       @items = {}
     end
 
-    def add(item)
-      item.names.each { |name| add_as(name, item) }
-      item
-    end
-
-    def find(name)
-      @items[name.to_sym] or raise ArgumentError.new("#{@name} not registered: #{name.to_s}")
+    def clear
+      @items.clear
     end
 
     def each(&block)
       @items.values.uniq.each(&block)
     end
 
-    def [](name)
-      find(name)
+    def find(name)
+      if registered?(name)
+        @items[name.to_sym]
+      else
+        raise ArgumentError, "#{@name} not registered: #{name}"
+      end
     end
 
-    def registered?(name)
-      @items.key?(name.to_sym)
-    end
+    alias :[] :find
 
-    def clear
-      @items.clear
+    def register(name, item)
+      @items[name.to_sym] = item
     end
 
-    private
-
-    def add_as(name, item)
-      if registered?(name)
-        raise DuplicateDefinitionError, "#{@name} already registered: #{name}"
-      else
-        @items[name.to_sym] = item
-      end
+    def registered?(name)
+      @items.key?(name.to_sym)
     end
   end
 end
-

data/lib/factory_girl/reload.rb

@@ -3,6 +3,8 @@ module FactoryGirl
     self.factories.clear
     self.sequences.clear
     self.traits.clear
+    self.strategies.clear
+    self.register_default_strategies
     self.find_definitions
   end
 end

data/lib/factory_girl/strategy_calculator.rb

@@ -19,11 +19,7 @@ module FactoryGirl
     end
 
     def strategy_name_to_object
-      case @name_or_object
-      when :build  then Strategy::Build
-      when :create then Strategy::Create
-      else raise "unrecognized method #{@name_or_object}"
-      end
+      FactoryGirl.strategy_by_name(@name_or_object)
     end
   end
 end

data/lib/factory_girl/syntax.rb

@@ -1,3 +1,4 @@
+require "active_support/deprecation"
 require "factory_girl/syntax/methods"
 require "factory_girl/syntax/default"
 require "factory_girl/syntax/vintage"

data/lib/factory_girl/syntax/blueprint.rb

@@ -26,6 +26,7 @@ module FactoryGirl
         module ClassMethods #:nodoc:
 
           def blueprint(&block)
+            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)

data/lib/factory_girl/syntax/generate.rb

@@ -42,20 +42,23 @@ module FactoryGirl
         module ClassMethods #:nodoc:
 
           def generate(overrides = {}, &block)
-            instance = FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+            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
             instance.save
             yield(instance) if block_given?
             instance
           end
 
           def generate!(overrides = {}, &block)
-            instance = FactoryRunner.new(name.underscore, Strategy::Create, [overrides]).run
+            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
             yield(instance) if block_given?
             instance
           end
 
           def spawn(overrides = {}, &block)
-            instance = FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+            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
             yield(instance) if block_given?
             instance
           end

data/lib/factory_girl/syntax/make.rb

@@ -28,11 +28,13 @@ module FactoryGirl
         module ClassMethods #:nodoc:
 
           def make(overrides = {})
-            FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+            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
           end
 
           def make!(overrides = {})
-            FactoryRunner.new(name.underscore, Strategy::Create, [overrides]).run
+            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
           end
 
         end

data/lib/factory_girl/syntax/methods.rb

@@ -1,87 +1,6 @@
 module FactoryGirl
   module Syntax
     module Methods
-      # Generates and returns a Hash of attributes from this factory. Attributes
-      # can be individually overridden by passing in a Hash of attribute => value
-      # pairs.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory that should be used.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this set.
-      # * block:
-      #   Yields the hash of attributes.
-      #
-      # Returns: +Hash+
-      # A set of attributes that can be used to build an instance of the class
-      # this factory generates.
-      def attributes_for(name, *traits_and_overrides, &block)
-        FactoryRunner.new(name, Strategy::AttributesFor, traits_and_overrides).run(&block)
-      end
-
-      # Generates and returns an instance from this factory. Attributes can be
-      # individually overridden by passing in a Hash of attribute => value pairs.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory that should be used.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this instance.
-      # * block:
-      #   Yields the built instance.
-      #
-      # Returns: +Object+
-      # An instance of the class this factory generates, with generated attributes
-      # assigned.
-      def build(name, *traits_and_overrides, &block)
-        FactoryRunner.new(name, Strategy::Build, traits_and_overrides).run(&block)
-      end
-
-      # Generates, saves, and returns an instance from this factory. Attributes can
-      # be individually overridden by passing in a Hash of attribute => value
-      # pairs.
-      #
-      # Instances are saved using the +save!+ method, so ActiveRecord models will
-      # raise ActiveRecord::RecordInvalid exceptions for invalid attribute sets.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory that should be used.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this instance.
-      # * block:
-      #   Yields the created instance.
-      #
-      # Returns: +Object+
-      # A saved instance of the class this factory generates, with generated
-      # attributes assigned.
-      def create(name, *traits_and_overrides, &block)
-        FactoryRunner.new(name, Strategy::Create, traits_and_overrides).run(&block)
-      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.
-      #
-      # Arguments:
-      # * name: +Symbol+ or +String+
-      #   The name of the factory that should be used.
-      # * traits_and_overrides: +Array+
-      #   [+*Array+] Traits to be applied
-      #   [+Hash+] Attributes to overwrite for this instance.
-      # * block
-      #   Yields the stubbed object.
-      #
-      # Returns: +Object+
-      # An object with generated attributes stubbed out.
-      def build_stubbed(name, *traits_and_overrides, &block)
-        FactoryRunner.new(name, Strategy::Stub, traits_and_overrides).run(&block)
-      end
-
       # 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.
       #

data/lib/factory_girl/syntax/sham.rb

@@ -26,6 +26,7 @@ module FactoryGirl
       module Sham #:nodoc:
         def self.method_missing(name, *args, &block)
           if block_given?
+            ActiveSupport::Deprecation.warn "Sham.sequence is deprecated; use the FactoryGirl.define syntax instead", caller
             start_value = args.first
             FactoryGirl.register_sequence(Sequence.new(name, start_value || 1, &block))
           else

data/lib/factory_girl/syntax/vintage.rb

@@ -1,5 +1,3 @@
-require "active_support/deprecation"
-
 module FactoryGirl
   module Syntax
     module Vintage

data/lib/factory_girl/syntax_runner.rb

@@ -0,0 +1,5 @@
+module FactoryGirl
+  class SyntaxRunner
+    include Syntax::Methods
+  end
+end

data/lib/factory_girl/version.rb

@@ -1,4 +1,4 @@
 module FactoryGirl
-  VERSION = "3.1.1"
+  VERSION = "3.2.0"
 end
 

data/spec/acceptance/activesupport_instrumentation_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe "using ActiveSupport::Instrumentation to track factory interaction" do
+  before do
+    define_model("User", email: :string)
+    FactoryGirl.define do
+      factory :user do
+        email "john@example.com"
+
+        factory :slow_user do
+          after_build { Kernel.sleep(0.1) }
+        end
+      end
+
+    end
+  end
+
+  it "tracks proper time of creating the record" do
+    time_to_execute = 0
+    callback = ->(name, start, finish, id, payload) { time_to_execute = finish - start }
+    ActiveSupport::Notifications.subscribed(callback, "factory_girl.run_factory") do
+      FactoryGirl.build(:slow_user)
+    end
+
+    time_to_execute.should be_within(0.01).of(0.1)
+  end
+
+  it "builds the correct payload" do
+    tracked_invocations = {}
+
+    callback = ->(name, start, finish, id, payload) do
+      factory_name = payload[:name]
+      strategy_name = payload[:strategy]
+      tracked_invocations[factory_name] ||= {}
+      tracked_invocations[factory_name][strategy_name] ||= 0
+      tracked_invocations[factory_name][strategy_name] += 1
+    end
+
+    ActiveSupport::Notifications.subscribed(callback, "factory_girl.run_factory") do
+      FactoryGirl.build_list(:slow_user, 2)
+      FactoryGirl.build_list(:user, 5)
+      FactoryGirl.create_list(:user, 2)
+      FactoryGirl.attributes_for(:slow_user)
+    end
+
+    tracked_invocations[:slow_user].should == { build: 2, attributes_for: 1 }
+    tracked_invocations[:user].should == { build: 5, create: 2 }
+  end
+end