opal-factory_girl 4.5.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfe191bdf8185297a622da7437455efe0f8cc184
+  data.tar.gz: 9392baa09edf4c369ef401d7a438e6ba987da140
+SHA512:
+  metadata.gz: 1efca3f1f569898b22874b732bb0e895bef38d9fb0c00204be6a062942034caba6e6aca5fdf604d11373327a8d9e942f86e849c442b9d757cd6d35a995995728
+  data.tar.gz: 74c78b1a22cd6f777497ca3bb8301d11238084c9920fe72b77638c74672f69f8ecf57e74949f48adec67c164577fbdadceb2a5b5e112c5ce49d8349b8368eb90

data/factory_girl/lib/factory_girl.rb

@@ -0,0 +1,132 @@
+require 'set'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/deprecation'
+require 'active_support/notifications'
+
+require 'factory_girl/definition_hierarchy'
+require 'factory_girl/configuration'
+require 'factory_girl/errors'
+require 'factory_girl/factory_runner'
+require 'factory_girl/strategy_syntax_method_registrar'
+require 'factory_girl/strategy_calculator'
+require 'factory_girl/strategy/build'
+require 'factory_girl/strategy/create'
+require 'factory_girl/strategy/attributes_for'
+require 'factory_girl/strategy/stub'
+require 'factory_girl/strategy/null'
+require 'factory_girl/registry'
+require 'factory_girl/null_factory'
+require 'factory_girl/null_object'
+require 'factory_girl/evaluation'
+require 'factory_girl/factory'
+require 'factory_girl/attribute_assigner'
+require 'factory_girl/evaluator'
+require 'factory_girl/evaluator_class_definer'
+require 'factory_girl/attribute'
+require 'factory_girl/callback'
+require 'factory_girl/callbacks_observer'
+require 'factory_girl/declaration_list'
+require 'factory_girl/declaration'
+require 'factory_girl/sequence'
+require 'factory_girl/attribute_list'
+require 'factory_girl/trait'
+require 'factory_girl/aliases'
+require 'factory_girl/definition'
+require 'factory_girl/definition_proxy'
+require 'factory_girl/syntax'
+require 'factory_girl/syntax_runner'
+require 'factory_girl/find_definitions'
+require 'factory_girl/reload'
+require 'factory_girl/decorator'
+require 'factory_girl/decorator/attribute_hash'
+require 'factory_girl/decorator/class_key_hash'
+require 'factory_girl/decorator/disallows_duplicates_registry'
+require 'factory_girl/decorator/invocation_tracker'
+require 'factory_girl/decorator/new_constructor'
+require 'factory_girl/linter'
+require 'factory_girl/version'
+
+module FactoryGirl
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset_configuration
+    @configuration = nil
+  end
+
+  def self.lint(factories_to_lint = FactoryGirl.factories)
+    Linter.lint!(factories_to_lint)
+  end
+
+  class << self
+    delegate :factories, :sequences, :traits, :callbacks, :strategies, :callback_names,
+      :to_create, :skip_create, :initialize_with, :constructor, :duplicate_attribute_assignment_from_initialize_with,
+      :duplicate_attribute_assignment_from_initialize_with=, to: :configuration
+  end
+
+  def self.register_factory(factory)
+    factory.names.each do |name|
+      factories.register(name, factory)
+    end
+    factory
+  end
+
+  def self.factory_by_name(name)
+    factories.find(name)
+  end
+
+  def self.register_sequence(sequence)
+    sequence.names.each do |name|
+      sequences.register(name, sequence)
+    end
+    sequence
+  end
+
+  def self.sequence_by_name(name)
+    sequences.find(name)
+  end
+
+  def self.register_trait(trait)
+    trait.names.each do |name|
+      traits.register(name, trait)
+    end
+    trait
+  end
+
+  def self.trait_by_name(name)
+    traits.find(name)
+  end
+
+  def self.register_strategy(strategy_name, strategy_class)
+    strategies.register(strategy_name, strategy_class)
+    StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
+  end
+
+  def self.strategy_by_name(name)
+    strategies.find(name)
+  end
+
+  def self.register_default_strategies
+    register_strategy(:build,          FactoryGirl::Strategy::Build)
+    register_strategy(:create,         FactoryGirl::Strategy::Create)
+    register_strategy(:attributes_for, FactoryGirl::Strategy::AttributesFor)
+    register_strategy(:build_stubbed,  FactoryGirl::Strategy::Stub)
+    register_strategy(:null,           FactoryGirl::Strategy::Null)
+  end
+
+  def self.register_default_callbacks
+    register_callback(:after_build)
+    register_callback(:after_create)
+    register_callback(:after_stub)
+    register_callback(:before_create)
+  end
+
+  def self.register_callback(name)
+    name = name.to_sym
+    callback_names << name
+  end
+end
+
+FactoryGirl.register_default_strategies
+FactoryGirl.register_default_callbacks

data/factory_girl/lib/factory_girl/aliases.rb

@@ -0,0 +1,18 @@
+module FactoryGirl
+  class << self
+    attr_accessor :aliases
+  end
+
+  self.aliases = [
+    [/(.+)_id/, '\1'],
+    [/(.*)/, '\1_id']
+  ]
+
+  def self.aliases_for(attribute)
+    aliases.map do |(pattern, replace)|
+      if pattern.match(attribute.to_s)
+        attribute.to_s.sub(pattern, replace).to_sym
+      end
+    end.compact << attribute
+  end
+end

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

@@ -0,0 +1,27 @@
+module FactoryGirl
+  class Attribute
+    # @api private
+    class Association < Attribute
+      attr_reader :factory
+
+      def initialize(name, factory, overrides)
+        super(name, false)
+        @factory   = factory
+        @overrides = overrides
+      end
+
+      def to_proc
+        factory   = @factory
+        overrides = @overrides
+        traits_and_overrides = [factory, overrides].flatten
+        factory_name = traits_and_overrides.shift
+
+        -> { association(factory_name, *traits_and_overrides) }
+      end
+
+      def association?
+        true
+      end
+    end
+  end
+end

data/factory_girl/lib/factory_girl/attribute/dynamic.rb

@@ -0,0 +1,24 @@
+module FactoryGirl
+  class Attribute
+    # @api private
+    class Dynamic < Attribute
+      def initialize(name, ignored, block)
+        super(name, ignored)
+        @block = block
+      end
+
+      def to_proc
+        block = @block
+
+        -> {
+          value = case block.arity
+                  when 1, -1 then instance_exec(self, &block)
+                  else instance_exec(&block)
+                  end
+          raise SequenceAbuseError if FactoryGirl::Sequence === value
+          value
+        }
+      end
+    end
+  end
+end

data/factory_girl/lib/factory_girl/attribute/sequence.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Attribute
+    # @api private
+    class Sequence < Attribute
+      def initialize(name, sequence, ignored)
+        super(name, ignored)
+        @sequence = sequence
+      end
+
+      def to_proc
+        sequence = @sequence
+        -> { FactoryGirl.generate(sequence) }
+      end
+    end
+  end
+end

data/factory_girl/lib/factory_girl/attribute/static.rb

@@ -0,0 +1,16 @@
+module FactoryGirl
+  class Attribute
+    # @api private
+    class Static < Attribute
+      def initialize(name, value, ignored)
+        super(name, ignored)
+        @value = value
+      end
+
+      def to_proc
+        value = @value
+        -> { value }
+      end
+    end
+  end
+end

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