tiny-lite-mod 0.0.1

data/factory_bot-6.6.0/lib/factory_bot/errors.rb

@@ -0,0 +1,28 @@
+module FactoryBot
+  # Raised when a factory is defined that attempts to instantiate itself.
+  class AssociationDefinitionError < RuntimeError; end
+
+  # Raised when a trait is defined that references itself.
+  class TraitDefinitionError < RuntimeError; end
+
+  # Raised when a callback is defined that has an invalid name
+  class InvalidCallbackNameError < RuntimeError; end
+
+  # Raised when a factory is defined with the same name as a previously-defined factory.
+  class DuplicateDefinitionError < RuntimeError; end
+
+  # Raised when attempting to register a sequence from a dynamic attribute block
+  class SequenceAbuseError < RuntimeError; end
+
+  # Raised when defining an attribute twice in the same factory
+  class AttributeDefinitionError < RuntimeError; end
+
+  # Raised when attempting to pass a block to an association definition
+  class AssociationDefinitionError < RuntimeError; end
+
+  # Raised when a method is defined in a factory or trait with arguments
+  class MethodDefinitionError < RuntimeError; end
+
+  # Raised when any factory is considered invalid
+  class InvalidFactoryError < RuntimeError; end
+end

data/factory_bot-6.6.0/lib/factory_bot/evaluation.rb

@@ -0,0 +1,23 @@
+module FactoryBot
+  class Evaluation
+    def initialize(evaluator, attribute_assigner, to_create, observer)
+      @evaluator = evaluator
+      @attribute_assigner = attribute_assigner
+      @to_create = to_create
+      @observer = observer
+    end
+
+    delegate :object, :hash, to: :@attribute_assigner
+
+    def create(result_instance)
+      case @to_create.arity
+      when 2 then @to_create[result_instance, @evaluator]
+      else @to_create[result_instance]
+      end
+    end
+
+    def notify(name, result_instance)
+      @observer.update(name, result_instance)
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/evaluator.rb

@@ -0,0 +1,86 @@
+require "active_support/core_ext/class/attribute"
+
+module FactoryBot
+  # @api private
+  class Evaluator
+    class_attribute :attribute_lists
+
+    private_instance_methods.each do |method|
+      undef_method(method) unless method.match?(/^__|initialize/)
+    end
+
+    def initialize(build_strategy, overrides = {})
+      @build_strategy = build_strategy
+      @overrides = overrides
+      @cached_attributes = overrides
+      @instance = nil
+
+      @overrides.each do |name, value|
+        singleton_class.define_attribute(name) { value }
+      end
+    end
+
+    def association(factory_name, *traits_and_overrides)
+      overrides = traits_and_overrides.extract_options!
+      strategy_override = overrides.fetch(:strategy) {
+        FactoryBot.use_parent_strategy ? @build_strategy.to_sym : :create
+      }
+
+      traits_and_overrides += [overrides.except(:strategy)]
+
+      runner = FactoryRunner.new(factory_name, strategy_override, traits_and_overrides)
+      @build_strategy.association(runner)
+    end
+
+    attr_accessor :instance
+
+    def method_missing(method_name, ...)
+      if @instance.respond_to?(method_name)
+        @instance.send(method_name, ...)
+      else
+        SyntaxRunner.new.send(method_name, ...)
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private = false)
+      @instance.respond_to?(method_name) || SyntaxRunner.new.respond_to?(method_name)
+    end
+
+    def __override_names__
+      @overrides.keys
+    end
+
+    def increment_sequence(sequence, scope: self)
+      value = sequence.next(scope)
+
+      raise if value.respond_to?(:start_with?) && value.start_with?("#<FactoryBot::Declaration")
+
+      value
+    rescue
+      raise ArgumentError, "Sequence '#{sequence.uri_manager.first}' failed to " \
+                          "return a value. Perhaps it needs a scope to operate? (scope: <object>)"
+    end
+
+    def self.attribute_list
+      AttributeList.new.tap do |list|
+        attribute_lists.each do |attribute_list|
+          list.apply_attributes attribute_list.to_a
+        end
+      end
+    end
+
+    def self.define_attribute(name, &block)
+      if instance_methods(false).include?(name) || private_instance_methods(false).include?(name)
+        undef_method(name)
+      end
+
+      define_method(name) do
+        if @cached_attributes.key?(name)
+          @cached_attributes[name]
+        else
+          @cached_attributes[name] = instance_exec(&block)
+        end
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/evaluator_class_definer.rb

