factory_girl_kibiz0r 2.0.0.beta2

data/features/support/factories.rb

@@ -0,0 +1,84 @@
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), 'test.db')
+)
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :posts, :force => true do |t|
+      t.integer :author_id
+      t.integer :category_id
+      t.string  :title
+      t.string  :body
+    end
+
+    create_table :category_groups, :force => true do |t|
+      t.string :name
+    end
+
+    create_table :categories, :force => true do |t|
+      t.integer :category_group_id
+      t.string :name
+    end
+
+    create_table :users, :force => true do |t|
+      t.string  :name
+      t.boolean :admin, :default => false, :null => false
+    end
+  end
+end
+
+CreateSchema.suppress_messages { CreateSchema.migrate(:up) }
+
+class User < ActiveRecord::Base
+end
+
+class CategoryGroup < ActiveRecord::Base
+end
+
+class Category < ActiveRecord::Base
+  belongs_to :category_group
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author, :class_name => 'User'
+  belongs_to :category
+end
+
+class NonActiveRecord
+end
+
+FactoryGirl.define do
+  # To make sure the step defs work with an email
+  sequence :email do |n|
+    "email#{n}@example.com"
+  end
+
+  factory :user do
+  end
+
+  factory :admin_user, :parent => :user do
+    admin true
+  end
+
+  factory :category do
+    name "programming"
+    category_group
+  end
+
+  factory :category_group do
+    name "tecnhology"
+  end
+
+  factory :post do
+    association :author, :factory => :user
+    category
+  end
+
+  # This is here to ensure that factory step definitions don't raise for a non-AR factory
+  factory :non_active_record do
+  end
+end
+
+require 'factory_girl/step_definitions'
+

data/lib/factory_girl/aliases.rb

@@ -0,0 +1,21 @@
+module FactoryGirl
+
+  class << self
+    attr_accessor :aliases #:nodoc:
+  end
+  self.aliases = [
+    [/(.+)_id/, '\1'],
+    [/(.*)/, '\1_id']
+  ]
+
+  def self.aliases_for(attribute) #:nodoc:
+    aliases.collect do |params|
+      pattern, replace = *params
+      if pattern.match(attribute.to_s)
+        attribute.to_s.sub(pattern, replace).to_sym
+      else
+        nil
+      end
+    end.compact << attribute
+  end
+end

data/lib/factory_girl/attribute/association.rb

@@ -0,0 +1,24 @@
+module FactoryGirl
+  class Attribute #:nodoc:
+
+    class Association < Attribute  #:nodoc:
+
+      attr_reader :factory
+
+      def initialize(name, factory, overrides)
+        super(name)
+        @factory   = factory
+        @overrides = overrides
+      end
+
+      def add_to(proxy)
+        proxy.associate(name, @factory, @overrides)
+      end
+
+      def association?
+        true
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute/callback.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  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

@@ -0,0 +1,21 @@
+module FactoryGirl
+  class Attribute #:nodoc:
+
+    class Dynamic < Attribute  #:nodoc:
+      def initialize(name, block)
+        super(name)
+        @block = block
+      end
+
+      def add_to(proxy)
+        value = @block.arity == 1 ? @block.call(proxy) : proxy.instance_exec(&@block)
+        if FactoryGirl::Sequence === value
+          raise SequenceAbuseError
+        end
+        method = !ignored? ? :set : :ignore
+        proxy.send(method, name, value)
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute/implicit.rb

@@ -0,0 +1,36 @@
+module FactoryGirl
+  class Attribute
+
+    class Implicit < Attribute
+      def initialize(name)
+        super(name)
+      end
+
+      def add_to(proxy)
+        implementation.add_to(proxy)
+      end
+
+      def association?
+        implementation.association?
+      end
+
+      def factory
+        name
+      end
+
+      private
+
+      def implementation
+        @implementation ||= resolve_name
+      end
+
+      def resolve_name
+        if FactoryGirl.factories.registered?(name)
+          Attribute::Association.new(name, name, {})
+        else
+          Attribute::Sequence.new(name, name)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/attribute/list.rb

