ffactory_girl 4.8.1

data/lib/factory_girl/attribute.rb

@@ -0,0 +1,62 @@
+require 'factory_girl/attribute/static'
+require 'factory_girl/attribute/dynamic'
+require 'factory_girl/attribute/association'
+require 'factory_girl/attribute/sequence'
+
+module FactoryGirl
+  # @api private
+  class Attribute
+    attr_reader :name, :ignored
+
+    def initialize(name, ignored)
+      @name = name.to_sym
+      @ignored = ignored
+      ensure_non_attribute_writer!
+    end
+
+    def to_proc
+      -> { }
+    end
+
+    def association?
+      false
+    end
+
+    def alias_for?(attr)
+      FactoryGirl.aliases_for(attr).include?(name)
+    end
+
+    private
+
+    def ensure_non_attribute_writer!
+      NonAttributeWriterValidator.new(@name).validate!
+    end
+
+    class NonAttributeWriterValidator
+      def initialize(method_name)
+        @method_name = method_name.to_s
+        @method_name_setter_match = @method_name.match(/(.*)=$/)
+      end
+
+      def validate!
+        if method_is_writer?
+          raise AttributeDefinitionError, error_message
+        end
+      end
+
+      private
+
+      def method_is_writer?
+        !!@method_name_setter_match
+      end
+
+      def attribute_name
+        @method_name_setter_match[1]
+      end
+
+      def error_message
+        "factory_girl uses '#{attribute_name} value' syntax rather than '#{attribute_name} = value'"
+      end
+    end
+  end
+end

data/lib/factory_girl/attribute_assigner.rb

@@ -0,0 +1,97 @@
+module FactoryGirl
+  # @api private
+  class AttributeAssigner
+    def initialize(evaluator, build_class, &instance_builder)
+      @build_class = build_class
+      @instance_builder         = instance_builder
+      @evaluator                = evaluator
+      @attribute_list           = evaluator.class.attribute_list
+      @attribute_names_assigned = []
+    end
+
+    def object
+      @evaluator.instance = build_class_instance
+      build_class_instance.tap do |instance|
+        attributes_to_set_on_instance.each do |attribute|
+          instance.public_send("#{attribute}=", get(attribute))
+          @attribute_names_assigned << attribute
+        end
+      end
+    end
+
+    def hash
+      @evaluator.instance = build_hash
+
+      attributes_to_set_on_hash.inject({}) do |result, attribute|
+        result[attribute] = get(attribute)
+        result
+      end
+    end
+
+    private
+
+    def method_tracking_evaluator
+      @method_tracking_evaluator ||= Decorator::AttributeHash.new(decorated_evaluator, attribute_names_to_assign)
+    end
+
+    def decorated_evaluator
+      Decorator::InvocationTracker.new(
+        Decorator::NewConstructor.new(@evaluator, @build_class)
+      )
+    end
+
+    def methods_invoked_on_evaluator
+      method_tracking_evaluator.__invoked_methods__
+    end
+
+    def build_class_instance
+      @build_class_instance ||= method_tracking_evaluator.instance_exec(&@instance_builder)
+    end
+
+    def build_hash
+      @build_hash ||= NullObject.new(hash_instance_methods_to_respond_to)
+    end
+
+    def get(attribute_name)
+      @evaluator.send(attribute_name)
+    end
+
+    def attributes_to_set_on_instance
+      (attribute_names_to_assign - @attribute_names_assigned - methods_invoked_on_evaluator).uniq
+    end
+
+    def attributes_to_set_on_hash
+      attribute_names_to_assign - association_names
+    end
+
+    def attribute_names_to_assign
+      @attribute_names_to_assign ||= non_ignored_attribute_names + override_names - ignored_attribute_names - alias_names_to_ignore
+    end
+
+    def non_ignored_attribute_names
+      @attribute_list.non_ignored.names
+    end
+
+    def ignored_attribute_names
+      @attribute_list.ignored.names
+    end
+
+    def association_names
+      @attribute_list.associations.names
+    end
+
+    def override_names
+      @evaluator.__override_names__
+    end
+
+    def hash_instance_methods_to_respond_to
+      @attribute_list.names + override_names + @build_class.instance_methods
+    end
+
+    def alias_names_to_ignore
+      @attribute_list.non_ignored.flat_map do |attribute|
+        override_names.map { |override| attribute.name if attribute.alias_for?(override) && attribute.name != override && !ignored_attribute_names.include?(override) }
+      end.compact
+    end
+  end
+end

