factory_girl 2.2.0 → 2.3.0

data/lib/factory_girl/null_factory.rb

@@ -0,0 +1,15 @@
+module FactoryGirl
+  class NullFactory
+    attr_reader :definition
+
+    def initialize
+      @definition = Definition.new
+    end
+
+    delegate :defined_traits, :callbacks, :attributes, :to => :definition
+
+    def compile; end
+    def default_strategy; end
+    def class_name; end
+  end
+end

data/lib/factory_girl/proxy.rb

@@ -1,10 +1,14 @@
+require "active_support/core_ext/hash/except"
+
 module FactoryGirl
   class Proxy #:nodoc:
+    def initialize(klass, callbacks = [])
+      @callbacks = callbacks.inject({}) do |result, callback|
+        result[callback.name] ||= []
+        result[callback.name] << callback
+        result
+      end
 
-    attr_reader :callbacks
-
-    def initialize(klass)
-      @callbacks = {}
       @ignored_attributes = {}
     end
 
@@ -21,11 +25,6 @@ module FactoryGirl
     def associate(name, factory, attributes)
     end
 
-    def add_callback(callback)
-      @callbacks[callback.name] ||= []
-      @callbacks[callback.name] << callback
-    end
-
     def run_callbacks(name)
       if @callbacks[name]
         @callbacks[name].each do |callback|
@@ -76,5 +75,11 @@ module FactoryGirl
     def result(to_create)
       raise NotImplementedError, "Strategies must return a result"
     end
+
+    def self.ensure_strategy_exists!(strategy)
+      unless Proxy.const_defined? strategy.to_s.camelize
+        raise ArgumentError, "Unknown strategy: #{strategy}"
+      end
+    end
   end
 end

data/lib/factory_girl/proxy/attributes_for.rb

@@ -1,10 +1,9 @@
 module FactoryGirl
   class Proxy #:nodoc:
     class AttributesFor < Proxy #:nodoc:
-      def initialize(klass)
-        super(klass)
+      def initialize(klass, callbacks = [])
+        super
         @hash = {}
-        @ignored_attributes = {}
       end
 
       def get(attribute)

data/lib/factory_girl/proxy/build.rb

@@ -1,8 +1,8 @@
 module FactoryGirl
   class Proxy #:nodoc:
     class Build < Proxy #:nodoc:
-      def initialize(klass)
-        super(klass)
+      def initialize(klass, callbacks = [])
+        super
         @instance = klass.new
       end
 
@@ -19,19 +19,13 @@ module FactoryGirl
       end
 
       def associate(name, factory_name, overrides)
-        method = get_method(overrides[:method])
-        factory = FactoryGirl.factory_by_name(factory_name)
-        set(name, factory.run(method, remove_method(overrides)))
+        set(name, association(factory_name, overrides))
       end
 
       def association(factory_name, overrides = {})
         method = get_method(overrides[:method])
         factory = FactoryGirl.factory_by_name(factory_name)
-        factory.run(method, remove_method(overrides))
-      end
-
-      def remove_method(overrides)
-        overrides.dup.delete_if {|key, value| key == :method}
+        factory.run(method, overrides.except(:method))
       end
 
       def result(to_create)
@@ -39,18 +33,16 @@ module FactoryGirl
         @instance
       end
 
-      def parse_method(method)
-        method ||= :create
-        if :build == method
-          return Proxy::Build
-        elsif :create == method
-          return Proxy::Create
-        else
-          raise "unrecognized method #{method}"
+      private
+
+      def get_method(method)
+        case method
+        when :build  then Proxy::Build
+        when :create then Proxy::Create
+        when nil     then Proxy::Create
+        else raise "unrecognized method #{method}"
         end
       end
-
-      alias_method :get_method, :parse_method
     end
   end
 end

data/lib/factory_girl/proxy/create.rb

@@ -11,12 +11,6 @@ module FactoryGirl
         run_callbacks(:after_create)
         @instance
       end
-
-      def get_method(method_string)
-        # Leaving this as Proxy::Build in the :method => :build case
-        # is a bit strange, but does it have any user-visible behaviors?
-        parse_method(method_string)
-      end
     end
   end
 end

data/lib/factory_girl/proxy/stub.rb

@@ -3,10 +3,9 @@ module FactoryGirl
     class Stub < Proxy #:nodoc:
       @@next_id = 1000
 
-      def initialize(klass)
-        super(klass)
+      def initialize(klass, callbacks = [])
+        super
         @instance = klass.new
-        @ignored_attributes = {}
         @instance.id = next_id
         @instance.instance_eval do
           def persisted?
@@ -60,17 +59,12 @@ module FactoryGirl
       end
 
       def associate(name, factory_name, overrides)
-        factory = FactoryGirl.factory_by_name(factory_name)
-        set(name, factory.run(Proxy::Stub, remove_method(overrides)))
+        set(name, association(factory_name, overrides))
       end
 
       def association(factory_name, overrides = {})
         factory = FactoryGirl.factory_by_name(factory_name)
