ffactory_girl 4.8.1

data/lib/factory_girl/definition.rb

@@ -0,0 +1,136 @@
+module FactoryGirl
+  # @api private
+  class Definition
+    attr_reader :defined_traits, :declarations
+
+    def initialize(name = nil, base_traits = [])
+      @declarations      = DeclarationList.new(name)
+      @callbacks         = []
+      @defined_traits    = Set.new
+      @to_create         = nil
+      @base_traits       = base_traits
+      @additional_traits = []
+      @constructor       = nil
+      @attributes        = nil
+      @compiled          = false
+    end
+
+    delegate :declare_attribute, to: :declarations
+
+    def attributes
+      @attributes ||= AttributeList.new.tap do |attribute_list|
+        attribute_lists = aggregate_from_traits_and_self(:attributes) { declarations.attributes }
+        attribute_lists.each do |attributes|
+          attribute_list.apply_attributes attributes
+        end
+      end
+    end
+
+    def to_create(&block)
+      if block_given?
+        @to_create = block
+      else
+        aggregate_from_traits_and_self(:to_create) { @to_create }.last
+      end
+    end
+
+    def constructor
+      aggregate_from_traits_and_self(:constructor) { @constructor }.last
+    end
+
+    def callbacks
+      aggregate_from_traits_and_self(:callbacks) { @callbacks }
+    end
+
+    def compile
+      unless @compiled
+        declarations.attributes
+
+        defined_traits.each do |defined_trait|
+          base_traits.each       { |bt| bt.define_trait defined_trait }
+          additional_traits.each { |bt| bt.define_trait defined_trait }
+        end
+
+        @compiled = true
+      end
+    end
+
+    def overridable
+      declarations.overridable
+      self
+    end
+
+    def inherit_traits(new_traits)
+      @base_traits += new_traits
+    end
+
+    def append_traits(new_traits)
+      @additional_traits += new_traits
+    end
+
+    def add_callback(callback)
+      @callbacks << callback
+    end
+
+    def skip_create
+      @to_create = ->(instance) { }
+    end
+
+    def define_trait(trait)
+      @defined_traits.add(trait)
+    end
+
+    def define_constructor(&block)
+      @constructor = block
+    end
+
+    def before(*names, &block)
+      callback(*names.map { |name| "before_#{name}" }, &block)
+    end
+
+    def after(*names, &block)
+      callback(*names.map { |name| "after_#{name}" }, &block)
+    end
+
+    def callback(*names, &block)
+      names.each do |name|
+        FactoryGirl.register_callback(name)
+        add_callback(Callback.new(name, block))
+      end
+    end
+
+    private
+
+    def base_traits
+      @base_traits.map { |name| trait_by_name(name) }
+    end
+
+    def additional_traits
+      @additional_traits.map { |name| trait_by_name(name) }
+    end
+
+    def trait_by_name(name)
+      trait_for(name) || FactoryGirl.trait_by_name(name)
+    end
+
+    def trait_for(name)
+      defined_traits.detect { |trait| trait.name == name }
+    end
+
+    def initialize_copy(source)
+      super
+      @attributes = nil
+      @compiled   = false
+    end
+
+    def aggregate_from_traits_and_self(method_name, &block)
+      compile
+
+      [
+        base_traits.map(&method_name),
+        instance_exec(&block),
+        additional_traits.map(&method_name),
+      ].flatten.compact
+    end
+  end
+end

data/lib/factory_girl/definition_hierarchy.rb

@@ -0,0 +1,48 @@
+module FactoryGirl
+  class DefinitionHierarchy
+    def callbacks
+      FactoryGirl.callbacks
+    end
+
+    def constructor
+      FactoryGirl.constructor
+    end
+
+    def to_create
+      FactoryGirl.to_create
+    end
+
+    def self.build_from_definition(definition)
+      build_to_create(&definition.to_create)
+      build_constructor(&definition.constructor)
+      add_callbacks definition.callbacks
+    end
+
+    def self.add_callbacks(callbacks)
+      if callbacks.any?
+        define_method :callbacks do
+          super() + callbacks
+        end
+      end
+    end
+    private_class_method :add_callbacks
+
+    def self.build_constructor(&block)
+      if block
+        define_method(:constructor) do
+          block
+        end
+      end
+    end
+    private_class_method :build_constructor
+
+    def self.build_to_create(&block)
+      if block
+        define_method(:to_create) do
+          block
+        end
+      end
+    end
+    private_class_method :build_to_create
+  end
+end

data/lib/factory_girl/definition_proxy.rb

