@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/.document

@@ -1 +0,0 @@
-# Vendored files do not need to be documented

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/assignment.rb

@@ -1,20 +0,0 @@
-module Bundler::PubGrub
-  class Assignment
-    attr_reader :term, :cause, :decision_level, :index
-    def initialize(term, cause, decision_level, index)
-      @term = term
-      @cause = cause
-      @decision_level = decision_level
-      @index = index
-    end
-
-    def self.decision(package, version, decision_level, index)
-      term = Term.new(VersionConstraint.exact(package, version), true)
-      new(term, :decision, decision_level, index)
-    end
-
-    def decision?
-      cause == :decision
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/basic_package_source.rb

@@ -1,169 +0,0 @@
-require_relative 'version_constraint'
-require_relative 'incompatibility'
-
-module Bundler::PubGrub
-  # Types:
-  #
-  # Where possible, Bundler::PubGrub will accept user-defined types, so long as they quack.
-  #
-  # ## "Package":
-  #
-  # This class will be used to represent the various packages being solved for.
-  # .to_s will be called when displaying errors and debugging info, it should
-  # probably return the package's name.
-  # It must also have a reasonable definition of #== and #hash
-  #
-  # Example classes: String ("rails")
-  #
-  #
-  # ## "Version":
-  #
-  # This class will be used to represent a single version number.
-  #
-  # Versions don't need to store their associated package, however they will
-  # only be compared against other versions of the same package.
-  #
-  # It must be Comparible (and implement <=> reasonably)
-  #
-  # Example classes: Gem::Version, Integer
-  #
-  #
-  # ## "Dependency"
-  #
-  # This class represents the requirement one package has on another. It is
-  # returned by dependencies_for(package, version) and will be passed to
-  # parse_dependency to convert it to a format Bundler::PubGrub understands.
-  #
-  # It must also have a reasonable definition of #==
-  #
-  # Example classes: String ("~> 1.0"), Gem::Requirement
-  #
-  class BasicPackageSource
-    # Override me!
-    #
-    # This is called per package to find all possible versions of a package.
-    #
-    # It is called at most once per-package
-    #
-    # Returns: Array of versions for a package, in preferred order of selection
-    def all_versions_for(package)
-      raise NotImplementedError
-    end
-
-    # Override me!
-    #
-    # Returns: Hash in the form of { package => requirement, ... }
-    def dependencies_for(package, version)
-      raise NotImplementedError
-    end
-
-    # Override me!
-    #
-    # Convert a (user-defined) dependency into a format Bundler::PubGrub understands.
-    #
-    # Package is passed to this method but for many implementations is not
-    # needed.
-    #
-    # Returns: either a Bundler::PubGrub::VersionRange, Bundler::PubGrub::VersionUnion, or a
-    #   Bundler::PubGrub::VersionConstraint
-    def parse_dependency(package, dependency)
-      raise NotImplementedError
-    end
-
-    # Override me!
-    #
-    # If not overridden, this will call dependencies_for with the root package.
-    #
-    # Returns: Hash in the form of { package => requirement, ... } (see dependencies_for)
-    def root_dependencies
-      dependencies_for(@root_package, @root_version)
-    end
-
-    def initialize
-      @root_package = Package.root
-      @root_version = Package.root_version
-
-      @sorted_versions = Hash.new do |h,k|
-        if k == @root_package
-          h[k] = [@root_version]
-        else
-          h[k] = all_versions_for(k).sort
-        end
-      end
-
-      @cached_dependencies = Hash.new do |packages, package|
-        if package == @root_package
-          packages[package] = {
-            @root_version => root_dependencies
-          }
-        else
-          packages[package] = Hash.new do |versions, version|
-            versions[version] = dependencies_for(package, version)
-          end
-        end
-      end
-    end
-
-    def versions_for(package, range=VersionRange.any)
-      range.select_versions(@sorted_versions[package])
-    end
-
-    def no_versions_incompatibility_for(_package, unsatisfied_term)
-      cause = Incompatibility::NoVersions.new(unsatisfied_term)
-
-      Incompatibility.new([unsatisfied_term], cause: cause)
-    end
-
-    def incompatibilities_for(package, version)
-      package_deps = @cached_dependencies[package]
-      sorted_versions = @sorted_versions[package]
-      package_deps[version].map do |dep_package, dep_constraint_name|
-        low = high = sorted_versions.index(version)
-
-        # find version low such that all >= low share the same dep
-        while low > 0 &&
-            package_deps[sorted_versions[low - 1]][dep_package] == dep_constraint_name
-          low -= 1
-        end
-        low =
-          if low == 0
-            nil
-          else
-            sorted_versions[low]
-          end
-
-        # find version high such that all < high share the same dep
-        while high < sorted_versions.length &&
-            package_deps[sorted_versions[high]][dep_package] == dep_constraint_name
-          high += 1
-        end
-        high =
-          if high == sorted_versions.length
-            nil
-          else
-            sorted_versions[high]
-          end
-
-        range = VersionRange.new(min: low, max: high, include_min: !low.nil?)
-
-        self_constraint = VersionConstraint.new(package, range: range)
-
-        if !@packages.include?(dep_package)
-          # no such package -> this version is invalid
-        end
-
-        dep_constraint = parse_dependency(dep_package, dep_constraint_name)
-        if !dep_constraint
-          # falsey indicates this dependency was invalid
-          cause = Bundler::PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
-          return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
-        elsif !dep_constraint.is_a?(VersionConstraint)
-          # Upgrade range/union to VersionConstraint
-          dep_constraint = VersionConstraint.new(dep_package, range: dep_constraint)
-        end
-
-        Incompatibility.new([Term.new(self_constraint, true), Term.new(dep_constraint, false)], cause: :dependency)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/failure_writer.rb

