factory_girl_kibiz0r 2.0.0.beta2

data/lib/factory_girl/proxy/attributes_for.rb

@@ -0,0 +1,21 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+    class AttributesFor < Proxy #:nodoc:
+      def initialize(klass)
+        @hash = {}
+      end
+
+      def get(attribute)
+        @hash[attribute]
+      end
+
+      def set(attribute, value)
+        @hash[attribute] = value
+      end
+
+      def result(to_create)
+        @hash
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/build.rb

@@ -0,0 +1,36 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+    class Build < Proxy #:nodoc:
+      def initialize(klass)
+        @instance = klass.new
+      end
+
+      def get(attribute)
+        if @instance.respond_to?(attribute)
+          @instance.send(attribute)
+        else
+          super
+        end
+      end
+
+      def set(attribute, value)
+        @instance.send(:"#{attribute}=", value)
+      end
+
+      def associate(name, factory_name, overrides)
+        factory = FactoryGirl.factory_by_name(factory_name)
+        set(name, factory.run(Proxy::Create, overrides))
+      end
+
+      def association(factory_name, overrides = {})
+        factory = FactoryGirl.factory_by_name(factory_name)
+        factory.run(Proxy::Create, overrides)
+      end
+
+      def result(to_create)
+        run_callbacks(:after_build)
+        @instance
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/create.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+    class Create < Build #:nodoc:
+      def result(to_create)
+        run_callbacks(:after_build)
+        if to_create
+          to_create.call(@instance)
+        else
+          @instance.save!
+        end
+        run_callbacks(:after_create)
+        @instance
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/stub.rb

@@ -0,0 +1,64 @@
+module FactoryGirl
+  class Proxy
+    class Stub < Proxy #:nodoc:
+      @@next_id = 1000
+
+      def initialize(klass)
+        @instance = klass.new
+        @instance.id = next_id
+        @instance.instance_eval do
+          def new_record?
+            id.nil?
+          end
+
+          def save(*args)
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def destroy(*args)
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def connection
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def reload
+            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"
+          end
+        end
+      end
+
+      def next_id
+        @@next_id += 1
+      end
+
+      def get(attribute)
+        @instance.send(attribute)
+      end
+
+      def set(attribute, value)
+        @instance.send(:"#{attribute}=", value)
+      end
+
+      def associate(name, factory_name, overrides)
+        factory = FactoryGirl.factory_by_name(factory_name)
+        set(name, factory.run(Proxy::Stub, overrides))
+      end
+
+      def association(factory_name, overrides = {})
+        factory = FactoryGirl.factory_by_name(factory_name)
+        factory.run(Proxy::Stub, overrides)
+      end
+
+      def result(to_create)
+        run_callbacks(:after_stub)
+        @instance
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy.rb

@@ -0,0 +1,87 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+
+    attr_reader :callbacks
+
+    def initialize(klass)
+    end
+
+    def get(attribute)
+      @ignored && @ignored[attribute]
+    end
+
+    def set(attribute, value)
+    end
+
+    def ignore(attribute, value)
+      @ignored = {}
+      @ignored[attribute] = value
+    end
+
+    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|
+          case block.arity
+            when 0 then block.call
+            when 2 then block.call(@instance, self)
+            else
+              block.call(@instance)
+          end
+        end
+      end
+    end
+
+    # Generates an association using the current build strategy.
+    #
+    # Arguments:
+    #   name: (Symbol)
+    #     The name of the factory that should be used to generate this
+    #     association.
+    #   attributes: (Hash)
+    #     A hash of attributes that should be overridden for this association.
+    #
+    # Returns:
+    #   The generated association for the current build strategy. Note that
+    #   associations are not generated for the attributes_for strategy. Returns
+    #   nil in this case.
+    #
+    # Example:
+    #
+    #   factory :user do
+    #     # ...
+    #   end
+    #
+    #   factory :post do
+    #     # ...
+    #     author { |post| post.association(:user, :name => 'Joe') }
+    #   end
+    #
+    #   # Builds (but doesn't save) a Post and a User
+    #   FactoryGirl.build(:post)
+    #
+    #   # Builds and saves a User, builds a Post, assigns the User to the
+    #   # author association, and saves the User.
+    #   FactoryGirl.create(:post)
+    #
+    def association(name, overrides = {})
+      nil
+    end
+
+    def method_missing(method, *args, &block)
+      get(method)
+    end
+
+    def result(to_create)
+      raise NotImplementedError, "Strategies must return a result"
+    end
+  end
+end

data/lib/factory_girl/rails2.rb

@@ -0,0 +1 @@
+Rails.configuration.after_initialize { FactoryGirl.find_definitions }

data/lib/factory_girl/registry.rb