data/lib/factory_girl/attribute_list.rb

@@ -0,0 +1,67 @@
+module FactoryGirl
+  # @api private
+  class AttributeList
+    include Enumerable
+
+    def initialize(name = nil, attributes = [])
+      @name       = name
+      @attributes = attributes
+    end
+
+    def define_attribute(attribute)
+      ensure_attribute_not_self_referencing! attribute
+      ensure_attribute_not_defined! attribute
+
+      add_attribute attribute
+    end
+
+    def each(&block)
+      @attributes.each(&block)
+    end
+
+    def names
+      map(&:name)
+    end
+
+    def associations
+      AttributeList.new(@name, select(&:association?))
+    end
+
+    def ignored
+      AttributeList.new(@name, select(&:ignored))
+    end
+
+    def non_ignored
+      AttributeList.new(@name, reject(&:ignored))
+    end
+
+    def apply_attributes(attributes_to_apply)
+      attributes_to_apply.each { |attribute| add_attribute(attribute) }
+    end
+
+    private
+
+    def add_attribute(attribute)
+      @attributes << attribute
+      attribute
+    end
+
+    def ensure_attribute_not_defined!(attribute)
+      if attribute_defined?(attribute.name)
+        raise AttributeDefinitionError, "Attribute already defined: #{attribute.name}"
+      end
+    end
+
+    def ensure_attribute_not_self_referencing!(attribute)
+      if attribute.respond_to?(:factory) && attribute.factory == @name
+        raise AssociationDefinitionError, "Self-referencing association '#{attribute.name}' in '#{attribute.factory}'"
+      end
+    end
+
+    def attribute_defined?(attribute_name)
+      @attributes.any? do |attribute|
+        attribute.name == attribute_name
+      end
+    end
+  end
+end

data/lib/factory_girl/callback.rb

@@ -0,0 +1,40 @@
+module FactoryGirl
+  class Callback
+    attr_reader :name
+
+    def initialize(name, block)
+      @name  = name.to_sym
+      @block = block
+      ensure_valid_callback_name!
+    end
+
+    def run(instance, evaluator)
+      case block.arity
+      when 1, -1 then syntax_runner.instance_exec(instance, &block)
+      when 2 then syntax_runner.instance_exec(instance, evaluator, &block)
+      else        syntax_runner.instance_exec(&block)
+      end
+    end
+
+    def ==(other)
+      name == other.name &&
+        block == other.block
+    end
+
+    protected
+    attr_reader :block
+
+    private
+
+    def ensure_valid_callback_name!
+      unless FactoryGirl.callback_names.include?(name)
+        raise InvalidCallbackNameError, "#{name} is not a valid callback name. " +
+          "Valid callback names are #{FactoryGirl.callback_names.inspect}"
+      end
+    end
+
+    def syntax_runner
+      @syntax_runner ||= SyntaxRunner.new
+    end
+  end
+end

data/lib/factory_girl/callbacks_observer.rb

@@ -0,0 +1,21 @@
+module FactoryGirl
+  # @api private
+  class CallbacksObserver
+    def initialize(callbacks, evaluator)
+      @callbacks = callbacks
+      @evaluator = evaluator
+    end
+
+    def update(name, result_instance)
+      callbacks_by_name(name).each do |callback|
+        callback.run(result_instance, @evaluator)
+      end
+    end
+
+    private
+
+    def callbacks_by_name(name)
+      @callbacks.select { |callback| callback.name == name }
+    end
+  end
+end

data/lib/factory_girl/configuration.rb

