vitalish-factory_girl 1.2.4

data/lib/factory_girl/attribute.rb

@@ -0,0 +1,29 @@
+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
+  end
+
+end

data/lib/factory_girl/attribute/association.rb

@@ -0,0 +1,20 @@
+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
+    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,20 @@
+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_eval(&@block)
+        if FactoryGirl::Sequence === value
+          raise SequenceAbuseError
+        end
+        proxy.set(name, value)
+      end
+    end
+
+  end
+end

data/lib/factory_girl/attribute/static.rb

@@ -0,0 +1,17 @@
+module FactoryGirl
+  class Attribute #:nodoc:
+
+    class Static < Attribute  #:nodoc:
+
+      def initialize(name, value)
+        super(name)
+        @value = value
+      end
+
+      def add_to(proxy)
+        proxy.set(name, @value)
+      end
+    end
+
+  end
+end

data/lib/factory_girl/factory.rb

@@ -0,0 +1,215 @@
+module FactoryGirl
+  class << self
+    attr_accessor :factories #:nodoc:
+  end
+
+  self.factories = {}
+
+  def self.factory_by_name(name)
+    factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
+  end
+
+  def self.register_factory(factory, options = {})
+    if options[:as]
+      name = options[:as]
+    else
+      name = factory.name
+      factory.aliases.each do |alias_name|
+        register_factory(factory, :as => alias_name)
+      end
+    end
+
+    if self.factories[name]
+      raise DuplicateDefinitionError, "Factory already defined: #{name}"
+    end
+
+    self.factories[name] = factory
+  end
+
+  # 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 = []
+    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
+    end
+
+    def human_name(*args, &block)
+      name.to_s.gsub('_', ' ')
+    end
+
+    def associations
+      attributes.select {|attribute| attribute.is_a?(Attribute::Association) }
+    end
+
+    # Alternate names for this factory.
+    #
+    # Example:
+    #
+    #   factory :user, :aliases => [:author] do
+    #     # ...
+    #   end
+    #
+    #   Factory(: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
+    #
+    #   Factory(:post).author.class
+    #   # => User
+    def aliases
+      @options[:aliases] || []
+    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
+      assert_valid_strategy(options[:default_strategy]) if options[:default_strategy]
+    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/proxy.rb

@@ -0,0 +1,77 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+
+    attr_reader :callbacks
+
+    def initialize(klass)
+    end
+
+    def get(attribute)
+      nil
+    end
+
+    def set(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|
+          block.arity.zero? ? block.call : block.call(@instance)
+        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
+    #   Factory.build(:post)
+    #
+    #   # Builds and saves a User, builds a Post, assigns the User to the
+    #   # author association, and saves the User.
+    #   Factory.create(:post)
+    #
+    def association(name, overrides = {})
+      nil
+    end
+
+    def method_missing(method, *args, &block)
+      get(method)
+    end
+
+    def result
+      raise NotImplementedError, "Strategies must return a result"
+    end
+  end
+end

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
+        @hash
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/build.rb

@@ -0,0 +1,32 @@
+module FactoryGirl
+  class Proxy #:nodoc:
+    class Build < Proxy #:nodoc:
+      def initialize(klass)
+        @instance = klass.new
+      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::Create, overrides))
+      end
+
+      def association(factory_name, overrides = {})
+        factory = FactoryGirl.factory_by_name(factory_name)
+        factory.run(Proxy::Create, overrides)
+      end
+
+      def result
+        run_callbacks(:after_build)
+        @instance
+      end
+    end
+  end
+end