@@ -0,0 +1,174 @@
+module FactoryGirl
+  class DefinitionProxy
+    UNPROXIED_METHODS = %w(__send__ __id__ nil? send object_id extend instance_eval initialize block_given? raise caller method)
+
+    (instance_methods + private_instance_methods).each do |method|
+      undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
+    end
+
+    delegate :before, :after, :callback, to: :@definition
+
+    attr_reader :child_factories
+
+    def initialize(definition, ignore = false)
+      @definition      = definition
+      @ignore          = ignore
+      @child_factories = []
+    end
+
+    def singleton_method_added(name)
+      message = "Defining methods in blocks (trait or factory) is not supported (#{name})"
+      raise FactoryGirl::MethodDefinitionError, message
+    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::Strategy 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)
+      raise AttributeDefinitionError, 'Both value and block given' if value && block_given?
+
+      declaration = if block_given?
+        Declaration::Dynamic.new(name, @ignore, block)
+      else
+        Declaration::Static.new(name, value, @ignore)
+      end
+
+      @definition.declare_attribute(declaration)
+    end
+
+    def ignore(&block)
+      ActiveSupport::Deprecation.warn "`#ignore` is deprecated and will be "\
+        "removed in 5.0. Please use `#transient` instead."
+      transient(&block)
+    end
+
+    def transient(&block)
+      proxy = DefinitionProxy.new(@definition, true)
+      proxy.instance_eval(&block)
+    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 equivalent.
+    #
+    # 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 equivalent.
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        @definition.declare_attribute(Declaration::Implicit.new(name, @definition, @ignore))
+      elsif args.first.respond_to?(:has_key?) && args.first.has_key?(:factory)
+        association(name, *args)
+      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.generate(:email) }
+    #   end
+    #
+    # Except that no globally available sequence will be defined.
+    def sequence(name, *args, &block)
+      sequence = Sequence.new(name, *args, &block)
+      add_attribute(name) { increment_sequence(sequence) }
+    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)
+      @definition.declare_attribute(Declaration::Association.new(name, *options))
+    end
+
+    def to_create(&block)
+      @definition.to_create(&block)
+    end
+
+    def skip_create
+      @definition.skip_create
+    end
+
+    def factory(name, options = {}, &block)
+      @child_factories << [name, options, block]
+    end
+
+    def trait(name, &block)
+      @definition.define_trait(Trait.new(name, &block))
+    end
+
+    def initialize_with(&block)
+      @definition.define_constructor(&block)
+    end
+  end
+end

data/lib/factory_girl/errors.rb

@@ -0,0 +1,25 @@
+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
+
+  # Raised when attempting to register a sequence from a dynamic attribute block
+  class SequenceAbuseError < RuntimeError; end
+
+  # 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
+
+  # Raised when a method is defined in a factory or trait with arguments
+  class MethodDefinitionError < RuntimeError; end
+
+  # Raised when any factory is considered invalid
+  class InvalidFactoryError < RuntimeError; end
+end

data/lib/factory_girl/evaluation.rb

@@ -0,0 +1,27 @@
+require 'observer'
+
+module FactoryGirl
+  class Evaluation
+    include Observable
+
+    def initialize(evaluator, attribute_assigner, to_create)
+      @evaluator = evaluator
+      @attribute_assigner = attribute_assigner
+      @to_create = to_create
+    end
+
+    delegate :object, :hash, to: :@attribute_assigner
+
+    def create(result_instance)
+      case @to_create.arity
+      when 2 then @to_create[result_instance, @evaluator]
+      else @to_create[result_instance]
+      end
+    end
+
+    def notify(name, result_instance)
+      changed
+      notify_observers(name, result_instance)
+    end
+  end
+end

data/lib/factory_girl/evaluator.rb