@@ -0,0 +1,37 @@
+module FactoryGirl
+  # @api private
+  class Configuration
+    attr_reader :factories, :sequences, :traits, :strategies, :callback_names
+
+    attr_accessor :allow_class_lookup, :use_parent_strategy
+
+    def initialize
+      @factories      = Decorator::DisallowsDuplicatesRegistry.new(Registry.new('Factory'))
+      @sequences      = Decorator::DisallowsDuplicatesRegistry.new(Registry.new('Sequence'))
+      @traits         = Decorator::DisallowsDuplicatesRegistry.new(Registry.new('Trait'))
+      @strategies     = Registry.new('Strategy')
+      @callback_names = Set.new
+      @definition     = Definition.new
+
+      @allow_class_lookup = true
+
+      to_create { |instance| instance.save! }
+      initialize_with { new }
+    end
+
+    delegate :to_create, :skip_create, :constructor, :before, :after,
+      :callback, :callbacks, to: :@definition
+
+    def initialize_with(&block)
+      @definition.define_constructor(&block)
+    end
+
+    def duplicate_attribute_assignment_from_initialize_with
+      false
+    end
+
+    def duplicate_attribute_assignment_from_initialize_with=(value)
+      ActiveSupport::Deprecation.warn 'Assignment of duplicate_attribute_assignment_from_initialize_with is unnecessary as this is now default behavior in FactoryGirl 4.0; this line can be removed', caller
+    end
+  end
+end

data/lib/factory_girl/declaration/association.rb

@@ -0,0 +1,28 @@
+module FactoryGirl
+  class Declaration
+    # @api private
+    class Association < Declaration
+      def initialize(name, *options)
+        super(name, false)
+        @options = options.dup
+        @overrides = options.extract_options!
+        @traits = options
+      end
+
+      def ==(other)
+        name == other.name &&
+          options == other.options
+      end
+
+      protected
+      attr_reader :options
+
+      private
+
+      def build
+        factory_name = @overrides[:factory] || name
+        [Attribute::Association.new(name, factory_name, [@traits, @overrides.except(:factory)].flatten)]
+      end
+    end
+  end
+end

data/lib/factory_girl/declaration/dynamic.rb

@@ -0,0 +1,26 @@
+module FactoryGirl
+  class Declaration
+    # @api private
+    class Dynamic < Declaration
+      def initialize(name, ignored = false, block = nil)
+        super(name, ignored)
+        @block = block
+      end
+
+      def ==(other)
+        name == other.name &&
+          ignored == other.ignored &&
+          block == other.block
+      end
+
+      protected
+      attr_reader :block
+
+      private
+
+      def build
+        [Attribute::Dynamic.new(name, @ignored, @block)]
+      end
+    end
+  end
+end

data/lib/factory_girl/declaration/implicit.rb

@@ -0,0 +1,33 @@
+module FactoryGirl
+  class Declaration
+    # @api private
+    class Implicit < Declaration
+      def initialize(name, factory = nil, ignored = false)
+        super(name, ignored)
+        @factory = factory
+      end
+
+      def ==(other)
+        name == other.name &&
+          factory == other.factory &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :factory
+
+      private
+
+      def build
+        if FactoryGirl.factories.registered?(name)
+          [Attribute::Association.new(name, name, {})]
+        elsif FactoryGirl.sequences.registered?(name)
+          [Attribute::Sequence.new(name, name, @ignored)]
+        else
+          @factory.inherit_traits([name])
+          []
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/declaration/static.rb

@@ -0,0 +1,26 @@
+module FactoryGirl
+  class Declaration
+    # @api private
+    class Static < Declaration
+      def initialize(name, value, ignored = false)
+        super(name, ignored)
+        @value = value
+      end
+
+      def ==(other)
+        name == other.name &&
+          value == other.value &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :value
+
+      private
+
+      def build
+        [Attribute::Static.new(name, @value, @ignored)]
+      end
+    end
+  end
+end

data/lib/factory_girl/declaration.rb

@@ -0,0 +1,23 @@
+require 'factory_girl/declaration/static'
+require 'factory_girl/declaration/dynamic'
+require 'factory_girl/declaration/association'
+require 'factory_girl/declaration/implicit'
+
+module FactoryGirl
+  # @api private
+  class Declaration
+    attr_reader :name
+
+    def initialize(name, ignored = false)
+      @name    = name
+      @ignored = ignored
+    end
+
+    def to_attributes
+      build
+    end
+
+    protected
+    attr_reader :ignored
+  end
+end