@@ -1,182 +0,0 @@
-module Bundler::PubGrub
-  class FailureWriter
-    def initialize(root)
-      @root = root
-
-      # { Incompatibility => Integer }
-      @derivations = {}
-
-      # [ [ String, Integer or nil ] ]
-      @lines = []
-
-      # { Incompatibility => Integer }
-      @line_numbers = {}
-
-      count_derivations(root)
-    end
-
-    def write
-      return @root.to_s unless @root.conflict?
-
-      visit(@root)
-
-      padding = @line_numbers.empty? ? 0 : "(#{@line_numbers.values.last}) ".length
-
-      @lines.map do |message, number|
-        next "" if message.empty?
-
-        lead = number ? "(#{number}) " : ""
-        lead = lead.ljust(padding)
-        message = message.gsub("\n", "\n" + " " * (padding + 2))
-        "#{lead}#{message}"
-      end.join("\n")
-    end
-
-    private
-
-    def write_line(incompatibility, message, numbered:)
-      if numbered
-        number = @line_numbers.length + 1
-        @line_numbers[incompatibility] = number
-      end
-
-      @lines << [message, number]
-    end
-
-    def visit(incompatibility, conclusion: false)
-      raise unless incompatibility.conflict?
-
-      numbered = conclusion || @derivations[incompatibility] > 1;
-      conjunction = conclusion || incompatibility == @root ? "So," : "And"
-
-      cause = incompatibility.cause
-
-      if cause.conflict.conflict? && cause.other.conflict?
-        conflict_line = @line_numbers[cause.conflict]
-        other_line = @line_numbers[cause.other]
-
-        if conflict_line && other_line
-          write_line(
-            incompatibility,
-            "Because #{cause.conflict} (#{conflict_line})\nand #{cause.other} (#{other_line}),\n#{incompatibility}.",
-            numbered: numbered
-          )
-        elsif conflict_line || other_line
-          with_line    = conflict_line ? cause.conflict : cause.other
-          without_line = conflict_line ? cause.other : cause.conflict
-          line = @line_numbers[with_line]
-
-          visit(without_line);
-          write_line(
-            incompatibility,
-            "#{conjunction} because #{with_line} (#{line}),\n#{incompatibility}.",
-            numbered: numbered
-          )
-        else
-          single_line_conflict = single_line?(cause.conflict.cause)
-          single_line_other    = single_line?(cause.other.cause)
-
-          if single_line_conflict || single_line_other
-            first  = single_line_other ? cause.conflict : cause.other
-            second = single_line_other ? cause.other : cause.conflict
-            visit(first)
-            visit(second)
-            write_line(
-              incompatibility,
-              "Thus, #{incompatibility}.",
-              numbered: numbered
-            )
-          else
-            visit(cause.conflict, conclusion: true)
-            @lines << ["", nil]
-            visit(cause.other)
-
-            write_line(
-              incompatibility,
-              "#{conjunction} because #{cause.conflict} (#{@line_numbers[cause.conflict]}),\n#{incompatibility}.",
-              numbered: numbered
-            )
-          end
-        end
-      elsif cause.conflict.conflict? || cause.other.conflict?
-        derived = cause.conflict.conflict? ? cause.conflict : cause.other
-        ext     = cause.conflict.conflict? ? cause.other : cause.conflict
-
-        derived_line = @line_numbers[derived]
-        if derived_line
-          write_line(
-            incompatibility,
-            "Because #{ext}\nand #{derived} (#{derived_line}),\n#{incompatibility}.",
-            numbered: numbered
-          )
-        elsif collapsible?(derived)
-          derived_cause = derived.cause
-          if derived_cause.conflict.conflict?
-            collapsed_derived = derived_cause.conflict
-            collapsed_ext = derived_cause.other
-          else
-            collapsed_derived = derived_cause.other
-            collapsed_ext = derived_cause.conflict
-          end
-
-          visit(collapsed_derived)
-
-          write_line(
-            incompatibility,
-            "#{conjunction} because #{collapsed_ext}\nand #{ext},\n#{incompatibility}.",
-            numbered: numbered
-          )
-        else
-          visit(derived)
-          write_line(
-            incompatibility,
-            "#{conjunction} because #{ext},\n#{incompatibility}.",
-            numbered: numbered
-          )
-        end
-      else
-        write_line(
-          incompatibility,
-          "Because #{cause.conflict}\nand #{cause.other},\n#{incompatibility}.",
-          numbered: numbered
-        )
-      end
-    end
-
-    def single_line?(cause)
-      !cause.conflict.conflict? && !cause.other.conflict?
-    end
-
-    def collapsible?(incompatibility)
-      return false if @derivations[incompatibility] > 1
-
-      cause = incompatibility.cause
-      # If incompatibility is derived from two derived incompatibilities,
-      # there are too many transitive causes to display concisely.
-      return false if cause.conflict.conflict? && cause.other.conflict?
-
-      # If incompatibility is derived from two external incompatibilities, it
-      # tends to be confusing to collapse it.
-      return false unless cause.conflict.conflict? || cause.other.conflict?
-
-      # If incompatibility's internal cause is numbered, collapsing it would
-      # get too noisy.
-      complex = cause.conflict.conflict? ? cause.conflict : cause.other
-
-      !@line_numbers.has_key?(complex)
-    end
-
-    def count_derivations(incompatibility)
-      if @derivations.has_key?(incompatibility)
-        @derivations[incompatibility] += 1
-      else
-        @derivations[incompatibility] = 1
-        if incompatibility.conflict?
-          cause = incompatibility.cause
-          count_derivations(cause.conflict)
-          count_derivations(cause.other)
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/incompatibility.rb

