tiny-lite-mod 0.0.1

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

@@ -0,0 +1,23 @@
+require "factory_bot/declaration/dynamic"
+require "factory_bot/declaration/association"
+require "factory_bot/declaration/implicit"
+
+module FactoryBot
+  # @api private
+  class Declaration
+    attr_reader :name
+
+    def initialize(name, ignored = false)
+      @name = name
+      @ignored = ignored
+    end
+
+    def to_attributes
+      build
+    end
+
+    protected
+
+    attr_reader :ignored
+  end
+end

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

@@ -0,0 +1,49 @@
+module FactoryBot
+  # @api private
+  class DeclarationList
+    include Enumerable
+
+    def initialize(name = nil)
+      @declarations = []
+      @name = name
+      @overridable = false
+    end
+
+    def declare_attribute(declaration)
+      delete_declaration(declaration) if overridable?
+
+      @declarations << declaration
+      declaration
+    end
+
+    def overridable
+      @overridable = true
+    end
+
+    def attributes
+      @attributes ||= AttributeList.new(@name).tap do |list|
+        to_attributes.each do |attribute|
+          list.define_attribute(attribute)
+        end
+      end
+    end
+
+    def each(&block)
+      @declarations.each(&block)
+    end
+
+    private
+
+    def delete_declaration(declaration)
+      @declarations.delete_if { |decl| decl.name == declaration.name }
+    end
+
+    def to_attributes
+      @declarations.reduce([]) { |result, declaration| result + declaration.to_attributes }
+    end
+
+    def overridable?
+      @overridable
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/decorator/attribute_hash.rb

@@ -0,0 +1,16 @@
+module FactoryBot
+  class Decorator
+    class AttributeHash < Decorator
+      def initialize(component, attributes = [])
+        super(component)
+        @attributes = attributes
+      end
+
+      def attributes
+        @attributes.each_with_object({}) do |attribute_name, result|
+          result[attribute_name] = @component.send(attribute_name)
+        end
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/decorator/disallows_duplicates_registry.rb

@@ -0,0 +1,13 @@
+module FactoryBot
+  class Decorator
+    class DisallowsDuplicatesRegistry < Decorator
+      def register(name, item)
+        if registered?(name)
+          raise DuplicateDefinitionError, "#{@component.name} already registered: #{name}"
+        else
+          @component.register(name, item)
+        end
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/decorator/invocation_tracker.rb

@@ -0,0 +1,20 @@
+module FactoryBot
+  class Decorator
+    class InvocationTracker < Decorator
+      def initialize(component)
+        super
+        @invoked_methods = []
+      end
+
+      def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+        @invoked_methods << name
+        super
+      end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
+
+      def __invoked_methods__
+        @invoked_methods.uniq
+      end
+    end
+  end
+end

data/factory_bot-6.6.0/lib/factory_bot/decorator/new_constructor.rb

