rubygems-update 3.3.26 → 3.4.1

data/bundler/lib/bundler/vendor/net-http-persistent/README.rdoc

@@ -1,7 +1,7 @@
 = net-http-persistent
 
 home :: https://github.com/drbrain/net-http-persistent
-rdoc :: http://docs.seattlerb.org/net-http-persistent
+rdoc :: https://rdoc.info/gems/net-http-persistent
 
 == DESCRIPTION:
 

data/bundler/lib/bundler/vendor/net-http-persistent/lib/net/http/persistent.rb

@@ -174,7 +174,7 @@ class Bundler::Persistent::Net::HTTP::Persistent
   ##
   # The version of Bundler::Persistent::Net::HTTP::Persistent you are using
 
-  VERSION = '4.0.0'
+  VERSION = '4.0.1'
 
   ##
   # Error class for errors raised by Bundler::Persistent::Net::HTTP::Persistent.  Various

data/bundler/lib/bundler/vendor/pub_grub/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 John Hawthorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/assignment.rb

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

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/basic_package_source.rb

@@ -0,0 +1,189 @@
+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
+
+    # Override me (maybe)
+    #
+    # If not overridden, the order returned by all_versions_for will be used
+    #
+    # Returns: Array of versions in preferred order
+    def sort_versions_by_preferred(package, sorted_versions)
+      indexes = @version_indexes[package]
+      sorted_versions.sort_by { |version| indexes[version] }
+    end
+
+    def initialize
+      @root_package = Package.root
+      @root_version = Package.root_version
+
+      @cached_versions = Hash.new do |h,k|
+        if k == @root_package
+          h[k] = [@root_version]
+        else
+          h[k] = all_versions_for(k)
+        end
+      end
+      @sorted_versions = Hash.new { |h,k| h[k] = @cached_versions[k].sort }
+      @version_indexes = Hash.new { |h,k| h[k] = @cached_versions[k].each.with_index.to_h }
+
+      @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)
+      versions = range.select_versions(@sorted_versions[package])
+
+      # Conditional avoids (among other things) calling
+      # sort_versions_by_preferred with the root package
+      if versions.size > 1
+        sort_versions_by_preferred(package, versions)
+      else
+        versions
+      end
+    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: true)
+
+        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

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/failure_writer.rb

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

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/incompatibility.rb

@@ -0,0 +1,151 @@
+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
+
+    CircularDependency = 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::CircularDependency
+        "#{terms[0].to_s(allow_every: true)} depends on itself"
+      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?
+            "#{terms[0].to_s(allow_every: true)} is forbidden"
+          else
+            "#{terms[0].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

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/package.rb

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