@@ -1,150 +0,0 @@
-module Bundler::PubGrub
-  class Incompatibility
-    ConflictCause = Struct.new(:incompatibility, :satisfier) do
-      alias_method :conflict, :incompatibility
-      alias_method :other, :satisfier
-    end
-
-    InvalidDependency = Struct.new(:package, :constraint) do
-    end
-
-    NoVersions = Struct.new(:constraint) do
-    end
-
-    attr_reader :terms, :cause
-
-    def initialize(terms, cause:, custom_explanation: nil)
-      @cause = cause
-      @terms = cleanup_terms(terms)
-      @custom_explanation = custom_explanation
-
-      if cause == :dependency && @terms.length != 2
-        raise ArgumentError, "a dependency Incompatibility must have exactly two terms. Got #{@terms.inspect}"
-      end
-    end
-
-    def hash
-      cause.hash ^ terms.hash
-    end
-
-    def eql?(other)
-      cause.eql?(other.cause) &&
-        terms.eql?(other.terms)
-    end
-
-    def failure?
-      terms.empty? || (terms.length == 1 && Package.root?(terms[0].package) && terms[0].positive?)
-    end
-
-    def conflict?
-      ConflictCause === cause
-    end
-
-    # Returns all external incompatibilities in this incompatibility's
-    # derivation graph
-    def external_incompatibilities
-      if conflict?
-        [
-          cause.conflict,
-          cause.other
-        ].flat_map(&:external_incompatibilities)
-      else
-        [this]
-      end
-    end
-
-    def to_s
-      return @custom_explanation if @custom_explanation
-
-      case cause
-      when :root
-        "(root dependency)"
-      when :dependency
-        "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
-      when Bundler::PubGrub::Incompatibility::InvalidDependency
-        "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"
-      when Bundler::PubGrub::Incompatibility::NoVersions
-        "no versions satisfy #{cause.constraint}"
-      when Bundler::PubGrub::Incompatibility::ConflictCause
-        if failure?
-          "version solving has failed"
-        elsif terms.length == 1
-          term = terms[0]
-          if term.positive?
-            if term.constraint.any?
-              "#{term.package} cannot be used"
-            else
-              "#{term.to_s(allow_every: true)} cannot be used"
-            end
-          else
-            "#{term.invert} is required"
-          end
-        else
-          if terms.all?(&:positive?)
-            if terms.length == 2
-              "#{terms[0].to_s(allow_every: true)} is incompatible with #{terms[1]}"
-            else
-              "one of #{terms.map(&:to_s).join(" or ")} must be false"
-            end
-          elsif terms.all?(&:negative?)
-            if terms.length == 2
-              "either #{terms[0].invert} or #{terms[1].invert}"
-            else
-              "one of #{terms.map(&:invert).join(" or ")} must be true";
-            end
-          else
-            positive = terms.select(&:positive?)
-            negative = terms.select(&:negative?).map(&:invert)
-
-            if positive.length == 1
-              "#{positive[0].to_s(allow_every: true)} requires #{negative.join(" or ")}"
-            else
-              "if #{positive.join(" and ")} then #{negative.join(" or ")}"
-            end
-          end
-        end
-      else
-        raise "unhandled cause: #{cause.inspect}"
-      end
-    end
-
-    def inspect
-      "#<#{self.class} #{to_s}>"
-    end
-
-    def pretty_print(q)
-      q.group 2, "#<#{self.class}", ">" do
-        q.breakable
-        q.text to_s
-
-        q.breakable
-        q.text " caused by "
-        q.pp @cause
-      end
-    end
-
-    private
-
-    def cleanup_terms(terms)
-      terms.each do |term|
-        raise "#{term.inspect} must be a term" unless term.is_a?(Term)
-      end
-
-      if terms.length != 1 && ConflictCause === cause
-        terms = terms.reject do |term|
-          term.positive? && Package.root?(term.package)
-        end
-      end
-
-      # Optimized simple cases
-      return terms if terms.length <= 1
-      return terms if terms.length == 2 && terms[0].package != terms[1].package
-
-      terms.group_by(&:package).map do |package, common_terms|
-        common_terms.inject do |acc, term|
-          acc.intersect(term)
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/package.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::PubGrub
-  class Package
-
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-    end
-
-    def inspect
-      "#<#{self.class} #{name.inspect}>"
-    end
-
-    def <=>(other)
-      name <=> other.name
-    end
-
-    ROOT = Package.new(:root)
-    ROOT_VERSION = 0
-
-    def self.root
-      ROOT
-    end
-
-    def self.root_version
-      ROOT_VERSION
-    end
-
-    def self.root?(package)
-      if package.respond_to?(:root?)
-        package.root?
-      else
-        package == root
-      end
-    end
-
-    def to_s
-      name.to_s
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/partial_solution.rb

