factory_bot 1.0.0.alpha

data/lib/factory_bot/declaration/association.rb

@@ -0,0 +1,28 @@
+module FactoryBot
+  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_bot/declaration/dynamic.rb

@@ -0,0 +1,26 @@
+module FactoryBot
+  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_bot/declaration/implicit.rb

@@ -0,0 +1,33 @@
+module FactoryBot
+  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 FactoryBot.factories.registered?(name)
+          [Attribute::Association.new(name, name, {})]
+        elsif FactoryBot.sequences.registered?(name)
+          [Attribute::Sequence.new(name, name, @ignored)]
+        else
+          @factory.inherit_traits([name])
+          []
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/declaration/static.rb

@@ -0,0 +1,26 @@
+module FactoryBot
+  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_bot/declaration_list.rb

@@ -0,0 +1,49 @@
+module FactoryBot
+  # @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_bot/decorator.rb

@@ -0,0 +1,21 @@
+module FactoryBot
+  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

data/lib/factory_bot/decorator/attribute_hash.rb

@@ -0,0 +1,16 @@
+module FactoryBot
+  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_bot/decorator/class_key_hash.rb

@@ -0,0 +1,28 @@
+module FactoryBot
+  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 FactoryBot.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 FactoryBot.allow_class_lookup = false", caller
+          key.to_s.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/decorator/disallows_duplicates_registry.rb

@@ -0,0 +1,13 @@
+module FactoryBot
+  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_bot/decorator/invocation_tracker.rb

@@ -0,0 +1,19 @@
+module FactoryBot
+  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_bot/decorator/new_constructor.rb

@@ -0,0 +1,12 @@
+module FactoryBot
+  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_bot/definition.rb

@@ -0,0 +1,136 @@
+module FactoryBot
+  # @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|
+        FactoryBot.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) || FactoryBot.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_bot/definition_hierarchy.rb

@@ -0,0 +1,48 @@
+module FactoryBot
+  class DefinitionHierarchy
+    def callbacks
+      FactoryBot.callbacks
+    end
+
+    def constructor
+      FactoryBot.constructor
+    end
+
+    def to_create
+      FactoryBot.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