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

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

@@ -1,423 +0,0 @@
-# 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

@@ -1,236 +0,0 @@
-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