@@ -0,0 +1,12 @@
+module FactoryBot
+  class Decorator
+    class NewConstructor < Decorator
+      def initialize(component, build_class)
+        super(component)
+        @build_class = build_class
+      end
+
+      delegate :new, to: :@build_class
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module FactoryBot
+  class Decorator < BasicObject
+    undef_method :==
+
+    def initialize(component)
+      @component = component
+    end
+
+    def method_missing(...) # rubocop:disable Style/MethodMissingSuper
+      @component.send(...)
+    end
+
+    def send(...)
+      __send__(...)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @component.respond_to?(name, true) || super
+    end
+
+    def self.const_missing(name)
+      ::Object.const_get(name)
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+module FactoryBot
+  # @api private
+  class Definition
+    attr_reader :defined_traits, :declarations, :name, :registered_enums, :uri_manager
+    attr_accessor :klass
+
+    def initialize(name, base_traits = [], **opts)
+      @name = name
+      @uri_manager = opts[:uri_manager]
+      @declarations = DeclarationList.new(name)
+      @callbacks = []
+      @defined_traits = Set.new
+      @registered_enums = []
+      @to_create = nil
+      @base_traits = base_traits
+      @additional_traits = []
+      @constructor = nil
+      @attributes = nil
+      @compiled = false
+      @expanded_enum_traits = false
+    end
+
+    delegate :declare_attribute, to: :declarations
+
+    def attributes
+      @attributes ||= AttributeList.new.tap do |attribute_list|
+        attribute_lists = aggregate_from_traits_and_self(:attributes) { declarations.attributes }
+        attribute_lists.each do |attributes|
+          attribute_list.apply_attributes attributes
+        end
+      end
+    end
+
+    def to_create(&block)
+      if block
+        @to_create = block
+      else
+        aggregate_from_traits_and_self(:to_create) { @to_create }.last
+      end
+    end
+
+    def constructor
+      aggregate_from_traits_and_self(:constructor) { @constructor }.last
+    end
+
+    def callbacks
+      aggregate_from_traits_and_self(:callbacks) { @callbacks }
+    end
+
+    def compile(klass = nil)
+      unless @compiled
+        expand_enum_traits(klass) unless klass.nil?
+
+        declarations.attributes
+
+        self.klass ||= klass
+        defined_traits.each do |defined_trait|
+          defined_trait.klass ||= klass
+          base_traits.each { |bt| bt.define_trait defined_trait }
+          additional_traits.each { |at| at.define_trait defined_trait }
+        end
+
+        @compiled = true
+
+        ActiveSupport::Notifications.instrument "factory_bot.compile_factory", {
+          name: name,
+          attributes: declarations.attributes,
+          traits: defined_traits,
+          class: klass || self.klass
+        }
+      end
+    end
+
+    def overridable
+      declarations.overridable
+      self
+    end
+
+    def inherit_traits(new_traits)
+      @base_traits += new_traits
+    end
+
+    def append_traits(new_traits)
+      @additional_traits += new_traits
+    end
+
+    def add_callback(callback)
+      @callbacks << callback
+    end
+
+    def skip_create
+      @to_create = ->(instance) {}
+    end
+
+    def define_trait(trait)
+      @defined_traits.add(trait)
+    end
+
+    def defined_traits_names
+      @defined_traits.map(&:name)
+    end
+
+    def register_enum(enum)
+      @registered_enums << enum
+    end
+
+    def define_constructor(&block)
+      @constructor = block
+    end
+
+    def before(*names, &block)
+      callback(*names.map { |name| "before_#{name}" }, &block)
+    end
+
+    def after(*names, &block)
+      callback(*names.map { |name| "after_#{name}" }, &block)
+    end
+
+    def callback(*names, &block)
+      names.each do |name|
+        add_callback(Callback.new(name, block))
+      end
+    end
+
+    private
+
+    def base_traits
+      @base_traits.map { |name| trait_by_name(name) }
+    rescue KeyError => error
+      raise error_with_definition_name(error)
+    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 error_with_definition_name(error)
+        message = error.message + " referenced within \"#{name}\" definition"
+
+        error.class.new(message, key: error.key, receiver: error.receiver)
+          .tap { |new_error| new_error.set_backtrace(error.backtrace) }
+      end
+    else
+      def error_with_definition_name(error)
+        message = error.message
+        message.insert(
+          message.index("\nDid you mean?") || message.length,
+          " referenced within \"#{name}\" definition"
+        )
+
+        error.class.new(message).tap do |new_error|
+          new_error.set_backtrace(error.backtrace)
+        end
+      end
+    end
+
+    def additional_traits
+      @additional_traits.map { |name| trait_by_name(name) }
+    end
+
+    def trait_by_name(name)
+      trait_for(name) || Internal.trait_by_name(name, klass)
+    end
+
+    def trait_for(name)
+      @defined_traits_by_name ||= defined_traits.each_with_object({}) { |t, memo| memo[t.name] ||= t }
+      @defined_traits_by_name[name.to_s]
+    end
+
+    def initialize_copy(source)
+      super
+      @attributes = nil
+      @compiled = false
+      @defined_traits_by_name = nil
+    end
+
+    def aggregate_from_traits_and_self(method_name, &block)
+      compile
+
+      [
+        base_traits.map(&method_name),
+        instance_exec(&block),
+        additional_traits.map(&method_name)
+      ].flatten.compact
+    end
+
+    def expand_enum_traits(klass)
+      return if @expanded_enum_traits
+
+      if automatically_register_defined_enums?(klass)
+        automatically_register_defined_enums(klass)
+      end
+
+      registered_enums.each do |enum|
+        traits = enum.build_traits(klass)
+        traits.each { |trait| define_trait(trait) }
+      end
+
+      @expanded_enum_traits = true
+    end
+
+    def automatically_register_defined_enums(klass)
+      klass.defined_enums.each_key { |name| register_enum(Enum.new(name)) }
+    end
+
+    def automatically_register_defined_enums?(klass)
+      FactoryBot.automatically_define_enum_traits &&
+        klass.respond_to?(:defined_enums)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module FactoryBot
+  class DefinitionHierarchy
+    delegate :callbacks, :constructor, :to_create, to: Internal
+
+    def self.build_from_definition(definition)
+      build_to_create(&definition.to_create)
+      build_constructor(&definition.constructor)
+      add_callbacks definition.callbacks
+    end
+
+    def self.add_callbacks(callbacks)
+      if callbacks.any?
+        define_method :callbacks do
+          super() + callbacks
+        end
+      end
+    end
+    private_class_method :add_callbacks
+
+    def self.build_constructor(&block)
+      if block
+        define_method(:constructor) do
+          block
+        end
+      end
+    end
+    private_class_method :build_constructor
+
+    def self.build_to_create(&block)
+      if block
+        define_method(:to_create) do
+          block
+        end
+      end
+    end
+    private_class_method :build_to_create
+  end
+end

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