@@ -0,0 +1,45 @@
+module FactoryGirl
+  class Registry
+    include Enumerable
+
+    def initialize
+      @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("Not registered: #{name.to_s}")
+    end
+
+    def each(&block)
+      @items.values.each(&block)
+    end
+
+    def [](name)
+      find(name)
+    end
+
+    def registered?(name)
+      @items.key?(name.to_sym)
+    end
+
+    def clear
+      @items.clear
+    end
+
+    private
+
+    def add_as(name, item)
+      if registered?(name)
+        raise DuplicateDefinitionError, "Already defined: #{name}"
+      else
+        @items[name.to_sym] = item
+      end
+    end
+  end
+end
+

data/lib/factory_girl/sequence.rb

@@ -0,0 +1,31 @@
+module FactoryGirl
+
+  # Raised when calling Factory.sequence from a dynamic attribute block
+  class SequenceAbuseError < StandardError; end
+
+  # Sequences are defined using sequence within a FactoryGirl.define block.
+  # Sequence values are generated using next.
+  class Sequence
+    attr_reader :name
+
+    def initialize(name, value = 1, &proc) #:nodoc:
+      @name = name
+      @proc  = proc
+      @value = value || 1
+    end
+
+    def next
+      @proc ? @proc.call(@value) : @value
+    ensure
+      @value = @value.next
+    end
+
+    def default_strategy
+      :create
+    end
+
+    def names
+      [@name]
+    end
+  end
+end

data/lib/factory_girl/step_definitions.rb

@@ -0,0 +1,60 @@
+module FactoryGirlStepHelpers
+
+  def convert_association_string_to_instance(factory_name, assignment)
+    attribute, value = assignment.split(':', 2)
+    return if value.blank?
+    factory = FactoryGirl.factory_by_name(factory_name)
+    attributes = convert_human_hash_to_attribute_hash({attribute => value.strip}, factory.associations)
+    attributes_find = {}
+    attributes.each do |k, v|
+      k = "#{k}_id" if v.is_a? ActiveRecord::Base
+      attributes_find[k] = v
+    end
+    model_class = factory.build_class
+    model_class.find(:first, :conditions => attributes_find) or
+      FactoryGirl.create(factory_name, attributes)
+  end
+
+  def convert_human_hash_to_attribute_hash(human_hash, associations = [])
+    human_hash.inject({}) do |attribute_hash, (human_key, value)|
+      key = human_key.downcase.gsub(' ', '_').to_sym
+      if association = associations.detect {|association| association.name == key }
+        value = convert_association_string_to_instance(association.factory, value)
+      end
+      attribute_hash.merge(key => value)
+    end
+  end
+end
+
+World(FactoryGirlStepHelpers)
+
+FactoryGirl.factories.each do |factory|
+  Given /^the following (?:#{factory.human_name}|#{factory.human_name.pluralize}) exists?:$/ do |table|
+    table.hashes.each do |human_hash|
+      attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)
+      factory.run(FactoryGirl::Proxy::Create, attributes)
+    end
+  end
+
+  Given /^an? #{factory.human_name} exists$/ do
+    FactoryGirl.create(factory.name)
+  end
+
+  Given /^(\d+) #{factory.human_name.pluralize} exist$/ do |count|
+    count.to_i.times { FactoryGirl.create(factory.name) }
+  end
+
+  if factory.build_class.respond_to?(:columns)
+    factory.build_class.columns.each do |column|
+      human_column_name = column.name.downcase.gsub('_', ' ')
+      Given /^an? #{factory.human_name} exists with an? #{human_column_name} of "([^"]*)"$/i do |value|
+        FactoryGirl.create(factory.name, column.name => value)
+      end
+
+      Given /^(\d+) #{factory.human_name.pluralize} exist with an? #{human_column_name} of "([^"]*)"$/i do |count, value|
+        count.to_i.times { FactoryGirl.create(factory.name, column.name => value) }
+      end
+    end
+  end
+end
+

data/lib/factory_girl/syntax/blueprint.rb

@@ -0,0 +1,42 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is an
+    # alternate syntax for defining factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/blueprint'
+    #
+    #   User.blueprint do
+    #     name  { 'Billy Bob'             }
+    #     email { 'billy@bob.example.com' }
+    #   end
+    #
+    #   FactoryGirl.create(:user, :name => 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Blueprint
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def blueprint(&block)
+            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
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Blueprint::ActiveRecord)

data/lib/factory_girl/syntax/default.rb

@@ -0,0 +1,33 @@
+module FactoryGirl
+  module Syntax
+    module Default
+      include Methods
+
+      def define(&block)
+        DSL.run(block)
+      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)
+          proxy.instance_eval(&block)
+          if parent = options.delete(:parent)
+            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+          end
+          FactoryGirl.register_factory(factory)
+        end
+
+        def sequence(name, start_value = 1, &block)
+          FactoryGirl.register_sequence(Sequence.new(name, start_value, &block))
+        end
+      end
+    end
+  end
+
+  extend Syntax::Default
+end

