tiny-lite-mod 0.0.1

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

@@ -0,0 +1,59 @@
+require "active_support/hash_with_indifferent_access"
+
+module FactoryBot
+  class Registry
+    include Enumerable
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @items = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def clear
+      @items.clear
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def find(name)
+      @items.fetch(name)
+    rescue KeyError => e
+      raise key_error_with_custom_message(e)
+    end
+
+    alias_method :[], :find
+
+    def register(name, item)
+      @items[name] = item
+    end
+
+    def registered?(name)
+      @items.key?(name)
+    end
+
+    private
+
+    def key_error_with_custom_message(key_error)
+      message = key_error.message.sub("key not found", "#{@name} not registered")
+      new_key_error(message, key_error).tap do |error|
+        error.set_backtrace(key_error.backtrace)
+      end
+    end
+
+    # detailed_message introduced in Ruby 3.2 for cleaner integration with
+    # did_you_mean. See https://bugs.ruby-lang.org/issues/18564
+    if KeyError.method_defined?(:detailed_message)
+      def new_key_error(message, key_error)
+        KeyError.new(message, key: key_error.key, receiver: key_error.receiver)
+      end
+    else
+      def new_key_error(message, _)
+        KeyError.new(message)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,197 @@
+require "timeout"
+
+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, :uri_manager, :aliases
+
+    def self.find(*uri_parts)
+      if uri_parts.empty?
+        fail ArgumentError, "wrong number of arguments, expected 1+)"
+      else
+        find_by_uri FactoryBot::UriManager.build_uri(*uri_parts)
+      end
+    end
+
+    def self.find_by_uri(uri)
+      uri = uri.to_sym
+      FactoryBot::Internal.sequences.to_a.find { |seq| seq.has_uri?(uri) } ||
+        FactoryBot::Internal.inline_sequences.find { |seq| seq.has_uri?(uri) }
+    end
+
+    def initialize(name, *args, &proc)
+      options = args.extract_options!
+      @name = name
+      @proc = proc
+      @aliases = options.fetch(:aliases, []).map(&:to_sym)
+      @uri_manager = FactoryBot::UriManager.new(names, paths: options[:uri_paths])
+      @value = args.first || 1
+
+      unless @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
+
+    def has_name?(test_name)
+      names.include?(test_name.to_sym)
+    end
+
+    def has_uri?(uri)
+      uri_manager.include?(uri)
+    end
+
+    def for_factory?(test_factory_name)
+      FactoryBot::Internal.factory_by_name(factory_name).names.include?(test_factory_name.to_sym)
+    end
+
+    def rewind
+      @value.rewind
+    end
+
+    ##
+    # If it's an Integer based sequence, set the new value directly,
+    # else rewind and seek from the beginning until a match is found.
+    #
+    def set_value(new_value)
+      if can_set_value_directly?(new_value)
+        @value.set_value(new_value)
+      elsif can_set_value_by_index?
+        set_value_by_index(new_value)
+      else
+        seek_value(new_value)
+      end
+    end
+
+    protected
+
+    attr_reader :proc
+
+    private
+
+    def value
+      @value.peek
+    end
+
+    def increment_value
+      @value.next
+    end
+
+    def can_set_value_by_index?
+      @value.respond_to?(:find_index)
+    end
+
+    ##
+    # Set to the given value, or fail if not found
+    #
+    def set_value_by_index(value)
+      index = @value.find_index(value) || fail_value_not_found(value)
+      @value.rewind
+      index.times { @value.next }
+    end
+
+    ##
+    # Rewind index and seek until the value is found or the max attempts
+    # have been tried. If not found, the sequence is rewound to its original value
+    #
+    def seek_value(value)
+      original_value = @value.peek
+
+      # rewind and search for the new value
+      @value.rewind
+      Timeout.timeout(FactoryBot.sequence_setting_timeout) do
+        loop do
+          return if @value.peek == value
+          increment_value
+        end
+
+        # loop auto-recues a StopIteration error, so if we
+        # reached this point, re-raise it now
+        fail StopIteration
+      end
+    rescue Timeout::Error, StopIteration
+      reset_original_value(original_value)
+      fail_value_not_found(value)
+    end
+
+    def reset_original_value(original_value)
+      @value.rewind
+
+      until @value.peek == original_value
+        increment_value
+      end
+    end
+
+    def can_set_value_directly?(value)
+      return false unless value.is_a?(Integer)
+      return false unless @value.is_a?(EnumeratorAdapter)
+      @value.integer_value?
+    end
+
+    def fail_value_not_found(value)
+      fail ArgumentError, "Unable to find '#{value}' in the sequence."
+    end
+
+    class EnumeratorAdapter
+      def initialize(initial_value)
+        @initial_value = initial_value
+      end
+
+      def peek
+        value
+      end
+
+      def next
+        @value = value.next
+      end
+
+      def rewind
+        @value = first_value
+      end
+
+      def set_value(new_value)
+        if new_value >= first_value
+          @value = new_value
+        else
+          fail ArgumentError, "Value cannot be less than: #{@first_value}"
+        end
+      end
+
+      def integer_value?
+        first_value.is_a?(Integer)
+      end
+
+      private
+
+      def first_value
+        @first_value ||= initial_value
+      end
+
+      def value
+        @value ||= initial_value
+      end
+
+      def initial_value
+        @value = @initial_value.respond_to?(:call) ? @initial_value.call : @initial_value
+        @first_value = @value
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/strategy/attributes_for.rb

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

data/factory_bot-6.6.0/lib/factory_bot/strategy/build.rb

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