@@ -0,0 +1,19 @@
+module FactoryGirl
+
+  class Attribute
+
+    class List < Array
+
+      def method_missing(method, *args, &block)
+        if empty?
+          super
+        else
+          last.send(method, *args, &block)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/factory_girl/attribute/sequence.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Attribute
+
+    class Sequence < Attribute
+      def initialize(name, sequence)
+        super(name)
+        @sequence = sequence
+      end
+
+      def add_to(proxy)
+        proxy.set(name, FactoryGirl.generate(@sequence))
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute/static.rb

@@ -0,0 +1,18 @@
+module FactoryGirl
+  class Attribute #:nodoc:
+
+    class Static < Attribute  #:nodoc:
+
+      def initialize(name, value)
+        super(name)
+        @value = value
+      end
+
+      def add_to(proxy)
+        method = !ignored? ? :set : :ignore
+        proxy.send(method, name, @value)
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute.rb

@@ -0,0 +1,42 @@
+module FactoryGirl
+
+  # Raised when defining an invalid attribute:
+  # * Defining an attribute which has a name ending in "="
+  # * Defining an attribute with both a static and lazy value
+  # * Defining an attribute twice in the same factory
+  class AttributeDefinitionError < RuntimeError
+  end
+
+  class Attribute #:nodoc:
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_sym
+
+      if @name.to_s =~ /=$/
+        attribute_name = $`
+        raise AttributeDefinitionError,
+          "factory_girl uses 'f.#{attribute_name} value' syntax " +
+          "rather than 'f.#{attribute_name} = value'"
+      end
+    end
+
+    def add_to(proxy)
+    end
+
+    def association?
+      false
+    end
+
+    def ignore
+      @ignored = true
+      self
+    end
+    
+    def ignored?
+      @ignored
+    end
+  end
+
+end

data/lib/factory_girl/definition_proxy.rb

@@ -0,0 +1,147 @@
+module FactoryGirl
+  class DefinitionProxy
+    instance_methods.each do |method|
+      undef_method(method) unless method =~ /(^__|^nil\?$|^send$|^object_id$|^extend$|^instance_eval$)/
+    end
+
+    def initialize(factory)
+      @factory = factory
+    end
+
+    # Adds an attribute that should be assigned on generated instances for this
+    # factory.
+    #
+    # This method should be called with either a value or block, but not both. If
+    # called with a block, the attribute will be generated "lazily," whenever an
+    # instance is generated. Lazy attribute blocks will not be called if that
+    # attribute is overridden for a specific instance.
+    #
+    # When defining lazy attributes, an instance of FactoryGirl::Proxy will
+    # be yielded, allowing associations to be built using the correct build
+    # strategy.
+    #
+    # Arguments:
+    # * name: +Symbol+ or +String+
+    #   The name of this attribute. This will be assigned using "name=" for
+    #   generated instances.
+    # * value: +Object+
+    #   If no block is given, this value will be used for this attribute.
+    def add_attribute(name, value = nil, &block)
+      if block_given?
+        if value
+          raise AttributeDefinitionError, "Both value and block given"
+        else
+          attribute = Attribute::Dynamic.new(name, block)
+        end
+      else
+        attribute = Attribute::Static.new(name, value)
+      end
+
+      @factory.define_attribute(attribute)
+    end
+
+    # Calls add_attribute using the missing method name as the name of the
+    # attribute, so that:
+    #
+    #   factory :user do
+    #     name 'Billy Idol'
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     add_attribute :name, 'Billy Idol'
+    #   end
+    #
+    # are equivilent.
+    #
+    # If no argument or block is given, factory_girl will look for a sequence
+    # or association with the same name. This means that:
+    #
+    #   factory :user do
+    #     email { create(:email) }
+    #     association :account
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     email
+    #     account
+    #   end
+    #
+    # are equivilent.
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        @factory.define_attribute(Attribute::Implicit.new(name))
+      else
+        add_attribute(name, *args, &block)
+      end
+    end
+
+    # Adds an attribute that will have unique values generated by a sequence with
+    # a specified format.
+    #
+    # The result of:
+    #   factory :user do
+    #     sequence(:email) { |n| "person#{n}@example.com" }
+    #   end
+    #
+    # Is equal to:
+    #   sequence(:email) { |n| "person#{n}@example.com" }
+    #
+    #   factory :user do
+    #     email { FactoryGirl.create(:email) }
+    #   end
+    #
+    # Except that no globally available sequence will be defined.
+    def sequence(name, start_value = 1, &block)
+      sequence = Sequence.new(name, start_value, &block)
+      add_attribute(name) { sequence.next }
+    end
+
+    # Adds an attribute that builds an association. The associated instance will
+    # be built using the same build strategy as the parent instance.
+    #
+    # Example:
+    #   factory :user do
+    #     name 'Joey'
+    #   end
+    #
+    #   factory :post do
+    #     association :author, :factory => :user
+    #   end
+    #
+    # Arguments:
+    # * name: +Symbol+
+    #   The name of this attribute.
+    # * options: +Hash+
+    #
+    # Options:
+    # * factory: +Symbol+ or +String+
+    #    The name of the factory to use when building the associated instance.
+    #    If no name is given, the name of the attribute is assumed to be the
+    #    name of the factory. For example, a "user" association will by
+    #    default use the "user" factory.
+    def association(name, options = {})
+      factory_name = options.delete(:factory) || name
+      @factory.define_attribute(Attribute::Association.new(name, factory_name, options))
+    end
+
+    def after_build(&block)
+      @factory.add_callback(:after_build, &block)
+    end
+
+    def after_create(&block)
+      @factory.add_callback(:after_create, &block)
+    end
+
+    def after_stub(&block)
+      @factory.add_callback(:after_stub, &block)
+    end
+
+    def to_create(&block)
+      @factory.to_create(&block)
+    end
+  end
+end

data/lib/factory_girl/deprecated.rb

@@ -0,0 +1,18 @@
+module Factory
+  def self.method_missing(name, *args, &block)
+    if FactoryGirl.respond_to?(name)
+      $stderr.puts "DEPRECATION WARNING: Change Factory.#{name} to FactoryGirl.#{name}"
+      FactoryGirl.send(name, *args, &block)
+    else
+      super(name, *args, &block)
+    end
+  end
+
+  def self.const_missing(name)
+    if FactoryGirl.const_defined?(name)
+      FactoryGirl.const_get(name)
+    else
+      super(name)
+    end
+  end
+end

data/lib/factory_girl/factory.rb

@@ -0,0 +1,196 @@
+module FactoryGirl
+  # Raised when a factory is defined that attempts to instantiate itself.
+  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 Factory
+    attr_reader :name #:nodoc:
+    attr_reader :attributes #:nodoc:
+
+    def factory_name
+      puts "WARNING: factory.factory_name is deprecated. Use factory.name instead."
+      name
+    end
+
+    def class_name #:nodoc:
+      @options[:class] || name
+    end
+
+    def build_class #:nodoc:
+      @build_class ||= class_for(class_name)
+    end
+
+    def default_strategy #:nodoc:
+      @options[:default_strategy] || :create
+    end
+
+    def initialize(name, options = {}) #:nodoc:
+      assert_valid_options(options)
+      @name       = factory_name_for(name)
+      @options    = options
+      @attributes   = Attribute::List.new
+    end
+
+    def inherit_from(parent) #:nodoc:
+      @options[:class]            ||= parent.class_name
+      @options[:default_strategy] ||= parent.default_strategy
+
+      new_attributes = []
+      parent.attributes.each do |attribute|
+        unless attribute_defined?(attribute.name)
+          new_attributes << attribute.clone
+        end
+      end
+      @attributes.unshift *new_attributes
+    end
+
+    def define_attribute(attribute)
+      name = attribute.name
+      # TODO: move these checks into Attribute
+      if attribute_defined?(name)
+        raise AttributeDefinitionError, "Attribute already defined: #{name}"
+      end
+      if attribute.respond_to?(:factory) && attribute.factory == self.name
+        raise AssociationDefinitionError, "Self-referencing association '#{name}' in factory '#{self.name}'"
+      end
+      @attributes << attribute
+    end
+
+    def add_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
+
+    def run(proxy_class, overrides) #:nodoc:
+      proxy = proxy_class.new(build_class)
+      overrides = symbolize_keys(overrides)
+      overrides.each {|attr, val| proxy.set(attr, val) }
+      passed_keys = overrides.keys.collect {|k| FactoryGirl.aliases_for(k) }.flatten
+      @attributes.each do |attribute|
+        unless passed_keys.include?(attribute.name)
+          attribute.add_to(proxy)
+        end
+      end
+      proxy.result(@to_create_block)
+    end
+
+    def human_name(*args, &block)
+      name.to_s.gsub('_', ' ')
+    end
+
+    def associations
+      attributes.select {|attribute| attribute.association? }
+    end
+
+    # Names for this factory, including aliases.
+    #
+    # Example:
+    #
+    #   factory :user, :aliases => [:author] do
+    #     # ...
+    #   end
+    #
+    #   FactoryGirl.create(:author).class
+    #   # => User
+    #
+    # Because an attribute defined without a value or block will build an
+    # association with the same name, this allows associations to be defined
+    # without factories, such as:
+    #
+    #   factory :user, :aliases => [:author] do
+    #     # ...
+    #   end
+    #
+    #   factory :post do
+    #     author
+    #   end
+    #
+    #   FactoryGirl.create(:post).author.class
+    #   # => User
+    def names
+      [name] + (@options[:aliases] || [])
+    end
+
+    def to_create(&block)
+      @to_create_block = block
+    end
+
+    private
+
+    def class_for (class_or_to_s)
+      if class_or_to_s.respond_to?(:to_sym)
+        class_name = variable_name_to_class_name(class_or_to_s)
+        class_name.split('::').inject(Object) do |object, string|
+          object.const_get(string)
+        end
+      else
+        class_or_to_s
+      end
+    end
+
+    def factory_name_for(class_or_to_s)
+      if class_or_to_s.respond_to?(:to_sym)
+        class_or_to_s.to_sym
+      else
+        class_name_to_variable_name(class_or_to_s).to_sym
+      end
+    end
+
+    def attribute_defined? (name)
+      !@attributes.detect {|attr| attr.name == name && !attr.is_a?(Attribute::Callback) }.nil?
+    end
+
+    def assert_valid_options(options)
+      invalid_keys = options.keys - [:class, :parent, :default_strategy, :aliases]
+      unless invalid_keys == []
+        raise ArgumentError, "Unknown arguments: #{invalid_keys.inspect}"
+      end
+      if options[:default_strategy]
+        assert_valid_strategy(options[:default_strategy])
+        puts "WARNING: default_strategy is deprecated."
+        puts "Override to_create if you need to prevent a call to #save!."
+      end
+    end
+
+    def assert_valid_strategy(strategy)
+      unless Proxy.const_defined? variable_name_to_class_name(strategy)
+        raise ArgumentError, "Unknown strategy: #{strategy}"
+      end
+    end
+
+    # Based on ActiveSupport's underscore inflector
+    def class_name_to_variable_name(name)
+      name.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    # Based on ActiveSupport's camelize inflector
+    def variable_name_to_class_name(name)
+      name.to_s.
+        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
+      end
+    end
+
+  end
+end

data/lib/factory_girl/find_definitions.rb

@@ -0,0 +1,23 @@
+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
+    # "factories," "test/factories," and "spec/factories." Only the first
+    # 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:
+    definition_file_paths.each do |path|
+      require("#{path}.rb") if File.exists?("#{path}.rb")
+
+      if File.directory? path
+        Dir[File.join(path, '*.rb')].sort.each do |file|
+          require file
+        end
+      end
+    end
+  end
+end