ffactory_girl 4.8.1

data/lib/factory_girl/find_definitions.rb

@@ -0,0 +1,25 @@
+module FactoryGirl
+  class << self
+    # An Array of strings specifying locations that should be searched for
+    # factory definitions. By default, factory_girl 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_girl/linter.rb

@@ -0,0 +1,97 @@
+module FactoryGirl
+  class Linter
+
+    def initialize(factories, linting_strategy, factory_strategy = :create)
+      @factories_to_lint = factories
+      @linting_method = "lint_#{linting_strategy}"
+      @factory_strategy = factory_strategy
+      @invalid_factories = calculate_invalid_factories
+    end
+
+    def lint!
+      if invalid_factories.any?
+        raise InvalidFactoryError, error_message
+      end
+    end
+
+    private
+
+    attr_reader :factories_to_lint, :invalid_factories, :factory_strategy
+
+    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
+        FactoryGirl.public_send(factory_strategy, 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
+          FactoryGirl.public_send(factory_strategy, 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_girl/null_factory.rb

@@ -0,0 +1,18 @@
+module FactoryGirl
+  # @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; FactoryGirl::Evaluator; end
+    def hierarchy_class; FactoryGirl::DefinitionHierarchy; end
+  end
+end

data/lib/factory_girl/null_object.rb

@@ -0,0 +1,24 @@
+module FactoryGirl
+  # @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_girl/registry.rb

@@ -0,0 +1,38 @@
+module FactoryGirl
+  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_girl/reload.rb

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

data/lib/factory_girl/sequence.rb

@@ -0,0 +1,62 @@
+module FactoryGirl
+
+  # Sequences are defined using sequence within a FactoryGirl.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_girl/strategy/attributes_for.rb

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

data/lib/factory_girl/strategy/build.rb

@@ -0,0 +1,15 @@
+module FactoryGirl
+  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_girl/strategy/create.rb

@@ -0,0 +1,18 @@
+module FactoryGirl
+  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_girl/strategy/null.rb

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

data/lib/factory_girl/strategy/stub.rb

@@ -0,0 +1,111 @@
+module FactoryGirl
+  module Strategy
+    class Stub
+      @@next_id = 1000
+
+      DISABLED_PERSISTENCE_METHODS = [
+        :connection,
+        :decrement!,
+        :decrement,
+        :delete,
+        :destroy!,
+        :destroy,
+        :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
+
+          def destroyed?
+            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

data/lib/factory_girl/strategy_calculator.rb

@@ -0,0 +1,26 @@
+module FactoryGirl
+  # @api private
+  class StrategyCalculator
+    def initialize(name_or_object)
+      @name_or_object = name_or_object
+    end
+
+    def strategy
+      if strategy_is_object?
+        @name_or_object
+      else
+        strategy_name_to_object
+      end
+    end
+
+    private
+
+    def strategy_is_object?
+      @name_or_object.is_a?(Class)
+    end
+
+    def strategy_name_to_object
+      FactoryGirl.strategy_by_name(@name_or_object)
+    end
+  end
+end

data/lib/factory_girl/strategy_syntax_method_registrar.rb

@@ -0,0 +1,54 @@
+module FactoryGirl
+  # @api private
+  class StrategySyntaxMethodRegistrar
+    def initialize(strategy_name)
+      @strategy_name = strategy_name
+    end
+
+    def define_strategy_methods
+      define_singular_strategy_method
+      define_list_strategy_method
+      define_pair_strategy_method
+    end
+
+    private
+
+    def define_singular_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method(strategy_name) do |name, *traits_and_overrides, &block|
+        FactoryRunner.new(name, strategy_name, traits_and_overrides).run(&block)
+      end
+    end
+
+    def define_list_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method("#{strategy_name}_list") do |name, amount, *traits_and_overrides, &block|
+        unless amount.respond_to?(:times)
+          raise ArgumentError, "count missing for #{strategy_name}_list"
+        end
+
+        amount.times.map { send(strategy_name, name, *traits_and_overrides, &block) }
+      end
+    end
+
+    def define_pair_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method("#{strategy_name}_pair") do |name, *traits_and_overrides, &block|
+        2.times.map { send(strategy_name, name, *traits_and_overrides, &block) }
+      end
+    end
+
+    def define_syntax_method(name, &block)
+      FactoryGirl::Syntax::Methods.module_exec do
+        if method_defined?(name) || private_method_defined?(name)
+          undef_method(name)
+        end
+
+        define_method(name, &block)
+      end
+    end
+  end
+end

data/lib/factory_girl/syntax/default.rb

@@ -0,0 +1,76 @@
+module FactoryGirl
+  module Syntax
+    module Default
+      include Methods
+
+      def define(&block)
+        DSL.run(block)
+      end
+
+      def modify(&block)
+        ModifyDSL.run(block)
+      end
+
+      class DSL
+        def factory(name, options = {}, &block)
+          factory = Factory.new(name, options)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition)
+          proxy.instance_eval(&block) if block_given?
+
+          FactoryGirl.register_factory(factory)
+
+          proxy.child_factories.each do |(child_name, child_options, child_block)|
+            parent_factory = child_options.delete(:parent) || name
+            factory(child_name, child_options.merge(parent: parent_factory), &child_block)
+          end
+        end
+
+        def sequence(name, *args, &block)
+          FactoryGirl.register_sequence(Sequence.new(name, *args, &block))
+        end
+
+        def trait(name, &block)
+          FactoryGirl.register_trait(Trait.new(name, &block))
+        end
+
+        def to_create(&block)
+          FactoryGirl.to_create(&block)
+        end
+
+        def skip_create
+          FactoryGirl.skip_create
+        end
+
+        def initialize_with(&block)
+          FactoryGirl.initialize_with(&block)
+        end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+
+        delegate :before, :after, :callback, to: :configuration
+
+        private
+
+        def configuration
+          FactoryGirl.configuration
+        end
+      end
+
+      class ModifyDSL
+        def factory(name, options = {}, &block)
+          factory = FactoryGirl.factory_by_name(name)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition.overridable)
+          proxy.instance_eval(&block)
+        end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+      end
+    end
+  end
+
+  extend Syntax::Default
+end