opal-factory_girl 4.5.0.3

data/factory_girl/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

data/factory_girl/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/factory_girl/lib/factory_girl/linter.rb

@@ -0,0 +1,47 @@
+module FactoryGirl
+  class Linter
+    def self.lint!(factories_to_lint)
+      new(factories_to_lint).lint!
+    end
+
+    def initialize(factories_to_lint)
+      @factories_to_lint = factories_to_lint
+      @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.inject({}) do |result, factory|
+        begin
+          FactoryGirl.create(factory.name)
+        rescue => error
+          result[factory] = error
+        end
+
+        result
+      end
+    end
+
+    def error_message
+      lines = invalid_factories.map do |factory, exception|
+        "* #{factory.name} - #{exception.message} (#{exception.class.name})"
+      end
+
+      <<-ERROR_MESSAGE.strip
+The following factories are invalid:
+
+#{lines.join("\n")}
+      ERROR_MESSAGE
+    end
+  end
+end

data/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/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/factory_girl/lib/factory_girl/strategy/stub.rb

@@ -0,0 +1,73 @@
+module FactoryGirl
+  module Strategy
+    class Stub
+      @@next_id = 1000
+
+      def association(runner)
+        runner.run(:build_stubbed)
+      end
+
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          stub_database_interaction_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 save(*args)
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#save(#{args.join(",")})"
+          end
+
+          def destroy(*args)
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#destroy(#{args.join(",")})"
+          end
+
+          def connection
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#connection()"
+          end
+
+          def reload(*args)
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#reload()"
+          end
+
+          def update_attribute(*args)
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#update_attribute(#{args.join(",")})"
+          end
+
+          def update_column(*args)
+            raise "stubbed models are not allowed to access the database - #{self.class.to_s}#update_column(#{args.join(",")})"
+          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
+      end
+    end
+  end
+end

data/factory_girl/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/factory_girl/lib/factory_girl/strategy_syntax_method_registrar.rb

@@ -0,0 +1,46 @@
+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|
+        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
+        define_method(name, &block)
+      end
+    end
+  end
+end