@@ -0,0 +1,20 @@
+module FactoryBot
+  # @api private
+  class EvaluatorClassDefiner
+    def initialize(attributes, parent_class)
+      @parent_class = parent_class
+      @attributes = attributes
+
+      attributes.each do |attribute|
+        evaluator_class.define_attribute(attribute.name, &attribute.to_proc)
+      end
+    end
+
+    def evaluator_class
+      @evaluator_class ||= Class.new(@parent_class).tap do |klass|
+        klass.attribute_lists ||= []
+        klass.attribute_lists += [@attributes]
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/factory.rb

@@ -0,0 +1,178 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/inflector"
+
+module FactoryBot
+  # @api private
+  class Factory
+    attr_reader :name, :definition
+
+    def initialize(name, options = {})
+      assert_valid_options(options)
+      @name = name.respond_to?(:to_sym) ? name.to_sym : name.to_s.underscore.to_sym
+      @parent = options[:parent]
+      @aliases = options[:aliases] || []
+      @class_name = options[:class]
+      @uri_manager = FactoryBot::UriManager.new(names)
+      @definition = Definition.new(@name, options[:traits] || [], uri_manager: @uri_manager)
+      @compiled = false
+    end
+
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait, :constructor,
+      :defined_traits, :defined_traits_names, :inherit_traits, :append_traits,
+      to: :@definition
+
+    def build_class
+      @build_class ||= if class_name.is_a? Class
+        class_name
+      elsif class_name.to_s.safe_constantize
+        class_name.to_s.safe_constantize
+      else
+        class_name.to_s.camelize.constantize
+      end
+    end
+
+    def run(build_strategy, overrides, &block)
+      block ||= ->(result) { result }
+
+      compile
+
+      strategy = Strategy.lookup_strategy(build_strategy).new
+
+      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
+      attribute_assigner = AttributeAssigner.new(evaluator, build_class, &compiled_constructor)
+
+      observer = CallbacksObserver.new(callbacks, evaluator)
+      evaluation = Evaluation.new(evaluator, attribute_assigner, compiled_to_create, observer)
+
+      evaluation.notify(:before_all, nil)
+      instance = strategy.result(evaluation).tap(&block)
+      evaluation.notify(:after_all, instance)
+
+      instance
+    end
+
+    def human_names
+      names.map { |name| name.to_s.humanize.downcase }
+    end
+
+    def associations
+      evaluator_class.attribute_list.associations
+    end
+
+    # Names for this factory, including aliases.
+    #
+    # Example:
+    #
+    #   factory :user, aliases: [:author] do
+    #     # ...
+    #   end
+    #
+    #   FactoryBot.create(:author).class
+    #   # => User
+    #
+    # Because an attribute defined without a value or block will build an
+    # association with the same name, this allows associations to be defined
+    # without factories, such as:
+    #
+    #   factory :user, aliases: [:author] do
+    #     # ...
+    #   end
+    #
+    #   factory :post do
+    #     author
+    #   end
+    #
+    #   FactoryBot.create(:post).author.class
+    #   # => User
+    def names
+      [name] + @aliases
+    end
+
+    def compile
+      unless @compiled
+        parent.compile
+        inherit_parent_traits
+        @definition.compile(build_class)
+        build_hierarchy
+        @compiled = true
+      end
+    end
+
+    def with_traits(traits)
+      clone.tap do |factory_with_traits|
+        factory_with_traits.append_traits traits
+      end
+    end
+
+    protected
+
+    def class_name
+      @class_name || parent.class_name || name
+    end
+
+    def evaluator_class
+      @evaluator_class ||= EvaluatorClassDefiner.new(attributes, parent.evaluator_class).evaluator_class
+    end
+
+    def attributes
+      compile
+      AttributeList.new(@name).tap do |list|
+        list.apply_attributes definition.attributes
+      end
+    end
+
+    def hierarchy_class
+      @hierarchy_class ||= Class.new(parent.hierarchy_class)
+    end
+
+    def hierarchy_instance
+      @hierarchy_instance ||= hierarchy_class.new
+    end
+
+    def build_hierarchy
+      hierarchy_class.build_from_definition definition
+    end
+
+    def callbacks
+      hierarchy_instance.callbacks
+    end
+
+    def compiled_to_create
+      hierarchy_instance.to_create
+    end
+
+    def compiled_constructor
+      hierarchy_instance.constructor
+    end
+
+    private
+
+    def assert_valid_options(options)
+      options.assert_valid_keys(:class, :parent, :aliases, :traits)
+    end
+
+    def parent
+      if @parent
+        FactoryBot::Internal.factory_by_name(@parent)
+      else
+        NullFactory.new
+      end
+    end
+
+    def inherit_parent_traits
+      parent.defined_traits.each do |trait|
+        next if defined_traits_names.include?(trait.name)
+        define_trait(trait.clone)
+      end
+    end
+
+    def initialize_copy(source)
+      super
+      @definition = @definition.clone
+      @evaluator_class = nil
+      @hierarchy_class = nil
+      @hierarchy_instance = nil
+      @compiled = false
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/factory_runner.rb