@@ -1,121 +0,0 @@
-require_relative 'assignment'
-
-module Bundler::PubGrub
-  class PartialSolution
-    attr_reader :assignments, :decisions
-    attr_reader :attempted_solutions
-
-    def initialize
-      reset!
-
-      @attempted_solutions = 1
-      @backtracking = false
-    end
-
-    def decision_level
-      @decisions.length
-    end
-
-    def relation(term)
-      package = term.package
-      return :overlap if !@terms.key?(package)
-
-      @relation_cache[package][term] ||=
-        @terms[package].relation(term)
-    end
-
-    def satisfies?(term)
-      relation(term) == :subset
-    end
-
-    def derive(term, cause)
-      add_assignment(Assignment.new(term, cause, decision_level, assignments.length))
-    end
-
-    def satisfier(term)
-      assignment =
-        @assignments_by[term.package].bsearch do |assignment_by|
-          @cumulative_assignments[assignment_by].satisfies?(term)
-        end
-
-      assignment || raise("#{term} unsatisfied")
-    end
-
-    # A list of unsatisfied terms
-    def unsatisfied
-      @required.keys.reject do |package|
-        @decisions.key?(package)
-      end.map do |package|
-        @terms[package]
-      end
-    end
-
-    def decide(package, version)
-      @attempted_solutions += 1 if @backtracking
-      @backtracking = false;
-
-      decisions[package] = version
-      assignment = Assignment.decision(package, version, decision_level, assignments.length)
-      add_assignment(assignment)
-    end
-
-    def backtrack(previous_level)
-      @backtracking = true
-
-      new_assignments = assignments.select do |assignment|
-        assignment.decision_level <= previous_level
-      end
-
-      new_decisions = Hash[decisions.first(previous_level)]
-
-      reset!
-
-      @decisions = new_decisions
-
-      new_assignments.each do |assignment|
-        add_assignment(assignment)
-      end
-    end
-
-    private
-
-    def reset!
-      # { Array<Assignment> }
-      @assignments = []
-
-      # { Package => Array<Assignment> }
-      @assignments_by = Hash.new { |h,k| h[k] = [] }
-      @cumulative_assignments = {}.compare_by_identity
-
-      # { Package => Package::Version }
-      @decisions = {}
-
-      # { Package => Term }
-      @terms = {}
-      @relation_cache = Hash.new { |h,k| h[k] = {} }
-
-      # { Package => Boolean }
-      @required = {}
-    end
-
-    def add_assignment(assignment)
-      term = assignment.term
-      package = term.package
-
-      @assignments << assignment
-      @assignments_by[package] << assignment
-
-      @required[package] = true if term.positive?
-
-      if @terms.key?(package)
-        old_term = @terms[package]
-        @terms[package] = old_term.intersect(term)
-      else
-        @terms[package] = term
-      end
-      @relation_cache[package].clear
-
-      @cumulative_assignments[assignment] = @terms[package]
-    end
-  end
-end