@@ -0,0 +1,82 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/class/attribute'
+
+module FactoryGirl
+  # @api private
+  class Evaluator
+    class_attribute :attribute_lists
+
+    private_instance_methods.each do |method|
+      undef_method(method) unless method =~ /^__|initialize/
+    end
+
+    def initialize(build_strategy, overrides = {})
+      @build_strategy = build_strategy
+      @overrides = overrides
+      @cached_attributes = overrides
+      @instance = nil
+
+      @overrides.each do |name, value|
+        singleton_class.define_attribute(name) { value }
+      end
+    end
+
+    def association(factory_name, *traits_and_overrides)
+      overrides = traits_and_overrides.extract_options!
+      strategy_override = overrides.fetch(:strategy) do
+        FactoryGirl.use_parent_strategy ? @build_strategy.class : :create
+      end
+
+      traits_and_overrides += [overrides.except(:strategy)]
+
+      runner = FactoryRunner.new(factory_name, strategy_override, traits_and_overrides)
+      @build_strategy.association(runner)
+    end
+
+    def instance=(object_instance)
+      @instance = object_instance
+    end
+
+    def method_missing(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
+
+    def respond_to_missing?(method_name, include_private = false)
+      @instance.respond_to?(method_name) || SyntaxRunner.new.respond_to?(method_name)
+    end
+
+    def __override_names__
+      @overrides.keys
+    end
+
+    def increment_sequence(sequence)
+      sequence.next(self)
+    end
+
+    def self.attribute_list
+      AttributeList.new.tap do |list|
+        attribute_lists.each do |attribute_list|
+          list.apply_attributes attribute_list.to_a
+        end
+      end
+    end
+
+    def self.define_attribute(name, &block)
+      if method_defined?(name) || private_method_defined?(name)
+        undef_method(name)
+      end
+
+      define_method(name) do
+        if @cached_attributes.key?(name)
+          @cached_attributes[name]
+        else
+          @cached_attributes[name] = instance_exec(&block)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/evaluator_class_definer.rb

@@ -0,0 +1,20 @@
+module FactoryGirl
+  # @api private
+  class EvaluatorClassDefiner
+    def initialize(attributes, parent_class)
+      @parent_class = parent_class
+      @attributes   = attributes
+
+      attributes.each do |attribute|
+        evaluator_class.define_attribute(attribute.name, &attribute.to_proc)
+      end
+    end
+
+    def evaluator_class
+      @evaluator_class ||= Class.new(@parent_class).tap do |klass|
+        klass.attribute_lists ||= []
+        klass.attribute_lists += [@attributes]
+      end
+    end
+  end
+end

data/lib/factory_girl/factory.rb

@@ -0,0 +1,163 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/inflector'
+
+module FactoryGirl
+  # @api private
+  class Factory
+    attr_reader :name, :definition
+
+    def initialize(name, options = {})
+      assert_valid_options(options)
+      @name             = name.respond_to?(:to_sym) ? name.to_sym : name.to_s.underscore.to_sym
+      @parent           = options[:parent]
+      @aliases          = options[:aliases] || []
+      @class_name       = options[:class]
+      @definition       = Definition.new(@name, options[:traits] || [])
+      @compiled         = false
+    end
+
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
+             :defined_traits, :inherit_traits, :append_traits, to: :@definition
+
+    def build_class
+      @build_class ||= if class_name.is_a? Class
+        class_name
+      else
+        class_name.to_s.camelize.constantize
+      end
+    end
+
+    def run(build_strategy, overrides, &block)
+      block ||= ->(result) { result }
+      compile
+
+      strategy = StrategyCalculator.new(build_strategy).strategy.new
+
+      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
+      attribute_assigner = AttributeAssigner.new(evaluator, build_class, &compiled_constructor)
+
+      evaluation =
+        Evaluation.new(evaluator, attribute_assigner, compiled_to_create)
+      evaluation.add_observer(CallbacksObserver.new(callbacks, evaluator))
+
+      strategy.result(evaluation).tap(&block)
+    end
+
+    def human_names
+      names.map { |name| name.to_s.humanize.downcase }
+    end
+
+    def associations
+      evaluator_class.attribute_list.associations
+    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] + @aliases
+    end
+
+    def compile
+      unless @compiled
+        parent.compile
+        parent.defined_traits.each { |trait| define_trait(trait) }
+        @definition.compile
+        build_hierarchy
+        @compiled = true
+      end
+    end
+
+    def with_traits(traits)
+      self.clone.tap do |factory_with_traits|
+        factory_with_traits.append_traits traits
+      end
+    end
+
+    protected
+
+    def class_name
+      @class_name || parent.class_name || name
+    end
+
+    def evaluator_class
+      @evaluator_class ||= EvaluatorClassDefiner.new(attributes, parent.evaluator_class).evaluator_class
+    end
+
+    def attributes
+      compile
+      AttributeList.new(@name).tap do |list|
+        list.apply_attributes definition.attributes
+      end
+    end
+
+    def hierarchy_class
+      @hierarchy_class ||= Class.new(parent.hierarchy_class)
+    end
+
+    def hierarchy_instance
+      @hierarchy_instance ||= hierarchy_class.new
+    end
+
+    def build_hierarchy
+      hierarchy_class.build_from_definition definition
+    end
+
+    def callbacks
+      hierarchy_instance.callbacks
+    end
+
+    def compiled_to_create
+      hierarchy_instance.to_create
+    end
+
+    def compiled_constructor
+      hierarchy_instance.constructor
+    end
+
+    private
+
+    def assert_valid_options(options)
+      options.assert_valid_keys(:class, :parent, :aliases, :traits)
+    end
+
+    def parent
+      if @parent
+        FactoryGirl.factory_by_name(@parent)
+      else
+        NullFactory.new
+      end
+    end
+
+    def initialize_copy(source)
+      super
+      @definition = @definition.clone
+      @evaluator_class = nil
+      @hierarchy_class = nil
+      @hierarchy_instance = nil
+      @compiled = false
+    end
+  end
+end

data/lib/factory_girl/factory_runner.rb

@@ -0,0 +1,33 @@
+module FactoryGirl
+  class FactoryRunner
+    def initialize(name, strategy, traits_and_overrides)
+      @name     = name
+      @strategy = strategy
+
+      @overrides = traits_and_overrides.extract_options!
+      @traits    = traits_and_overrides
+    end
+
+    def run(runner_strategy = @strategy, &block)
+      factory = FactoryGirl.factory_by_name(@name)
+
+      factory.compile
+
+      if @traits.any?
+        factory = factory.with_traits(@traits)
+      end
+
+      instrumentation_payload = {
+        name: @name,
+        strategy: runner_strategy,
+        traits: @traits,
+        overrides: @overrides,
+        factory: factory
+      }
+
+      ActiveSupport::Notifications.instrument('factory_girl.run_factory', instrumentation_payload) do
+        factory.run(runner_strategy, @overrides, &block)
+      end
+    end
+  end
+end