data/factory_bot-6.6.0/lib/factory_bot/strategy/create.rb

@@ -0,0 +1,24 @@
+module FactoryBot
+  module Strategy
+    class Create
+      def association(runner)
+        runner.run
+      end
+
+      def result(evaluation)
+        evaluation.notify(:before_build, nil)
+
+        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
+
+      def to_sym
+        :create
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/strategy/null.rb

@@ -0,0 +1,15 @@
+module FactoryBot
+  module Strategy
+    class Null
+      def association(runner)
+      end
+
+      def result(evaluation)
+      end
+
+      def to_sym
+        :null
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/strategy/stub.rb

@@ -0,0 +1,129 @@
+module FactoryBot
+  module Strategy
+    class Stub
+      @@next_id = 1000
+
+      DISABLED_PERSISTENCE_METHODS = [
+        :connection,
+        :decrement!,
+        :delete,
+        :destroy!,
+        :destroy,
+        :increment!,
+        :reload,
+        :save!,
+        :save,
+        :toggle!,
+        :touch,
+        :update!,
+        :update,
+        :update_attribute,
+        :update_attributes!,
+        :update_attributes,
+        :update_column,
+        :update_columns
+      ].freeze
+
+      def self.next_id=(id)
+        @@next_id = id
+      end
+
+      def association(runner)
+        runner.run(:build_stubbed)
+      end
+
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          stub_database_interaction_on_result(instance)
+          set_timestamps(instance)
+          clear_changes_information(instance)
+          evaluation.notify(:after_stub, instance)
+        end
+      end
+
+      def to_sym
+        :stub
+      end
+
+      private
+
+      def next_id(result_instance)
+        if uuid_primary_key?(result_instance)
+          SecureRandom.uuid
+        else
+          @@next_id += 1
+        end
+      end
+
+      def stub_database_interaction_on_result(result_instance)
+        if has_settable_id?(result_instance)
+          result_instance.id ||= next_id(result_instance)
+        end
+
+        result_instance.instance_eval do
+          def persisted?
+            true
+          end
+
+          def new_record?
+            false
+          end
+
+          def destroyed?
+            false
+          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
+      end
+
+      def has_settable_id?(result_instance)
+        result_instance.respond_to?(:id=) &&
+          (!result_instance.class.respond_to?(:primary_key) ||
+          result_instance.class.primary_key)
+      end
+
+      def uuid_primary_key?(result_instance)
+        result_instance.respond_to?(:column_for_attribute) &&
+          (column = result_instance.column_for_attribute(result_instance.class.primary_key)) &&
+          column.respond_to?(:sql_type) &&
+          column.sql_type == "uuid"
+      end
+
+      def clear_changes_information(result_instance)
+        if result_instance.respond_to?(:clear_changes_information)
+          result_instance.clear_changes_information
+        end
+      end
+
+      def set_timestamps(result_instance)
+        timestamp = Time.current
+
+        if missing_created_at?(result_instance)
+          result_instance.created_at = timestamp
+        end
+
+        if missing_updated_at?(result_instance)
+          result_instance.updated_at = timestamp
+        end
+      end
+
+      def missing_created_at?(result_instance)
+        result_instance.respond_to?(:created_at) &&
+          result_instance.respond_to?(:created_at=) &&
+          result_instance.created_at.blank?
+      end
+
+      def missing_updated_at?(result_instance)
+        result_instance.respond_to?(:updated_at) &&
+          result_instance.respond_to?(:updated_at=) &&
+          result_instance.updated_at.blank?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require "factory_bot/strategy/build"
+require "factory_bot/strategy/create"
+require "factory_bot/strategy/attributes_for"
+require "factory_bot/strategy/stub"
+require "factory_bot/strategy/null"
+
+module FactoryBot
+  module Strategy
+    def self.lookup_strategy(name_or_object)
+      return name_or_object if name_or_object.is_a?(Class)
+
+      FactoryBot::Internal.strategy_by_name(name_or_object)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module FactoryBot
+  # @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
+
+    def self.with_index(block, index)
+      if block&.arity == 2
+        ->(instance) { block.call(instance, index) }
+      else
+        block
+      end
+    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
+
+        Array.new(amount) do |i|
+          block_with_index = StrategySyntaxMethodRegistrar.with_index(block, i)
+          send(strategy_name, name, *traits_and_overrides, &block_with_index)
+        end
+      end
+    end
+
+    def define_pair_strategy_method
+      strategy_name = @strategy_name
+
+      define_syntax_method("#{strategy_name}_pair") do |name, *traits_and_overrides, &block|
+        Array.new(2) { send(strategy_name, name, *traits_and_overrides, &block) }
+      end
+    end
+
+    def define_syntax_method(name, &block)
+      FactoryBot::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/factory_bot-6.6.0/lib/factory_bot/syntax/default.rb

@@ -0,0 +1,64 @@
+module FactoryBot
+  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 = FactoryBot::DefinitionProxy.new(factory.definition)
+          proxy.instance_eval(&block) if block
+
+          Internal.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, ...)
+          Internal.register_sequence(Sequence.new(name, ...))
+        end
+
+        def trait(name, &block)
+          Internal.register_trait(Trait.new(name, &block))
+        end
+
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+
+        delegate :after,
+          :before,
+          :callback,
+          :initialize_with,
+          :skip_create,
+          :to_create,
+          to: FactoryBot::Internal
+      end
+
+      class ModifyDSL
+        def factory(name, _options = {}, &block)
+          factory = Internal.factory_by_name(name)
+          proxy = FactoryBot::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