data/lib/factory_girl/declaration_list.rb

@@ -0,0 +1,49 @@
+module FactoryGirl
+  # @api private
+  class DeclarationList
+    include Enumerable
+
+    def initialize(name = nil)
+      @declarations = []
+      @name         = name
+      @overridable  = false
+    end
+
+    def declare_attribute(declaration)
+      delete_declaration(declaration) if overridable?
+
+      @declarations << declaration
+      declaration
+    end
+
+    def overridable
+      @overridable = true
+    end
+
+    def attributes
+      @attributes ||= AttributeList.new(@name).tap do |list|
+        to_attributes.each do |attribute|
+          list.define_attribute(attribute)
+        end
+      end
+    end
+
+    def each(&block)
+      @declarations.each(&block)
+    end
+
+    private
+
+    def delete_declaration(declaration)
+      @declarations.delete_if { |decl| decl.name == declaration.name }
+    end
+
+    def to_attributes
+      @declarations.inject([]) { |result, declaration| result += declaration.to_attributes }
+    end
+
+    def overridable?
+      @overridable
+    end
+  end
+end

data/lib/factory_girl/decorator/attribute_hash.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Decorator
+    class AttributeHash < Decorator
+      def initialize(component, attributes = [])
+        super(component)
+        @attributes = attributes
+      end
+
+      def attributes
+        @attributes.each_with_object({}) do |attribute_name, result|
+          result[attribute_name] = send(attribute_name)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/decorator/class_key_hash.rb

@@ -0,0 +1,28 @@
+module FactoryGirl
+  class Decorator
+    class ClassKeyHash < Decorator
+      def [](key)
+        @component[symbolized_key key]
+      end
+
+      def []=(key, value)
+        @component[symbolized_key key] = value
+      end
+
+      def key?(key)
+        @component.key? symbolized_key(key)
+      end
+
+      private
+
+      def symbolized_key(key)
+        if key.respond_to?(:to_sym)
+          key.to_sym
+        elsif FactoryGirl.allow_class_lookup
+          ActiveSupport::Deprecation.warn "Looking up factories by class is deprecated and will be removed in 5.0. Use symbols instead and set FactoryGirl.allow_class_lookup = false", caller
+          key.to_s.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/decorator/disallows_duplicates_registry.rb

@@ -0,0 +1,13 @@
+module FactoryGirl
+  class Decorator
+    class DisallowsDuplicatesRegistry < Decorator
+      def register(name, item)
+        if registered?(name)
+          raise DuplicateDefinitionError, "#{@component.name} already registered: #{name}"
+        else
+          @component.register(name, item)
+        end
+      end
+    end
+  end
+end

data/lib/factory_girl/decorator/invocation_tracker.rb

@@ -0,0 +1,19 @@
+module FactoryGirl
+  class Decorator
+    class InvocationTracker < Decorator
+      def initialize(component)
+        super
+        @invoked_methods = []
+      end
+
+      def method_missing(name, *args, &block)
+        @invoked_methods << name
+        super
+      end
+
+      def __invoked_methods__
+        @invoked_methods.uniq
+      end
+    end
+  end
+end

data/lib/factory_girl/decorator/new_constructor.rb

@@ -0,0 +1,12 @@
+module FactoryGirl
+  class Decorator
+    class NewConstructor < Decorator
+      def initialize(component, build_class)
+        super(component)
+        @build_class = build_class
+      end
+
+      delegate :new, to: :@build_class
+    end
+  end
+end

data/lib/factory_girl/decorator.rb

@@ -0,0 +1,21 @@
+module FactoryGirl
+  class Decorator < BasicObject
+    undef_method :==
+
+    def initialize(component)
+      @component = component
+    end
+
+    def method_missing(name, *args, &block)
+      @component.send(name, *args, &block)
+    end
+
+    def send(symbol, *args, &block)
+      __send__(symbol, *args, &block)
+    end
+
+    def self.const_missing(name)
+      ::Object.const_get(name)
+    end
+  end
+end