@ai-ecoverse/wasix-ruby 3.4.11-1

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

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+module Bundler::PubGrub
+  class VersionRange
+    attr_reader :min, :max, :include_min, :include_max
+
+    alias_method :include_min?, :include_min
+    alias_method :include_max?, :include_max
+
+    class Empty < VersionRange
+      undef_method :min, :max
+      undef_method :include_min, :include_min?
+      undef_method :include_max, :include_max?
+
+      def initialize
+      end
+
+      def empty?
+        true
+      end
+
+      def eql?(other)
+        other.empty?
+      end
+
+      def hash
+        [].hash
+      end
+
+      def intersects?(_)
+        false
+      end
+
+      def intersect(other)
+        self
+      end
+
+      def allows_all?(other)
+        other.empty?
+      end
+
+      def include?(_)
+        false
+      end
+
+      def any?
+        false
+      end
+
+      def to_s
+        "(no versions)"
+      end
+
+      def ==(other)
+        other.class == self.class
+      end
+
+      def invert
+        VersionRange.any
+      end
+
+      def select_versions(_)
+        []
+      end
+    end
+
+    EMPTY = Empty.new
+    Empty.singleton_class.undef_method(:new)
+
+    def self.empty
+      EMPTY
+    end
+
+    def self.any
+      new
+    end
+
+    def initialize(min: nil, max: nil, include_min: false, include_max: false, name: nil)
+      raise ArgumentError, "Ranges without a lower bound cannot have include_min == true" if !min && include_min == true
+      raise ArgumentError, "Ranges without an upper bound cannot have include_max == true" if !max && include_max == true
+
+      @min = min
+      @max = max
+      @include_min = include_min
+      @include_max = include_max
+      @name = name
+    end
+
+    def hash
+      @hash ||= min.hash ^ max.hash ^ include_min.hash ^ include_max.hash
+    end
+
+    def eql?(other)
+      if other.is_a?(VersionRange)
+        !other.empty? &&
+          min.eql?(other.min) &&
+          max.eql?(other.max) &&
+          include_min.eql?(other.include_min) &&
+          include_max.eql?(other.include_max)
+      else
+        ranges.eql?(other.ranges)
+      end
+    end
+
+    def ranges
+      [self]
+    end
+
+    def include?(version)
+      compare_version(version) == 0
+    end
+
+    # Partitions passed versions into [lower, within, higher]
+    #
+    # versions must be sorted
+    def partition_versions(versions)
+      min_index =
+        if !min || versions.empty?
+          0
+        elsif include_min?
+          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] >= min }
+        else
+          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] > min }
+        end
+
+      lower = versions.slice(0, min_index)
+      versions = versions.slice(min_index, versions.size)
+
+      max_index =
+        if !max || versions.empty?
+          versions.size
+        elsif include_max?
+          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] > max }
+        else
+          (0..versions.size).bsearch { |i| versions[i].nil? || versions[i] >= max }
+        end
+
+      [
+        lower,
+        versions.slice(0, max_index),
+        versions.slice(max_index, versions.size)
+      ]
+    end
+
+    # Returns versions which are included by this range.
+    #
+    # versions must be sorted
+    def select_versions(versions)
+      return versions if any?
+
+      partition_versions(versions)[1]
+    end
+
+    def compare_version(version)
+      if min
+        case version <=> min
+        when -1
+          return -1
+        when 0
+          return -1 if !include_min
+        when 1
+        end
+      end
+
+      if max
+        case version <=> max
+        when -1
+        when 0
+          return 1 if !include_max
+        when 1
+          return 1
+        end
+      end
+
+      0
+    end
+
+    def strictly_lower?(other)
+      return false if !max || !other.min
+
+      case max <=> other.min
+      when 0
+        !include_max || !other.include_min
+      when -1
+        true
+      when 1
+        false
+      end
+    end
+
+    def strictly_higher?(other)
+      other.strictly_lower?(self)
+    end
+
+    def intersects?(other)
+      return false if other.empty?
+      return other.intersects?(self) if other.is_a?(VersionUnion)
+      !strictly_lower?(other) && !strictly_higher?(other)
+    end
+    alias_method :allows_any?, :intersects?
+
+    def intersect(other)
+      return other if other.empty?
+      return other.intersect(self) if other.is_a?(VersionUnion)
+
+      min_range =
+        if !min
+          other
+        elsif !other.min
+          self
+        else
+          case min <=> other.min
+          when 0
+            include_min ? other : self
+          when -1
+            other
+          when 1
+            self
+          end
+        end
+
+      max_range =
+        if !max
+          other
+        elsif !other.max
+          self
+        else
+          case max <=> other.max
+          when 0
+            include_max ? other : self
+          when -1
+            self
+          when 1
+            other
+          end
+        end
+
+      if !min_range.equal?(max_range) && min_range.min && max_range.max
+        case min_range.min <=> max_range.max
+        when -1
+        when 0
+          if !min_range.include_min || !max_range.include_max
+            return EMPTY
+          end
+        when 1
+          return EMPTY
+        end
+      end
+
+      VersionRange.new(
+        min: min_range.min,
+        include_min: min_range.include_min,
+        max: max_range.max,
+        include_max: max_range.include_max
+      )
+    end
+
+    # The span covered by two ranges
+    #
+    # If self and other are contiguous, this builds a union of the two ranges.
+    # (if they aren't you are probably calling the wrong method)
+    def span(other)
+      return self if other.empty?
+
+      min_range =
+        if !min
+          self
+        elsif !other.min
+          other
+        else
+          case min <=> other.min
+          when 0
+            include_min ? self : other
+          when -1
+            self
+          when 1
+            other
+          end
+        end
+
+      max_range =
+        if !max
+          self
+        elsif !other.max
+          other
+        else
+          case max <=> other.max
+          when 0
+            include_max ? self : other
+          when -1
+            other
+          when 1
+            self
+          end
+        end
+
+      VersionRange.new(
+        min: min_range.min,
+        include_min: min_range.include_min,
+        max: max_range.max,
+        include_max: max_range.include_max
+      )
+    end
+
+    def union(other)
+      return other.union(self) if other.is_a?(VersionUnion)
+
+      if contiguous_to?(other)
+        span(other)
+      else
+        VersionUnion.union([self, other])
+      end
+    end
+
+    def contiguous_to?(other)
+      return false if other.empty?
+      return true if any?
+
+      intersects?(other) || contiguous_below?(other) || contiguous_above?(other)
+    end
+
+    def contiguous_below?(other)
+      return false if !max || !other.min
+
+      max == other.min && (include_max || other.include_min)
+    end
+
+    def contiguous_above?(other)
+      other.contiguous_below?(self)
+    end
+
+    def allows_all?(other)
+      return true if other.empty?
+
+      if other.is_a?(VersionUnion)
+        return VersionUnion.new([self]).allows_all?(other)
+      end
+
+      return false if max && !other.max
+      return false if min && !other.min
+
+      if min
+        case min <=> other.min
+        when -1
+        when 0
+          return false if !include_min && other.include_min
+        when 1
+          return false
+        end
+      end
+
+      if max
+        case max <=> other.max
+        when -1
+          return false
+        when 0
+          return false if !include_max && other.include_max
+        when 1
+        end
+      end
+
+      true
+    end
+
+    def any?
+      !min && !max
+    end
+
+    def empty?
+      false
+    end
+
+    def to_s
+      @name ||= constraints.join(", ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def upper_invert
+      return self.class.empty unless max
+
+      VersionRange.new(min: max, include_min: !include_max)
+    end
+
+    def invert
+      return self.class.empty if any?
+
+      low = -> { VersionRange.new(max: min, include_max: !include_min) }
+      high = -> { VersionRange.new(min: max, include_min: !include_max) }
+
+      if !min
+        high.call
+      elsif !max
+        low.call
+      else
+        low.call.union(high.call)
+      end
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        min == other.min &&
+        max == other.max &&
+        include_min == other.include_min &&
+        include_max == other.include_max
+    end
+
+    private
+
+    def constraints
+      return ["any"] if any?
+      return ["= #{min}"] if min.to_s == max.to_s
+
+      c = []
+      c << "#{include_min ? ">=" : ">"} #{min}" if min
+      c << "#{include_max ? "<=" : "<"} #{max}" if max
+      c
+    end
+
+  end
+end

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

@@ -0,0 +1,236 @@
+require_relative 'partial_solution'
+require_relative 'term'
+require_relative 'incompatibility'
+require_relative 'solve_failure'
+require_relative 'strategy'
+
+module Bundler::PubGrub
+  class VersionSolver
+    attr_reader :logger
+    attr_reader :source
+    attr_reader :solution
+    attr_reader :strategy
+
+    def initialize(source:, root: Package.root, strategy: Strategy.new(source), logger: Bundler::PubGrub.logger)
+      @logger = logger
+
+      @source = source
+      @strategy = strategy
+
+      # { package => [incompatibility, ...]}
+      @incompatibilities = Hash.new do |h, k|
+        h[k] = []
+      end
+
+      @seen_incompatibilities = {}
+
+      @solution = PartialSolution.new
+
+      add_incompatibility Incompatibility.new([
+        Term.new(VersionConstraint.any(root), false)
+      ], cause: :root)
+
+      propagate(root)
+    end
+
+    def solved?
+      solution.unsatisfied.empty?
+    end
+
+    # Returns true if there is more work to be done, false otherwise
+    def work
+      unsatisfied_terms = solution.unsatisfied
+      if unsatisfied_terms.empty?
+        logger.info { "Solution found after #{solution.attempted_solutions} attempts:" }
+        solution.decisions.each do |package, version|
+          next if Package.root?(package)
+          logger.info { "* #{package} #{version}" }
+        end
+
+        return false
+      end
+
+      next_package = choose_package_version_from(unsatisfied_terms)
+      propagate(next_package)
+
+      true
+    end
+
+    def solve
+      while work; end
+
+      solution.decisions
+    end
+
+    alias_method :result, :solve
+
+    private
+
+    def propagate(initial_package)
+      changed = [initial_package]
+      while package = changed.shift
+        @incompatibilities[package].reverse_each do |incompatibility|
+          result = propagate_incompatibility(incompatibility)
+          if result == :conflict
+            root_cause = resolve_conflict(incompatibility)
+            changed.clear
+            changed << propagate_incompatibility(root_cause)
+          elsif result # should be a Package
+            changed << result
+          end
+        end
+        changed.uniq!
+      end
+    end
+
+    def propagate_incompatibility(incompatibility)
+      unsatisfied = nil
+      incompatibility.terms.each do |term|
+        relation = solution.relation(term)
+        if relation == :disjoint
+          return nil
+        elsif relation == :overlap
+          # If more than one term is inconclusive, we can't deduce anything
+          return nil if unsatisfied
+          unsatisfied = term
+        end
+      end
+
+      if !unsatisfied
+        return :conflict
+      end
+
+      logger.debug { "derived: #{unsatisfied.invert}" }
+
+      solution.derive(unsatisfied.invert, incompatibility)
+
+      unsatisfied.package
+    end
+
+    def choose_package_version_from(unsatisfied_terms)
+      remaining = unsatisfied_terms.map { |t| [t.package, t.constraint.range] }.to_h
+
+      package, version = strategy.next_package_and_version(remaining)
+
+      logger.debug { "attempting #{package} #{version}" }
+
+      if version.nil?
+        unsatisfied_term = unsatisfied_terms.find { |t| t.package == package }
+        add_incompatibility source.no_versions_incompatibility_for(package, unsatisfied_term)
+        return package
+      end
+
+      conflict = false
+
+      source.incompatibilities_for(package, version).each do |incompatibility|
+        if @seen_incompatibilities.include?(incompatibility)
+          logger.debug { "knew: #{incompatibility}" }
+          next
+        end
+        @seen_incompatibilities[incompatibility] = true
+
+        add_incompatibility incompatibility
+
+        conflict ||= incompatibility.terms.all? do |term|
+          term.package == package || solution.satisfies?(term)
+        end
+      end
+
+      unless conflict
+        logger.info { "selected #{package} #{version}" }
+
+        solution.decide(package, version)
+      else
+        logger.info { "conflict: #{conflict.inspect}" }
+      end
+
+      package
+    end
+
+    def resolve_conflict(incompatibility)
+      logger.info { "conflict: #{incompatibility}" }
+
+      new_incompatibility = nil
+
+      while !incompatibility.failure?
+        most_recent_term = nil
+        most_recent_satisfier = nil
+        difference = nil
+
+        previous_level = 1
+
+        incompatibility.terms.each do |term|
+          satisfier = solution.satisfier(term)
+
+          if most_recent_satisfier.nil?
+            most_recent_term = term
+            most_recent_satisfier = satisfier
+          elsif most_recent_satisfier.index < satisfier.index
+            previous_level = [previous_level, most_recent_satisfier.decision_level].max
+            most_recent_term = term
+            most_recent_satisfier = satisfier
+            difference = nil
+          else
+            previous_level = [previous_level, satisfier.decision_level].max
+          end
+
+          if most_recent_term == term
+            difference = most_recent_satisfier.term.difference(most_recent_term)
+            if difference.empty?
+              difference = nil
+            else
+              difference_satisfier = solution.satisfier(difference.inverse)
+              previous_level = [previous_level, difference_satisfier.decision_level].max
+            end
+          end
+        end
+
+        if previous_level < most_recent_satisfier.decision_level ||
+            most_recent_satisfier.decision?
+
+          logger.info { "backtracking to #{previous_level}" }
+          solution.backtrack(previous_level)
+
+          if new_incompatibility
+            add_incompatibility(new_incompatibility)
+          end
+
+          return incompatibility
+        end
+
+        new_terms = []
+        new_terms += incompatibility.terms - [most_recent_term]
+        new_terms += most_recent_satisfier.cause.terms.reject { |term|
+          term.package == most_recent_satisfier.term.package
+        }
+        if difference
+          new_terms << difference.invert
+        end
+
+        new_incompatibility = Incompatibility.new(new_terms, cause: Incompatibility::ConflictCause.new(incompatibility, most_recent_satisfier.cause))
+
+        if incompatibility.to_s == new_incompatibility.to_s
+          logger.info { "!! failed to resolve conflicts, this shouldn't have happened" }
+          break
+        end
+
+        incompatibility = new_incompatibility
+
+        partially = difference ? " partially" : ""
+        logger.info { "! #{most_recent_term} is#{partially} satisfied by #{most_recent_satisfier.term}" }
+        logger.info { "! which is caused by #{most_recent_satisfier.cause}" }
+        logger.info { "! thus #{incompatibility}" }
+      end
+
+      raise SolveFailure.new(incompatibility)
+    end
+
+    def add_incompatibility(incompatibility)
+      logger.debug { "fact: #{incompatibility}" }
+      incompatibility.terms.each do |term|
+        package = term.package
+        @incompatibilities[package] << incompatibility
+      end
+    end
+  end
+end