-        factory.run(Proxy::Stub, remove_method(overrides))
-      end
-
-      def remove_method(overrides)
-        overrides.dup.delete_if {|key, value| key == :method}
+        factory.run(Proxy::Stub, overrides.except(:method))
       end
 
       def result(to_create)

data/lib/factory_girl/registry.rb

@@ -2,7 +2,8 @@ module FactoryGirl
   class Registry
     include Enumerable
 
-    def initialize
+    def initialize(name)
+      @name  = name
       @items = {}
     end
 
@@ -12,7 +13,7 @@ module FactoryGirl
     end
 
     def find(name)
-      @items[name.to_sym] or raise ArgumentError.new("Not registered: #{name.to_s}")
+      @items[name.to_sym] or raise ArgumentError.new("#{@name} not registered: #{name.to_s}")
     end
 
     def each(&block)
@@ -35,7 +36,7 @@ module FactoryGirl
 
     def add_as(name, item)
       if registered?(name)
-        raise DuplicateDefinitionError, "Already defined: #{name}"
+        raise DuplicateDefinitionError, "#{@name} already registered: #{name}"
       else
         @items[name.to_sym] = item
       end

data/lib/factory_girl/step_definitions.rb

@@ -95,7 +95,7 @@ end
 World(FactoryGirlStepHelpers)
 
 FactoryGirl.factories.each do |factory|
-  factory.ensure_compiled
+  factory.compile
   factory.human_names.each do |human_name|
     Given /^the following (?:#{human_name}|#{human_name.pluralize}) exists?:$/i do |table|
       table.hashes.each do |human_hash|

data/lib/factory_girl/syntax/default.rb

@@ -18,7 +18,7 @@ module FactoryGirl
 
         def factory(name, options = {}, &block)
           factory = Factory.new(name, options)
-          proxy = FactoryGirl::DefinitionProxy.new(factory)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition)
           proxy.instance_eval(&block) if block_given?
 
           FactoryGirl.register_factory(factory)
@@ -43,10 +43,9 @@ module FactoryGirl
         end
 
         def factory(name, options = {}, &block)
-          factory = FactoryGirl.factory_by_name(name).allow_overrides
-          proxy = FactoryGirl::DefinitionProxy.new(factory)
+          factory = FactoryGirl.factory_by_name(name)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition.overridable)
           proxy.instance_eval(&block)
-          factory.ensure_compiled
         end
       end
     end

data/lib/factory_girl/syntax/methods.rb

@@ -8,16 +8,17 @@ module FactoryGirl
       # Arguments:
       # * name: +Symbol+ or +String+
       #   The name of the factory that should be used.
-      # * overrides: +Hash+
-      #   Attributes to overwrite for this set.
+      # * 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, overrides = {}, &block)
-        FactoryGirl.factory_by_name(name).run(Proxy::AttributesFor, overrides, &block)
+      def attributes_for(name, *traits_and_overrides, &block)
+        run_factory_girl_proxy(name, traits_and_overrides, Proxy::AttributesFor, &block)
       end
 
       # Generates and returns an instance from this factory. Attributes can be
@@ -26,16 +27,17 @@ module FactoryGirl
       # Arguments:
       # * name: +Symbol+ or +String+
       #   The name of the factory that should be used.
-      # * overrides: +Hash+
-      #   Attributes to overwrite for this instance.
+      # * 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, overrides = {}, &block)
-        FactoryGirl.factory_by_name(name).run(Proxy::Build, overrides, &block)
+      def build(name, *traits_and_overrides, &block)
+        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Build, &block)
       end
 
       # Generates, saves, and returns an instance from this factory. Attributes can
@@ -48,16 +50,17 @@ module FactoryGirl
       # Arguments:
       # * name: +Symbol+ or +String+
       #   The name of the factory that should be used.
-      # * overrides: +Hash+
-      #   Attributes to overwrite for this instance.
+      # * 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, overrides = {}, &block)
-        FactoryGirl.factory_by_name(name).run(Proxy::Create, overrides, &block)
+      def create(name, *traits_and_overrides, &block)
+        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Create, &block)
       end
 
       # Generates and returns an object with all attributes from this factory
@@ -67,15 +70,16 @@ module FactoryGirl
       # Arguments:
       # * name: +Symbol+ or +String+
       #   The name of the factory that should be used.
-      # * overrides: +Hash+
-      #   Attributes to overwrite for this instance.
+      # * 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, overrides = {}, &block)
-        FactoryGirl.factory_by_name(name).run(Proxy::Stub, overrides, &block)
+      def build_stubbed(name, *traits_and_overrides, &block)
+        run_factory_girl_proxy(name, traits_and_overrides, Proxy::Stub, &block)
       end
 
       # Builds and returns multiple instances from this factory as an array. Attributes can be
