factory_bot 1.0.0.alpha

data/lib/factory_bot/factory_runner.rb

@@ -0,0 +1,33 @@
+module FactoryBot
+  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 = FactoryBot.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_bot.run_factory', instrumentation_payload) do
+        factory.run(runner_strategy, @overrides, &block)
+      end
+    end
+  end
+end

data/lib/factory_bot/find_definitions.rb

@@ -0,0 +1,25 @@
+module FactoryBot
+  class << self
+    # An Array of strings specifying locations that should be searched for
+    # factory definitions. By default, factory_bot will attempt to require
+    # "factories", "test/factories" and "spec/factories". Only the first
+    # existing file will be loaded.
+    attr_accessor :definition_file_paths
+  end
+
+  self.definition_file_paths = %w(factories test/factories spec/factories)
+
+  def self.find_definitions
+    absolute_definition_file_paths = definition_file_paths.map { |path| File.expand_path(path) }
+
+    absolute_definition_file_paths.uniq.each do |path|
+      load("#{path}.rb") if File.exist?("#{path}.rb")
+
+      if File.directory? path
+        Dir[File.join(path, '**', '*.rb')].sort.each do |file|
+          load file
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/linter.rb

@@ -0,0 +1,97 @@
+module FactoryBot
+  class Linter
+
+    def initialize(factories_to_lint, linting_strategy)
+      @factories_to_lint = factories_to_lint
+      @linting_method = "lint_#{linting_strategy}"
+      @invalid_factories = calculate_invalid_factories
+    end
+
+    def lint!
+      if invalid_factories.any?
+        raise InvalidFactoryError, error_message
+      end
+    end
+
+    attr_reader :factories_to_lint, :invalid_factories
+    private :factories_to_lint, :invalid_factories
+
+    private
+
+    def calculate_invalid_factories
+      factories_to_lint.reduce(Hash.new([])) do |result, factory|
+        errors = send(@linting_method, factory)
+        result[factory] |= errors unless errors.empty?
+        result
+      end
+    end
+
+    class FactoryError
+      def initialize(wrapped_error, factory)
+        @wrapped_error = wrapped_error
+        @factory       = factory
+      end
+
+      def message
+        message = @wrapped_error.message
+        "* #{location} - #{message} (#{@wrapped_error.class.name})"
+      end
+
+      def location
+        @factory.name
+      end
+    end
+
+    class FactoryTraitError < FactoryError
+      def initialize(wrapped_error, factory, trait_name)
+        super(wrapped_error, factory)
+        @trait_name = trait_name
+      end
+
+      def location
+        "#{@factory.name}+#{@trait_name}"
+      end
+    end
+
+    def lint_factory(factory)
+      result = []
+      begin
+        FactoryBot.create(factory.name)
+      rescue => error
+        result |= [FactoryError.new(error, factory)]
+      end
+      result
+    end
+
+    def lint_traits(factory)
+      result = []
+      factory.definition.defined_traits.map(&:name).each do |trait_name|
+        begin
+          FactoryBot.create(factory.name, trait_name)
+        rescue => error
+          result |=
+              [FactoryTraitError.new(error, factory, trait_name)]
+        end
+      end
+      result
+    end
+
+    def lint_factory_and_traits(factory)
+      errors = lint_factory(factory)
+      errors |= lint_traits(factory)
+      errors
+    end
+
+    def error_message
+      lines = invalid_factories.map do |_factory, exceptions|
+        exceptions.map(&:message)
+      end.flatten
+
+      <<-ERROR_MESSAGE.strip
+The following factories are invalid:
+
+#{lines.join("\n")}
+      ERROR_MESSAGE
+    end
+  end
+end

data/lib/factory_bot/null_factory.rb

@@ -0,0 +1,18 @@
+module FactoryBot
+  # @api private
+  class NullFactory
+    attr_reader :definition
+
+    def initialize
+      @definition = Definition.new(:null_factory)
+    end
+
+    delegate :defined_traits, :callbacks, :attributes, :constructor,
+      :to_create, to: :definition
+
+    def compile; end
+    def class_name; end
+    def evaluator_class; FactoryBot::Evaluator; end
+    def hierarchy_class; FactoryBot::DefinitionHierarchy; end
+  end
+end

data/lib/factory_bot/null_object.rb

@@ -0,0 +1,24 @@
+module FactoryBot
+  # @api private
+  class NullObject < ::BasicObject
+    def initialize(methods_to_respond_to)
+      @methods_to_respond_to = methods_to_respond_to.map(&:to_s)
+    end
+
+    def method_missing(name, *args, &block)
+      if respond_to?(name)
+        nil
+      else
+        super
+      end
+    end
+
+    def respond_to?(method, include_private=false)
+      @methods_to_respond_to.include? method.to_s
+    end
+
+    def respond_to_missing?(*args)
+      false
+    end
+  end
+end

data/lib/factory_bot/registry.rb

@@ -0,0 +1,38 @@
+module FactoryBot
+  class Registry
+    include Enumerable
+
+    attr_reader :name
+
+    def initialize(name)
+      @name  = name
+      @items = Decorator::ClassKeyHash.new({})
+    end
+
+    def clear
+      @items.clear
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def find(name)
+      if registered?(name)
+        @items[name]
+      else
+        raise ArgumentError, "#{@name} not registered: #{name}"
+      end
+    end
+
+    alias :[] :find
+
+    def register(name, item)
+      @items[name] = item
+    end
+
+    def registered?(name)
+      @items.key?(name)
+    end
+  end
+end

