tiny-lite-mod 0.0.1

data/factory_bot-6.6.0/README.md

@@ -0,0 +1,99 @@
+# factory_bot 
+
+[![Build Status][ci-image]][ci] [![Gem Version][version-image]][version]
+
+factory_bot is a fixtures replacement with a straightforward definition syntax, support for multiple build strategies (saved instances, unsaved instances, attribute hashes, and stubbed objects), and support for multiple factories for the same class (user, admin_user, and so on), including factory inheritance.
+
+If you want to use factory_bot with Rails, see
+[factory_bot_rails](https://github.com/thoughtbot/factory_bot_rails).
+
+Interested in the history of the project name? You can find the history [here](https://github.com/thoughtbot/factory_bot/blob/main/NAME.md)
+
+Transitioning from factory\_girl? Check out the [upgrade guide](https://github.com/thoughtbot/factory_bot/blob/v4.9.0/UPGRADE_FROM_FACTORY_GIRL.md).
+
+## Documentation
+
+See our extensive reference, guides, and cookbook in [the factory_bot book][].
+
+For information on integrations with third party libraries, such as RSpec or
+Rails, see [the factory_bot wiki][].
+
+ We also have [a detailed introductory video][], available for free on Upcase.
+
+[a detailed introductory video]: https://upcase.com/videos/factory-bot?utm_source=github&utm_medium=open-source&utm_campaign=factory-girl
+[the factory_bot book]: https://thoughtbot.github.io/factory_bot
+[the factory_bot wiki]: https://github.com/thoughtbot/factory_bot/wiki
+
+## Install
+
+Run:
+
+```ruby
+bundle add factory_bot
+```
+
+To install the gem manually from your shell, run:
+
+```shell
+gem install factory_bot
+```
+
+## Supported Ruby versions
+
+Supported Ruby versions are listed in `.github/workflows/build.yml` ([source](https://github.com/thoughtbot/factory_bot/blob/main/.github/workflows/build.yml))
+
+## More Information
+
+* [Rubygems](https://rubygems.org/gems/factory_bot)
+* [Stack Overflow](https://stackoverflow.com/questions/tagged/factory-bot)
+* [Issues](https://github.com/thoughtbot/factory_bot/issues)
+* [GIANT ROBOTS SMASHING INTO OTHER GIANT ROBOTS](https://robots.thoughtbot.com/)
+
+[GETTING_STARTED]: https://github.com/thoughtbot/factory_bot/blob/main/GETTING_STARTED.md
+
+## Useful Tools
+
+* [FactoryTrace](https://github.com/djezzzl/factory_trace) - helps to find unused factories and traits.
+* [ruby-lsp-factory_bot](https://github.com/donny741/ruby-lsp-factory_bot) / [ruby-lsp-rails-factory-bot](https://github.com/johansenja/ruby-lsp-rails-factory-bot) - integration with [ruby-lsp](https://github.com/Shopify/ruby-lsp) to provide intellisense
+
+Contributing
+------------
+
+Please see [CONTRIBUTING.md](https://github.com/thoughtbot/factory_bot/blob/main/CONTRIBUTING.md).
+
+factory_bot was originally written by Joe Ferris and is maintained by thoughtbot.
+Many improvements and bugfixes were contributed by the [open source
+community](https://github.com/thoughtbot/factory_bot/graphs/contributors).
+
+License
+-------
+
+factory_bot is Copyright © 2008 Joe Ferris and thoughtbot. It is free
+software, and may be redistributed under the terms specified in the
+[LICENSE] file.
+
+[LICENSE]: https://github.com/thoughtbot/factory_bot/blob/main/LICENSE
+
+<!-- START /templates/footer.md -->
+## About thoughtbot
+
+![thoughtbot](https://thoughtbot.com/thoughtbot-logo-for-readmes.svg)
+
+This repo is maintained and funded by thoughtbot, inc.
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+We love open source software!
+See [our other projects][community].
+We are [available for hire][hire].
+
+[community]: https://thoughtbot.com/community?utm_source=github
+[hire]: https://thoughtbot.com/hire-us?utm_source=github
+
+<!-- END /templates/footer.md -->
+
+[ci-image]: https://github.com/thoughtbot/factory_bot/actions/workflows/build.yml/badge.svg?branch=main
+[ci]: https://github.com/thoughtbot/factory_bot/actions?query=workflow%3ABuild+branch%3Amain
+[version-image]: https://badge.fury.io/rb/factory_bot.svg
+[version]: https://badge.fury.io/rb/factory_bot
+[hound-badge-image]: https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg
+[hound]: https://houndci.com

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

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

data/factory_bot-6.6.0/lib/factory_bot/attribute/association.rb

@@ -0,0 +1,27 @@
+module FactoryBot
+  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_bot-6.6.0/lib/factory_bot/attribute/dynamic.rb

@@ -0,0 +1,25 @@
+module FactoryBot
+  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, -2 then instance_exec(self, &block)
+          else instance_exec(&block)
+          end
+          raise SequenceAbuseError if FactoryBot::Sequence === value
+
+          value
+        }
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+require "factory_bot/attribute/dynamic"
+require "factory_bot/attribute/association"
+require "factory_bot/attribute/sequence"
+
+module FactoryBot
+  # @api private
+  class Attribute
+    attr_reader :name, :ignored
+
+    def initialize(name, ignored)
+      @name = name.to_sym
+      @ignored = ignored
+    end
+
+    def to_proc
+      -> {}
+    end
+
+    def association?
+      false
+    end
+
+    def alias_for?(attr)
+      FactoryBot.aliases_for(attr).include?(name)
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+module FactoryBot
+  # @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
+
+    # constructs an object-based factory product
+    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
+
+    # constructs a Hash-based factory product
+    def hash
+      @evaluator.instance = build_hash
+
+      attributes_to_set_on_hash.each_with_object({}) do |attribute, result|
+        result[attribute] = get(attribute)
+      end
+    end
+
+    private
+
+    # Track evaluation of methods on the evaluator to prevent the duplicate
+    # assignment of attributes accessed and via `initialize_with` syntax
+    def method_tracking_evaluator
+      @method_tracking_evaluator ||= Decorator::AttributeHash.new(
+        decorated_evaluator,
+        attribute_names_to_assign
+      )
+    end
+
+    def decorated_evaluator
+      Decorator::NewConstructor.new(
+        Decorator::InvocationTracker.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
+
+    # Builds a list of attributes names that should be assigned to the factory product
+    def attribute_names_to_assign
+      @attribute_names_to_assign ||= begin
+        # start a list of candidates containing non-transient attributes and overrides
+        assignment_candidates = non_ignored_attribute_names + override_names
+        # then remove any transient attributes (potentially reintroduced by the overrides),
+        # and remove ignorable aliased attributes from the candidate list
+        assignment_candidates - ignored_attribute_names - attribute_names_overriden_by_alias
+      end
+    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 attribute_names
+      @attribute_list.names
+    end
+
+    def hash_instance_methods_to_respond_to
+      attribute_names + override_names + @build_class.instance_methods
+    end
+
+    # Builds a list of attribute names which are slated to be interrupted by an override.
+    def attribute_names_overriden_by_alias
+      @attribute_list
+        .non_ignored
+        .flat_map { |attribute|
+          override_names.map do |override|
+            attribute.name if ignorable_alias?(attribute, override)
+          end
+        }
+        .compact
+    end
+
+    # Is the attribute an ignorable alias of the override?
+    # An attribute is ignorable when it is an alias of the override AND it is
+    # either interrupting an assocciation OR is not the name of another attribute
+    #
+    # @note An "alias" is currently an overloaded term for two distinct cases:
+    #   (1) attributes which are aliases and reference the same value
+    #   (2) a logical grouping of a foreign key and an associated object
+    def ignorable_alias?(attribute, override)
+      return false unless attribute.alias_for?(override)
+
+      # The attribute alias should be ignored when the override interrupts an association
+      return true if override_interrupts_association?(attribute, override)
+
+      # Remaining aliases should be ignored when the override does not match a declared attribute.
+      # An override which is an alias to a declared attribute should not interrupt the aliased
+      # attribute and interrupt only the attribute with a matching name. This workaround allows a
+      # factory to declare both <attribute> and <attribute>_id as separate and distinct attributes.
+      !override_matches_declared_attribute?(override)
+    end
+
+    # Does this override interrupt an association?
+    # When true, this indicates the aliased attribute is related to a declared association and the
+    # override does not match the attribute name.
+    #
+    # @note Association overrides should take precedence over a declared foreign key attribute.
+    #
+    # @note An override may interrupt an association by providing the associated object or
+    #   by providing the foreign key.
+    #
+    # @param [FactoryBot::Attribute] aliased_attribute
+    # @param [Symbol] override name of an override which is an alias to the attribute name
+    def override_interrupts_association?(aliased_attribute, override)
+      (aliased_attribute.association? || association_names.include?(override)) &&
+        aliased_attribute.name != override
+    end
+
+    # Does this override match the name of any declared attribute?
+    #
+    # @note Checking against the names of all attributes, resolves any issues with having both
+    #   <attribute> and <attribute>_id in the same factory. This also takes into account ignored
+    #   attributes that should not be assigned (aka transient attributes)
+    #
+    # @param [Symbol] override the name of an override
+    def override_matches_declared_attribute?(override)
+      attribute_names.include?(override)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module FactoryBot
+  # @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
+        message = "Self-referencing association '#{attribute.name}' in '#{attribute.factory}'"
+        raise AssociationDefinitionError, message
+      end
+    end
+
+    def attribute_defined?(attribute_name)
+      @attributes.any? do |attribute|
+        attribute.name == attribute_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module FactoryBot
+  class Callback
+    attr_reader :name
+
+    def initialize(name, block)
+      @name = name.to_sym
+      @block = block
+    end
+
+    def run(instance, evaluator)
+      case block.arity
+      when 1, -1, -2 then syntax_runner.instance_exec(instance, &block)
+      when 2 then syntax_runner.instance_exec(instance, evaluator, &block)
+      else syntax_runner.instance_exec(&block)
+      end
+    end
+
+    def ==(other)
+      name == other.name &&
+        block == other.block
+    end
+
+    protected
+
+    attr_reader :block
+
+    private
+
+    def syntax_runner
+      @syntax_runner ||= SyntaxRunner.new
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module FactoryBot
+  # @api private
+  class CallbacksObserver
+    def initialize(callbacks, evaluator)
+      @callbacks = callbacks
+      @evaluator = evaluator
+      @completed = []
+    end
+
+    def update(name, result_instance)
+      callbacks_by_name(name).each do |callback|
+        if !completed?(result_instance, callback)
+          callback.run(result_instance, @evaluator)
+          record_completion!(result_instance, callback)
+        end
+      end
+    end
+
+    private
+
+    def callbacks_by_name(name)
+      @callbacks.select { |callback| callback.name == name }
+    end
+
+    def completed?(instance, callback)
+      key = completion_key_for(instance, callback)
+      @completed.include?(key)
+    end
+
+    def record_completion!(instance, callback)
+      key = completion_key_for(instance, callback)
+      @completed << key
+    end
+
+    def completion_key_for(instance, callback)
+      "#{instance.object_id}-#{callback.object_id}"
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module FactoryBot
+  # @api private
+  class Configuration
+    attr_reader(
+      :callback_names,
+      :factories,
+      :inline_sequences,
+      :sequences,
+      :strategies,
+      :traits
+    )
+
+    def initialize
+      @factories = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Factory"))
+      @sequences = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Sequence"))
+      @traits = Decorator::DisallowsDuplicatesRegistry.new(Registry.new("Trait"))
+      @strategies = Registry.new("Strategy")
+      @callback_names = Set.new
+      @definition = Definition.new(:configuration)
+      @inline_sequences = []
+
+      to_create(&:save!)
+      initialize_with { new }
+    end
+
+    delegate :to_create, :skip_create, :constructor, :before, :after,
+      :callback, :callbacks, to: :@definition
+
+    def initialize_with(&block)
+      @definition.define_constructor(&block)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module FactoryBot
+  class Declaration
+    # @api private
+    class Association < Declaration
+      def initialize(name, *options)
+        super(name, false)
+        @options = options.dup
+        @overrides = options.extract_options!
+        @factory_name = @overrides.delete(:factory) || name
+        @traits = options
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          name == other.name &&
+          options == other.options
+      end
+
+      protected
+
+      attr_reader :options
+
+      private
+
+      attr_reader :factory_name, :overrides, :traits
+
+      def build
+        raise_if_arguments_are_declarations!
+
+        [
+          Attribute::Association.new(
+            name,
+            factory_name,
+            [traits, overrides].flatten
+          )
+        ]
+      end
+
+      def raise_if_arguments_are_declarations!
+        if factory_name.is_a?(Declaration)
+          raise ArgumentError.new(<<~MSG)
+            Association '#{name}' received an invalid factory argument.
+            Did you mean? 'factory: :#{factory_name.name}'
+          MSG
+        end
+
+        overrides.each do |attribute, value|
+          if value.is_a?(Declaration)
+            raise ArgumentError.new(<<~MSG)
+              Association '#{name}' received an invalid attribute override.
+              Did you mean? '#{attribute}: :#{value.name}'
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module FactoryBot
+  class Declaration
+    # @api private
+    class Dynamic < Declaration
+      def initialize(name, ignored = false, block = nil)
+        super(name, ignored)
+        @block = block
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          name == other.name &&
+          ignored == other.ignored &&
+          block == other.block
+      end
+
+      protected
+
+      attr_reader :block
+
+      private
+
+      def build
+        [Attribute::Dynamic.new(name, @ignored, @block)]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module FactoryBot
+  class Declaration
+    # @api private
+    class Implicit < Declaration
+      def initialize(name, factory = nil, ignored = false)
+        super(name, ignored)
+        @factory = factory
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          name == other.name &&
+          factory == other.factory &&
+          ignored == other.ignored
+      end
+
+      protected
+
+      attr_reader :factory
+
+      private
+
+      def build
+        if FactoryBot.factories.registered?(name)
+          [Attribute::Association.new(name, name, {})]
+        elsif FactoryBot::Internal.sequences.registered?(name)
+          [Attribute::Sequence.new(name, name, @ignored)]
+        elsif @factory.name.to_s == name.to_s
+          message = "Self-referencing trait '#{@name}'"
+          raise TraitDefinitionError, message
+        else
+          @factory.inherit_traits([name])
+          []
+        end
+      end
+    end
+  end
+end