@@ -125,6 +129,24 @@ module FactoryGirl
       def generate(name)
         FactoryGirl.sequence_by_name(name).next
       end
+
+      private
+
+      def run_factory_girl_proxy(name, traits_and_overrides, proxy, &block)
+        overrides = if traits_and_overrides.last.respond_to?(:has_key?)
+                      traits_and_overrides.pop
+                    else
+                      {}
+                    end
+
+        factory = FactoryGirl.factory_by_name(name)
+
+        if traits_and_overrides.any?
+          factory = factory.with_traits(traits_and_overrides)
+        end
+
+        factory.run(proxy, overrides, &block)
+      end
     end
   end
 end

data/lib/factory_girl/trait.rb

@@ -4,34 +4,26 @@ module FactoryGirl
 
     def initialize(name, &block) #:nodoc:
       @name = name
-      @attribute_list = AttributeList.new
+      @block = block
+      @definition = Definition.new
 
-      proxy = FactoryGirl::DefinitionProxy.new(self)
-      proxy.instance_eval(&block) if block_given?
+      proxy = FactoryGirl::DefinitionProxy.new(@definition)
+      proxy.instance_eval(&@block) if block_given?
     end
 
-    def declare_attribute(declaration)
-      @attribute_list.declare_attribute(declaration)
-      declaration
-    end
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait,
+             :callbacks, :attributes, :to => :@definition
 
-    def add_callback(name, &block)
-      @attribute_list.add_callback(Callback.new(name, block))
+    def names
+      [@name]
     end
 
-    def attributes
-      AttributeList.new.tap do |list|
-        @attribute_list.declarations.each do |declaration|
-          declaration.to_attributes.each do |attribute|
-            list.define_attribute(attribute)
-          end
-        end
-        list.apply_attributes @attribute_list
-      end
+    def ==(other)
+      name == other.name &&
+        block == other.block
     end
 
-    def names
-      [@name]
-    end
+    protected
+    attr_reader :block
   end
 end

data/lib/factory_girl/version.rb

@@ -1,4 +1,4 @@
 module FactoryGirl
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end
 

data/spec/acceptance/modify_factories_spec.rb

@@ -39,7 +39,7 @@ describe "modifying factories" do
     it "doesn't allow the factory to be subsequently defined" do
       expect do
         FactoryGirl.define { factory :user }
-      end.to raise_error(FactoryGirl::DuplicateDefinitionError)
+      end.to raise_error(FactoryGirl::DuplicateDefinitionError, "Factory already registered: user")
     end
 
     it "does allow the factory to be subsequently modified" do

data/spec/acceptance/traits_spec.rb

@@ -165,6 +165,92 @@ describe "an instance generated by a factory with multiple traits" do
 
   context "factory outside of scope" do
     subject     { FactoryGirl.create(:user_without_admin_scoping) }
-    it { expect { subject }.to raise_error(ArgumentError, "Not registered: admin_trait") }
+    it { expect { subject }.to raise_error(ArgumentError, "Trait not registered: admin_trait") }
+  end
+end
+
+describe "traits with callbacks" do
+  before do
+    define_model("User", :name => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        name "John"
+
+        trait :great do
+          after_create {|user| user.name.upcase! }
+        end
+
+        factory :caps_user, :traits => [:great]
+
+        factory :caps_user_implicit_trait do
+          great
+        end
+      end
+    end
+  end
+
+  context "when the factory has a trait passed via arguments" do
+    subject    { FactoryGirl.create(:caps_user) }
+    its(:name) { should == "JOHN" }
+  end
+
+  context "when the factory has an implicit trait" do
+    subject    { FactoryGirl.create(:caps_user_implicit_trait) }
+    its(:name) { should == "JOHN" }
+  end
+end
+
+describe "traits added via proxy" do
+  before do
+    define_model("User", :name => :string, :admin => :boolean)
+
+    FactoryGirl.define do
+      factory :user do
+        name "John"
+
+        trait :admin do
+          admin true
+        end
+
+        trait :great do
+          after_create {|user| user.name.upcase! }
+        end
+      end
+    end
+  end
+
+  context "adding traits in create" do
+    subject { FactoryGirl.create(:user, :admin, :great, :name => "Joe") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "JOE" }
+
+    it "doesn't modify the user factory" do
+      subject
+      FactoryGirl.create(:user).should_not be_admin
+      FactoryGirl.create(:user).name.should == "John"
+    end
+  end
+
+  context "adding traits in build" do
+    subject { FactoryGirl.build(:user, :admin, :great, :name => "Joe") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "Joe" }
+  end
+
+  context "adding traits in attributes_for" do
+    subject { FactoryGirl.attributes_for(:user, :admin, :great) }
+
+    its([:admin]) { should be_true }
+    its([:name])  { should == "John" }
+  end
+
+  context "adding traits in build_stubbed" do
+    subject { FactoryGirl.build_stubbed(:user, :admin, :great, :name => "Jack") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "Jack" }
   end
 end