@@ -0,0 +1,269 @@
+module FactoryBot
+  class DefinitionProxy
+    UNPROXIED_METHODS = %w[
+      __send__
+      __id__
+      nil?
+      send
+      object_id
+      extend
+      instance_eval
+      initialize
+      block_given?
+      raise
+      caller
+      method
+    ].freeze
+
+    (instance_methods + private_instance_methods).each do |method|
+      undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
+    end
+
+    delegate :before, :after, :callback, to: :@definition
+
+    attr_reader :child_factories
+
+    def initialize(definition, ignore = false)
+      @definition = definition
+      @ignore = ignore
+      @child_factories = []
+    end
+
+    def singleton_method_added(name)
+      message = "Defining methods in blocks (trait or factory) is not supported (#{name})"
+      raise FactoryBot::MethodDefinitionError, message
+    end
+
+    # Adds an attribute to the factory.
+    # The attribute value will be generated "lazily"
+    # by calling the block whenever an instance is generated.
+    # The block will not be called if the
+    # attribute is overridden for a specific instance.
+    #
+    # Arguments:
+    # * name: +Symbol+ or +String+
+    #   The name of this attribute. This will be assigned using "name=" for
+    #   generated instances.
+    def add_attribute(name, &block)
+      declaration = Declaration::Dynamic.new(name, @ignore, block)
+      @definition.declare_attribute(declaration)
+    end
+
+    def transient(&block)
+      proxy = DefinitionProxy.new(@definition, true)
+      proxy.instance_eval(&block)
+    end
+
+    # Calls add_attribute using the missing method name as the name of the
+    # attribute, so that:
+    #
+    #   factory :user do
+    #     name { 'Billy Idol' }
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     add_attribute(:name) { 'Billy Idol' }
+    #   end
+    #
+    # are equivalent.
+    #
+    # If no argument or block is given, factory_bot will first look for an
+    # association, then for a sequence, and finally for a trait with the same
+    # name. This means that given an "admin" trait, an "email" sequence, and an
+    # "account" factory:
+    #
+    #   factory :user, traits: [:admin] do
+    #     email { generate(:email) }
+    #     association :account
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     admin
+    #     email
+    #     account
+    #   end
+    #
+    # are equivalent.
+    def method_missing(name, *args, &block) # rubocop:disable Style/MissingRespondToMissing
+      association_options = args.first
+
+      if association_options.nil?
+        __declare_attribute__(name, block)
+      elsif __valid_association_options?(association_options)
+        association(name, association_options, &block)
+      else
+        raise NoMethodError.new(<<~MSG)
+          undefined method '#{name}' in '#{@definition.name}' factory
+          Did you mean? '#{name} { #{association_options.inspect} }'
+        MSG
+      end
+    end
+
+    # Adds an attribute that will have unique values generated by a sequence with
+    # a specified format.
+    #
+    # The result of:
+    #   factory :user do
+    #     sequence(:email) { |n| "person#{n}@example.com" }
+    #   end
+    #
+    # Is equal to:
+    #   sequence(:email) { |n| "person#{n}@example.com" }
+    #
+    #   factory :user do
+    #     email { FactoryBot.generate(:email) }
+    #   end
+    #
+    # Except that no globally available sequence will be defined.
+    def sequence(name, *args, &block)
+      options = args.extract_options!
+      options[:uri_paths] = @definition.uri_manager.to_a
+      args << options
+
+      new_sequence = Sequence.new(name, *args, &block)
+      registered_sequence = __fetch_or_register_sequence(new_sequence)
+      add_attribute(name) { increment_sequence(registered_sequence) }
+    end
+
+    # Adds an attribute that builds an association. The associated instance will
+    # be built using the same build strategy as the parent instance.
+    #
+    # Example:
+    #   factory :user do
+    #     name 'Joey'
+    #   end
+    #
+    #   factory :post do
+    #     association :author, factory: :user
+    #   end
+    #
+    # Arguments:
+    # * name: +Symbol+
+    #   The name of this attribute.
+    # * options: +Hash+
+    #
+    # Options:
+    # * factory: +Symbol+ or +String+
+    #    The name of the factory to use when building the associated instance.
+    #    If no name is given, the name of the attribute is assumed to be the
+    #    name of the factory. For example, a "user" association will by
+    #    default use the "user" factory.
+    def association(name, *options)
+      if block_given?
+        raise AssociationDefinitionError.new(
+          "Unexpected block passed to '#{name}' association " \
+          "in '#{@definition.name}' factory"
+        )
+      else
+        declaration = Declaration::Association.new(name, *options)
+        @definition.declare_attribute(declaration)
+      end
+    end
+
+    def to_create(&block)
+      @definition.to_create(&block)
+    end
+
+    def skip_create
+      @definition.skip_create
+    end
+
+    def factory(name, options = {}, &block)
+      child_factories << [name, options, block]
+    end
+
+    def trait(name, &block)
+      @definition.define_trait(Trait.new(name, uri_paths: @definition.uri_manager.to_a, &block))
+    end
+
+    # Creates traits for enumerable values.
+    #
+    # Example:
+    #   factory :task do
+    #     traits_for_enum :status, [:started, :finished]
+    #   end
+    #
+    # Equivalent to:
+    #   factory :task do
+    #     trait :started do
+    #       status { :started }
+    #     end
+    #
+    #     trait :finished do
+    #       status { :finished }
+    #     end
+    #   end
+    #
+    # Example:
+    #   factory :task do
+    #     traits_for_enum :status, {started: 1, finished: 2}
+    #   end
+    #
+    # Example:
+    #   class Task
+    #     def statuses
+    #       {started: 1, finished: 2}
+    #     end
+    #   end
+    #
+    #   factory :task do
+    #     traits_for_enum :status
+    #   end
+    #
+    # Both equivalent to:
+    #   factory :task do
+    #     trait :started do
+    #       status { 1 }
+    #     end
+    #
+    #     trait :finished do
+    #       status { 2 }
+    #     end
+    #   end
+    #
+    #
+    # Arguments:
+    #   attribute_name: +Symbol+ or +String+
+    #     the name of the attribute these traits will set the value of
+    #   values: +Array+, +Hash+, or other +Enumerable+
+    #     An array of trait names, or a mapping of trait names to values for
+    #     those traits. When this argument is not provided, factory_bot will
+    #     attempt to get the values by calling the pluralized `attribute_name`
+    #     class method.
+    def traits_for_enum(attribute_name, values = nil)
+      @definition.register_enum(Enum.new(attribute_name, values))
+    end
+
+    def initialize_with(&block)
+      @definition.define_constructor(&block)
+    end
+
+    private
+
+    def __declare_attribute__(name, block)
+      if block.nil?
+        declaration = Declaration::Implicit.new(name, @definition, @ignore)
+        @definition.declare_attribute(declaration)
+      else
+        add_attribute(name, &block)
+      end
+    end
+
+    def __valid_association_options?(options)
+      options.respond_to?(:has_key?) && options.has_key?(:factory)
+    end
+
+    ##
+    # If the inline sequence has already been registered by a parent,
+    # return that one, otherwise register and return the given sequence
+    #
+    def __fetch_or_register_sequence(sequence)
+      FactoryBot::Sequence.find_by_uri(sequence.uri_manager.first) ||
+        FactoryBot::Internal.register_inline_sequence(sequence)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module FactoryBot
+  # @api private
+  class Enum
+    def initialize(attribute_name, values = nil)
+      @attribute_name = attribute_name
+      @values = values
+    end
+
+    def build_traits(klass)
+      enum_values(klass).map do |trait_name, value|
+        build_trait(trait_name, @attribute_name, value || trait_name)
+      end
+    end
+
+    private
+
+    def enum_values(klass)
+      @values || klass.send(@attribute_name.to_s.pluralize)
+    end
+
+    def build_trait(trait_name, attribute_name, value)
+      Trait.new(trait_name) do
+        add_attribute(attribute_name) { value }
+      end
+    end
+  end
+end