@@ -0,0 +1,35 @@
+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::Internal.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.before_run_factory", instrumentation_payload)
+
+      ActiveSupport::Notifications.instrument("factory_bot.run_factory", instrumentation_payload) do
+        factory.run(runner_strategy, @overrides, &block)
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/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.rb", "factories/**/*.rb", "test/factories.rb",
+    # "test/factories/**.rb", "spec/factories.rb", and "spec/factories/**.rb".
+    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_bot-6.6.0/lib/factory_bot/internal.rb

@@ -0,0 +1,124 @@
+module FactoryBot
+  # @api private
+  module Internal
+    class << self
+      delegate :after,
+        :before,
+        :callbacks,
+        :constructor,
+        :factories,
+        :initialize_with,
+        :inline_sequences,
+        :sequences,
+        :skip_create,
+        :strategies,
+        :to_create,
+        :traits,
+        to: :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def reset_configuration
+        @configuration = nil
+      end
+
+      def register_inline_sequence(sequence)
+        inline_sequences.push(sequence)
+        sequence
+      end
+
+      def rewind_inline_sequences
+        inline_sequences.each(&:rewind)
+      end
+
+      def register_trait(trait)
+        trait.names.each do |name|
+          traits.register(name, trait)
+        end
+        trait
+      end
+
+      def trait_by_name(name, klass)
+        traits.find(name).tap { |t| t.klass = klass }
+      end
+
+      def register_sequence(sequence)
+        sequence.names.each do |name|
+          sequences.register(name, sequence)
+        end
+        sequence
+      end
+
+      def sequence_by_name(name)
+        sequences.find(name)
+      end
+
+      def rewind_sequences
+        sequences.each(&:rewind)
+        rewind_inline_sequences
+      end
+
+      def rewind_sequence(*uri_parts)
+        fail_argument_count(0, "1+") if uri_parts.empty?
+
+        uri = build_uri(uri_parts)
+        sequence = Sequence.find_by_uri(uri) || fail_unregistered_sequence(uri)
+
+        sequence.rewind
+      end
+
+      def set_sequence(*uri_parts, value)
+        uri = build_uri(uri_parts) || fail_argument_count(uri_parts.size, "2+")
+        sequence = Sequence.find(*uri) || fail_unregistered_sequence(uri)
+
+        sequence.set_value(value)
+      end
+
+      def register_factory(factory)
+        factory.names.each do |name|
+          factories.register(name, factory)
+        end
+        factory
+      end
+
+      def factory_by_name(name)
+        factories.find(name)
+      end
+
+      def register_strategy(strategy_name, strategy_class)
+        strategies.register(strategy_name, strategy_class)
+        StrategySyntaxMethodRegistrar.new(strategy_name).define_strategy_methods
+      end
+
+      def strategy_by_name(name)
+        strategies.find(name)
+      end
+
+      def register_default_strategies
+        register_strategy(:build, FactoryBot::Strategy::Build)
+        register_strategy(:create, FactoryBot::Strategy::Create)
+        register_strategy(:attributes_for, FactoryBot::Strategy::AttributesFor)
+        register_strategy(:build_stubbed, FactoryBot::Strategy::Stub)
+        register_strategy(:null, FactoryBot::Strategy::Null)
+      end
+
+      private
+
+      def build_uri(...)
+        FactoryBot::UriManager.build_uri(...)
+      end
+
+      def fail_argument_count(received, expected)
+        fail ArgumentError,
+          "wrong number of arguments (given #{received}, expected #{expected})"
+      end
+
+      def fail_unregistered_sequence(uri)
+        fail KeyError,
+          "Sequence not registered: '#{uri}'."
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/linter.rb