data/lib/factory_girl/syntax/generate.rb

@@ -0,0 +1,73 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide generation methods for factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/generate'
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       name 'Billy Bob'
+    #       email 'billy@bob.example.com'
+    #     end
+    #   end
+    #
+    #   # Creates a saved instance without raising (same as saving the result
+    #   # of FactoryGirl.build)
+    #   User.generate(:name => 'Johnny')
+    #
+    #   # Creates a saved instance and raises when invalid (same as
+    #   # FactoryGirl.create)
+    #   User.generate!
+    #
+    #   # Creates an unsaved instance (same as FactoryGirl.build)
+    #   User.spawn
+    #
+    #   # Creates an instance and yields it to the passed block
+    #   User.generate do |user|
+    #     # ...do something with user...
+    #   end
+    #
+    # This syntax was derived from Rick Bradley and Yossef Mendelssohn's
+    # object_daddy.
+    module Generate
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def generate(overrides = {}, &block)
+            factory = FactoryGirl.factory_by_name(name.underscore)
+            instance = factory.run(Proxy::Build, overrides)
+            instance.save
+            yield(instance) if block_given?
+            instance
+          end
+
+          def generate!(overrides = {}, &block)
+            factory = FactoryGirl.factory_by_name(name.underscore)
+            instance = factory.run(Proxy::Create, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+          def spawn(overrides = {}, &block)
+            factory = FactoryGirl.factory_by_name(name.underscore)
+            instance = factory.run(Proxy::Build, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Generate::ActiveRecord)

data/lib/factory_girl/syntax/make.rb

@@ -0,0 +1,41 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is a
+    # shortcut for FactoryGirl.create.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/make'
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       name 'Billy Bob'
+    #       email 'billy@bob.example.com'
+    #     end
+    #   end
+    #
+    #   User.make(:name => 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Make
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def make(overrides = {})
+            FactoryGirl.factory_by_name(name.underscore).run(Proxy::Create, overrides)
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Make::ActiveRecord)

data/lib/factory_girl/syntax/methods.rb

@@ -0,0 +1,86 @@
+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.
+      # * overrides: +Hash+
+      #   Attributes to overwrite for this set.
+      #
+      # 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 = {})
+        FactoryGirl.factory_by_name(name).run(Proxy::AttributesFor, overrides)
+      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.
+      # * overrides: +Hash+
+      #   Attributes to overwrite for this instance.
+      #
+      # Returns: +Object+
+      # An instance of the class this factory generates, with generated attributes
+      # assigned.
+      def build(name, overrides = {})
+        FactoryGirl.factory_by_name(name).run(Proxy::Build, overrides)
+      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.
+      # * overrides: +Hash+
+      #   Attributes to overwrite for this instance.
+      #
+      # Returns: +Object+
+      # A saved instance of the class this factory generates, with generated
+      # attributes assigned.
+      def create(name, overrides = {})
+        FactoryGirl.factory_by_name(name).run(Proxy::Create, overrides)
+      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.
+      # * overrides: +Hash+
+      #   Attributes to overwrite for this instance.
+      #
+      # Returns: +Object+
+      # An object with generated attributes stubbed out.
+      def build_stubbed(name, overrides = {})
+        FactoryGirl.factory_by_name(name).run(Proxy::Stub, overrides)
+      end
+
+      # Generates and returns the next value in a sequence.
+      #
+      # Arguments:
+      #   name: (Symbol)
+      #     The name of the sequence that a value should be generated for.
+      #
+      # Returns:
+      #   The next value in the sequence. (Object)
+      def generate(name)
+        FactoryGirl.sequence_by_name(name).next
+      end
+    end
+  end
+end

data/lib/factory_girl/syntax/sham.rb

@@ -0,0 +1,45 @@
+module FactoryGirl
+  module Syntax
+
+    # Adds a Sham module, which provides an alternate interface to
+    # FactoryGirl::Sequence.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/sham'
+    #
+    #   Sham.email {|n| "somebody#{n}@example.com" }
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       email
+    #     end
+    #   end
+    #
+    # Note that you can also use Faker, but it is recommended that you simply
+    # use a sequence as in the above example, as factory_girl does not provide
+    # protection against duplication in randomized sequences, and a randomized
+    # value does not provide any tangible benefits over an ascending sequence.
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Sham
+      module Sham #:nodoc:
+        def self.method_missing(name, *args, &block)
+          if block_given?
+            start_value = args.first
+            FactoryGirl.register_sequence(Sequence.new(name, start_value || 1, &block))
+          else
+            FactoryGirl.sequence_by_name(name).next
+          end
+        end
+
+        # overrides name on Module
+        def self.name(&block)
+          method_missing('name', &block)
+        end
+      end
+    end
+  end
+end
+
+include FactoryGirl::Syntax::Sham