data/lib/factory_bot/reload.rb

@@ -0,0 +1,8 @@
+module FactoryBot
+  def self.reload
+    reset_configuration
+    register_default_strategies
+    register_default_callbacks
+    find_definitions
+  end
+end

data/lib/factory_bot/sequence.rb

@@ -0,0 +1,62 @@
+module FactoryBot
+
+  # Sequences are defined using sequence within a FactoryBot.define block.
+  # Sequence values are generated using next.
+  # @api private
+  class Sequence
+    attr_reader :name
+
+    def initialize(name, *args, &proc)
+      @name    = name
+      @proc    = proc
+
+      options  = args.extract_options!
+      @value   = args.first || 1
+      @aliases = options.fetch(:aliases) { [] }
+
+      if !@value.respond_to?(:peek)
+        @value = EnumeratorAdapter.new(@value)
+      end
+    end
+
+    def next(scope = nil)
+      if @proc && scope
+        scope.instance_exec(value, &@proc)
+      elsif @proc
+        @proc.call(value)
+      else
+        value
+      end
+    ensure
+      increment_value
+    end
+
+    def names
+      [@name] + @aliases
+    end
+
+    private
+
+    def value
+      @value.peek
+    end
+
+    def increment_value
+      @value.next
+    end
+
+    class EnumeratorAdapter
+      def initialize(value)
+        @value = value
+      end
+
+      def peek
+        @value
+      end
+
+      def next
+        @value = @value.next
+      end
+    end
+  end
+end

data/lib/factory_bot/strategy/attributes_for.rb

@@ -0,0 +1,13 @@
+module FactoryBot
+  module Strategy
+    class AttributesFor
+      def association(runner)
+        runner.run(:null)
+      end
+
+      def result(evaluation)
+        evaluation.hash
+      end
+    end
+  end
+end

data/lib/factory_bot/strategy/build.rb

@@ -0,0 +1,15 @@
+module FactoryBot
+  module Strategy
+    class Build
+      def association(runner)
+        runner.run
+      end
+
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          evaluation.notify(:after_build, instance)
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/strategy/create.rb

@@ -0,0 +1,18 @@
+module FactoryBot
+  module Strategy
+    class Create
+      def association(runner)
+        runner.run
+      end
+
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          evaluation.notify(:after_build, instance)
+          evaluation.notify(:before_create, instance)
+          evaluation.create(instance)
+          evaluation.notify(:after_create, instance)
+        end
+      end
+    end
+  end
+end

data/lib/factory_bot/strategy/null.rb

@@ -0,0 +1,11 @@
+module FactoryBot
+  module Strategy
+    class Null
+      def association(runner)
+      end
+
+      def result(evaluation)
+      end
+    end
+  end
+end

data/lib/factory_bot/strategy/stub.rb

@@ -0,0 +1,108 @@
+module FactoryBot
+  module Strategy
+    class Stub
+      @@next_id = 1000
+
+      DISABLED_PERSISTENCE_METHODS = [
+        :connection,
+        :decrement!,
+        :decrement,
+        :delete,
+        :destroy!,
+        :destroy,
+        :destroyed?,
+        :increment!,
+        :increment,
+        :reload,
+        :save!,
+        :save,
+        :toggle!,
+        :toggle,
+        :touch,
+        :update!,
+        :update,
+        :update_attribute,
+        :update_attributes!,
+        :update_attributes,
+        :update_column,
+        :update_columns,
+      ].freeze
+
+      def association(runner)
+        runner.run(:build_stubbed)
+      end
+
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          stub_database_interaction_on_result(instance)
+          clear_changed_attributes_on_result(instance)
+          evaluation.notify(:after_stub, instance)
+        end
+      end
+
+      private
+
+      def next_id
+        @@next_id += 1
+      end
+
+      def stub_database_interaction_on_result(result_instance)
+        result_instance.id ||= next_id
+
+        result_instance.instance_eval do
+          def persisted?
+            !new_record?
+          end
+
+          def new_record?
+            id.nil?
+          end
+
+          DISABLED_PERSISTENCE_METHODS.each do |write_method|
+            define_singleton_method(write_method) do |*args|
+              raise "stubbed models are not allowed to access the database - #{self.class}##{write_method}(#{args.join(",")})"
+            end
+          end
+        end
+
+        created_at_missing_default = result_instance.respond_to?(:created_at) && !result_instance.created_at
+        result_instance_missing_created_at = !result_instance.respond_to?(:created_at)
+
+        if created_at_missing_default || result_instance_missing_created_at
+          result_instance.instance_eval do
+            def created_at
+              @created_at ||= Time.now.in_time_zone
+            end
+          end
+        end
+
+        has_updated_at = result_instance.respond_to?(:updated_at)
+        updated_at_no_default = has_updated_at && !result_instance.updated_at
+        result_instance_missing_updated_at = !has_updated_at
+
+        if updated_at_no_default || result_instance_missing_updated_at
+          result_instance.instance_eval do
+            def updated_at
+              @updated_at ||= Time.current
+            end
+          end
+        end
+      end
+
+      def clear_changed_attributes_on_result(result_instance)
+        unless result_instance.respond_to?(:clear_changes_information)
+          result_instance.extend ActiveModelDirtyBackport
+        end
+
+        result_instance.clear_changes_information
+      end
+    end
+
+    module ActiveModelDirtyBackport
+      def clear_changes_information
+        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      end
+    end
+  end
+end