@@ -0,0 +1,121 @@
+module FactoryBot
+  class Linter
+    def initialize(factories, strategy: :create, traits: false, verbose: false)
+      @factories_to_lint = factories
+      @factory_strategy = strategy
+      @traits = traits
+      @verbose = verbose
+      @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.each_with_object(Hash.new([])) do |factory, result|
+        errors = lint(factory)
+        result[factory] |= errors unless errors.empty?
+      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 verbose_message
+        <<~MESSAGE
+          #{message}
+            #{@wrapped_error.backtrace.join("\n  ")}
+        MESSAGE
+      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)
+      if @traits
+        lint_factory(factory) + lint_traits(factory)
+      else
+        lint_factory(factory)
+      end
+    end
+
+    def lint_factory(factory)
+      result = []
+      begin
+        in_transaction { FactoryBot.public_send(factory_strategy, factory.name) }
+      rescue => e
+        result |= [FactoryError.new(e, factory)]
+      end
+      result
+    end
+
+    def lint_traits(factory)
+      result = []
+      factory.definition.defined_traits.map(&:name).each do |trait_name|
+        in_transaction { FactoryBot.public_send(factory_strategy, factory.name, trait_name) }
+      rescue => e
+        result |= [FactoryTraitError.new(e, factory, trait_name)]
+      end
+      result
+    end
+
+    def error_message
+      lines = invalid_factories.map { |_factory, exceptions|
+        exceptions.map(&error_message_type)
+      }.flatten
+
+      <<~ERROR_MESSAGE.strip
+        The following factories are invalid:
+
+        #{lines.join("\n")}
+      ERROR_MESSAGE
+    end
+
+    def error_message_type
+      if @verbose
+        :verbose_message
+      else
+        :message
+      end
+    end
+
+    def in_transaction
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.transaction(joinable: false) do
+          yield
+          raise ActiveRecord::Rollback
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/null_factory.rb

@@ -0,0 +1,27 @@
+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/factory_bot-6.6.0/lib/factory_bot/null_object.rb

@@ -0,0 +1,20 @@
+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) # rubocop:disable Style/MissingRespondToMissing
+      if respond_to?(name)
+        nil
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      @methods_to_respond_to.include? method.to_s
+    end
+  end
+end