bundler 2.2.27 → 2.2.31

data/lib/bundler/vendor/molinillo/LICENSE

@@ -0,0 +1,9 @@
+This project is licensed under the MIT license.
+
+Copyright (c) 2014 Samuel E. Giddins segiddins@segiddins.me
+
+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/lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'tsort'
+require_relative '../../../../vendored_tsort'
 
 require_relative 'dependency_graph/log'
 require_relative 'dependency_graph/vertex'
@@ -17,7 +17,7 @@ module Bundler::Molinillo
       vertices.values.each { |v| yield v }
     end
 
-    include TSort
+    include Bundler::TSort
 
     # @!visibility private
     alias tsort_each_node each

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

@@ -0,0 +1,82 @@
+= net-http-persistent
+
+home :: https://github.com/drbrain/net-http-persistent
+rdoc :: http://docs.seattlerb.org/net-http-persistent
+
+== DESCRIPTION:
+
+Manages persistent connections using Net::HTTP including a thread pool for
+connecting to multiple hosts.
+
+Using persistent HTTP connections can dramatically increase the speed of HTTP.
+Creating a new HTTP connection for every request involves an extra TCP
+round-trip and causes TCP congestion avoidance negotiation to start over.
+
+Net::HTTP supports persistent connections with some API methods but does not
+make setting up a single persistent connection or managing multiple
+connections easy.  Net::HTTP::Persistent wraps Net::HTTP and allows you to
+focus on how to make HTTP requests.
+
+== FEATURES/PROBLEMS:
+
+* Supports TLS with secure defaults
+* Thread-safe
+* Pure ruby
+
+== SYNOPSIS
+
+The following example will make two requests to the same server.  The
+connection is kept alive between requests:
+
+    require 'net/http/persistent'
+
+    uri = URI 'http://example.com/awesome/web/service'
+
+    http = Net::HTTP::Persistent.new name: 'my_app_name'
+
+    # perform a GET
+    response = http.request uri
+
+    # create a POST
+    post_uri = uri + 'create'
+    post = Net::HTTP::Post.new post_uri.path
+    post.set_form_data 'some' => 'cool data'
+
+    # perform the POST, the URI is always required
+    response = http.request post_uri, post
+
+    # if you are done making http requests, or won't make requests for several
+    # minutes
+    http.shutdown
+
+Please see the documentation on Net::HTTP::Persistent for more information,
+including SSL connection verification, header handling and tunable options.
+
+== INSTALL:
+
+  gem install net-http-persistent
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) Eric Hodel, Aaron Patterson
+
+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/lib/bundler/vendor/thor/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
+
+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/lib/bundler/vendor/tsort/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/lib/bundler/vendor/tsort/lib/tsort.rb

@@ -0,0 +1,453 @@
+# frozen_string_literal: true
+
+#--
+# tsort.rb - provides a module for topological sorting and strongly connected components.
+#++
+#
+
+#
+# TSort implements topological sorting using Tarjan's algorithm for
+# strongly connected components.
+#
+# TSort is designed to be able to be used with any object which can be
+# interpreted as a directed graph.
+#
+# TSort requires two methods to interpret an object as a graph,
+# tsort_each_node and tsort_each_child.
+#
+# * tsort_each_node is used to iterate for all nodes over a graph.
+# * tsort_each_child is used to iterate for child nodes of a given node.
+#
+# The equality of nodes are defined by eql? and hash since
+# TSort uses Hash internally.
+#
+# == A Simple Example
+#
+# The following example demonstrates how to mix the TSort module into an
+# existing class (in this case, Hash). Here, we're treating each key in
+# the hash as a node in the graph, and so we simply alias the required
+# #tsort_each_node method to Hash's #each_key method. For each key in the
+# hash, the associated value is an array of the node's child nodes. This
+# choice in turn leads to our implementation of the required #tsort_each_child
+# method, which fetches the array of child nodes and then iterates over that
+# array using the user-supplied block.
+#
+#   require 'tsort'
+#
+#   class Hash
+#     include TSort
+#     alias tsort_each_node each_key
+#     def tsort_each_child(node, &block)
+#       fetch(node).each(&block)
+#     end
+#   end
+#
+#   {1=>[2, 3], 2=>[3], 3=>[], 4=>[]}.tsort
+#   #=> [3, 2, 1, 4]
+#
+#   {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}.strongly_connected_components
+#   #=> [[4], [2, 3], [1]]
+#
+# == A More Realistic Example
+#
+# A very simple `make' like tool can be implemented as follows:
+#
+#   require 'tsort'
+#
+#   class Make
+#     def initialize
+#       @dep = {}
+#       @dep.default = []
+#     end
+#
+#     def rule(outputs, inputs=[], &block)
+#       triple = [outputs, inputs, block]
+#       outputs.each {|f| @dep[f] = [triple]}
+#       @dep[triple] = inputs
+#     end
+#
+#     def build(target)
+#       each_strongly_connected_component_from(target) {|ns|
+#         if ns.length != 1
+#           fs = ns.delete_if {|n| Array === n}
+#           raise TSort::Cyclic.new("cyclic dependencies: #{fs.join ', '}")
+#         end
+#         n = ns.first
+#         if Array === n
+#           outputs, inputs, block = n
+#           inputs_time = inputs.map {|f| File.mtime f}.max
+#           begin
+#             outputs_time = outputs.map {|f| File.mtime f}.min
+#           rescue Errno::ENOENT
+#             outputs_time = nil
+#           end
+#           if outputs_time == nil ||
+#              inputs_time != nil && outputs_time <= inputs_time
+#             sleep 1 if inputs_time != nil && inputs_time.to_i == Time.now.to_i
+#             block.call
+#           end
+#         end
+#       }
+#     end
+#
+#     def tsort_each_child(node, &block)
+#       @dep[node].each(&block)
+#     end
+#     include TSort
+#   end
+#
+#   def command(arg)
+#     print arg, "\n"
+#     system arg
+#   end
+#
+#   m = Make.new
+#   m.rule(%w[t1]) { command 'date > t1' }
+#   m.rule(%w[t2]) { command 'date > t2' }
+#   m.rule(%w[t3]) { command 'date > t3' }
+#   m.rule(%w[t4], %w[t1 t3]) { command 'cat t1 t3 > t4' }
+#   m.rule(%w[t5], %w[t4 t2]) { command 'cat t4 t2 > t5' }
+#   m.build('t5')
+#
+# == Bugs
+#
+# * 'tsort.rb' is wrong name because this library uses
+#   Tarjan's algorithm for strongly connected components.
+#   Although 'strongly_connected_components.rb' is correct but too long.
+#
+# == References
+#
+# R. E. Tarjan, "Depth First Search and Linear Graph Algorithms",
+# <em>SIAM Journal on Computing</em>, Vol. 1, No. 2, pp. 146-160, June 1972.
+#
+module Bundler
+  module TSort
+    class Cyclic < StandardError
+    end
+
+    # Returns a topologically sorted array of nodes.
+    # The array is sorted from children to parents, i.e.
+    # the first element has no child and the last node has no parent.
+    #
+    # If there is a cycle, TSort::Cyclic is raised.
+    #
+    #   class G
+    #     include TSort
+    #     def initialize(g)
+    #       @g = g
+    #     end
+    #     def tsort_each_child(n, &b) @g[n].each(&b) end
+    #     def tsort_each_node(&b) @g.each_key(&b) end
+    #   end
+    #
+    #   graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
+    #   p graph.tsort #=> [4, 2, 3, 1]
+    #
+    #   graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
+    #   p graph.tsort # raises TSort::Cyclic
+    #
+    def tsort
+      each_node = method(:tsort_each_node)
+      each_child = method(:tsort_each_child)
+      TSort.tsort(each_node, each_child)
+    end
+
+    # Returns a topologically sorted array of nodes.
+    # The array is sorted from children to parents, i.e.
+    # the first element has no child and the last node has no parent.
+    #
+    # The graph is represented by _each_node_ and _each_child_.
+    # _each_node_ should have +call+ method which yields for each node in the graph.
+    # _each_child_ should have +call+ method which takes a node argument and yields for each child node.
+    #
+    # If there is a cycle, TSort::Cyclic is raised.
+    #
+    #   g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   p TSort.tsort(each_node, each_child) #=> [4, 2, 3, 1]
+    #
+    #   g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   p TSort.tsort(each_node, each_child) # raises TSort::Cyclic
+    #
+    def TSort.tsort(each_node, each_child)
+      TSort.tsort_each(each_node, each_child).to_a
+    end
+
+    # The iterator version of the #tsort method.
+    # <tt><em>obj</em>.tsort_each</tt> is similar to <tt><em>obj</em>.tsort.each</tt>, but
+    # modification of _obj_ during the iteration may lead to unexpected results.
+    #
+    # #tsort_each returns +nil+.
+    # If there is a cycle, TSort::Cyclic is raised.
+    #
+    #   class G
+    #     include TSort
+    #     def initialize(g)
+    #       @g = g
+    #     end
+    #     def tsort_each_child(n, &b) @g[n].each(&b) end
+    #     def tsort_each_node(&b) @g.each_key(&b) end
+    #   end
+    #
+    #   graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
+    #   graph.tsort_each {|n| p n }
+    #   #=> 4
+    #   #   2
+    #   #   3
+    #   #   1
+    #
+    def tsort_each(&block) # :yields: node
+      each_node = method(:tsort_each_node)
+      each_child = method(:tsort_each_child)
+      TSort.tsort_each(each_node, each_child, &block)
+    end
+
+    # The iterator version of the TSort.tsort method.
+    #
+    # The graph is represented by _each_node_ and _each_child_.
+    # _each_node_ should have +call+ method which yields for each node in the graph.
+    # _each_child_ should have +call+ method which takes a node argument and yields for each child node.
+    #
+    #   g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   TSort.tsort_each(each_node, each_child) {|n| p n }
+    #   #=> 4
+    #   #   2
+    #   #   3
+    #   #   1
+    #
+    def TSort.tsort_each(each_node, each_child) # :yields: node
+      return to_enum(__method__, each_node, each_child) unless block_given?
+
+      TSort.each_strongly_connected_component(each_node, each_child) {|component|
+        if component.size == 1
+          yield component.first
+        else
+          raise Cyclic.new("topological sort failed: #{component.inspect}")
+        end
+      }
+    end
+
+    # Returns strongly connected components as an array of arrays of nodes.
+    # The array is sorted from children to parents.
+    # Each elements of the array represents a strongly connected component.
+    #
+    #   class G
+    #     include TSort
+    #     def initialize(g)
+    #       @g = g
+    #     end
+    #     def tsort_each_child(n, &b) @g[n].each(&b) end
+    #     def tsort_each_node(&b) @g.each_key(&b) end
+    #   end
+    #
+    #   graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
+    #   p graph.strongly_connected_components #=> [[4], [2], [3], [1]]
+    #
+    #   graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
+    #   p graph.strongly_connected_components #=> [[4], [2, 3], [1]]
+    #
+    def strongly_connected_components
+      each_node = method(:tsort_each_node)
+      each_child = method(:tsort_each_child)
+      TSort.strongly_connected_components(each_node, each_child)
+    end
+
+    # Returns strongly connected components as an array of arrays of nodes.
+    # The array is sorted from children to parents.
+    # Each elements of the array represents a strongly connected component.
+    #
+    # The graph is represented by _each_node_ and _each_child_.
+    # _each_node_ should have +call+ method which yields for each node in the graph.
+    # _each_child_ should have +call+ method which takes a node argument and yields for each child node.
+    #
+    #   g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   p TSort.strongly_connected_components(each_node, each_child)
+    #   #=> [[4], [2], [3], [1]]
+    #
+    #   g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   p TSort.strongly_connected_components(each_node, each_child)
+    #   #=> [[4], [2, 3], [1]]
+    #
+    def TSort.strongly_connected_components(each_node, each_child)
+      TSort.each_strongly_connected_component(each_node, each_child).to_a
+    end
+
+    # The iterator version of the #strongly_connected_components method.
+    # <tt><em>obj</em>.each_strongly_connected_component</tt> is similar to
+    # <tt><em>obj</em>.strongly_connected_components.each</tt>, but
+    # modification of _obj_ during the iteration may lead to unexpected results.
+    #
+    # #each_strongly_connected_component returns +nil+.
+    #
+    #   class G
+    #     include TSort
+    #     def initialize(g)
+    #       @g = g
+    #     end
+    #     def tsort_each_child(n, &b) @g[n].each(&b) end
+    #     def tsort_each_node(&b) @g.each_key(&b) end
+    #   end
+    #
+    #   graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
+    #   graph.each_strongly_connected_component {|scc| p scc }
+    #   #=> [4]
+    #   #   [2]
+    #   #   [3]
+    #   #   [1]
+    #
+    #   graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
+    #   graph.each_strongly_connected_component {|scc| p scc }
+    #   #=> [4]
+    #   #   [2, 3]
+    #   #   [1]
+    #
+    def each_strongly_connected_component(&block) # :yields: nodes
+      each_node = method(:tsort_each_node)
+      each_child = method(:tsort_each_child)
+      TSort.each_strongly_connected_component(each_node, each_child, &block)
+    end
+
+    # The iterator version of the TSort.strongly_connected_components method.
+    #
+    # The graph is represented by _each_node_ and _each_child_.
+    # _each_node_ should have +call+ method which yields for each node in the graph.
+    # _each_child_ should have +call+ method which takes a node argument and yields for each child node.
+    #
+    #   g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc }
+    #   #=> [4]
+    #   #   [2]
+    #   #   [3]
+    #   #   [1]
+    #
+    #   g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
+    #   each_node = lambda {|&b| g.each_key(&b) }
+    #   each_child = lambda {|n, &b| g[n].each(&b) }
+    #   TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc }
+    #   #=> [4]
+    #   #   [2, 3]
+    #   #   [1]
+    #
+    def TSort.each_strongly_connected_component(each_node, each_child) # :yields: nodes
+      return to_enum(__method__, each_node, each_child) unless block_given?
+
+      id_map = {}
+      stack = []
+      each_node.call {|node|
+        unless id_map.include? node
+          TSort.each_strongly_connected_component_from(node, each_child, id_map, stack) {|c|
+            yield c
+          }
+        end
+      }
+      nil
+    end
+
+    # Iterates over strongly connected component in the subgraph reachable from
+    # _node_.
+    #
+    # Return value is unspecified.
+    #
+    # #each_strongly_connected_component_from doesn't call #tsort_each_node.
+    #
+    #   class G
+    #     include TSort
+    #     def initialize(g)
+    #       @g = g
+    #     end
+    #     def tsort_each_child(n, &b) @g[n].each(&b) end
+    #     def tsort_each_node(&b) @g.each_key(&b) end
+    #   end
+    #
+    #   graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
+    #   graph.each_strongly_connected_component_from(2) {|scc| p scc }
+    #   #=> [4]
+    #   #   [2]
+    #
+    #   graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
+    #   graph.each_strongly_connected_component_from(2) {|scc| p scc }
+    #   #=> [4]
+    #   #   [2, 3]
+    #
+    def each_strongly_connected_component_from(node, id_map={}, stack=[], &block) # :yields: nodes
+      TSort.each_strongly_connected_component_from(node, method(:tsort_each_child), id_map, stack, &block)
+    end
+
+    # Iterates over strongly connected components in a graph.
+    # The graph is represented by _node_ and _each_child_.
+    #
+    # _node_ is the first node.
+    # _each_child_ should have +call+ method which takes a node argument
+    # and yields for each child node.
+    #
+    # Return value is unspecified.
+    #
+    # #TSort.each_strongly_connected_component_from is a class method and
+    # it doesn't need a class to represent a graph which includes TSort.
+    #
+    #   graph = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
+    #   each_child = lambda {|n, &b| graph[n].each(&b) }
+    #   TSort.each_strongly_connected_component_from(1, each_child) {|scc|
+    #     p scc
+    #   }
+    #   #=> [4]
+    #   #   [2, 3]
+    #   #   [1]
+    #
+    def TSort.each_strongly_connected_component_from(node, each_child, id_map={}, stack=[]) # :yields: nodes
+      return to_enum(__method__, node, each_child, id_map, stack) unless block_given?
+
+      minimum_id = node_id = id_map[node] = id_map.size
+      stack_length = stack.length
+      stack << node
+
+      each_child.call(node) {|child|
+        if id_map.include? child
+          child_id = id_map[child]
+          minimum_id = child_id if child_id && child_id < minimum_id
+        else
+          sub_minimum_id =
+            TSort.each_strongly_connected_component_from(child, each_child, id_map, stack) {|c|
+              yield c
+            }
+          minimum_id = sub_minimum_id if sub_minimum_id < minimum_id
+        end
+      }
+
+      if node_id == minimum_id
+        component = stack.slice!(stack_length .. -1)
+        component.each {|n| id_map[n] = nil}
+        yield component
+      end
+
+      minimum_id
+    end
+
+    # Should be implemented by a extended class.
+    #
+    # #tsort_each_node is used to iterate for all nodes over a graph.
+    #
+    def tsort_each_node # :yields: node
+      raise NotImplementedError.new
+    end
+
+    # Should be implemented by a extended class.
+    #
+    # #tsort_each_child is used to iterate for child nodes of _node_.
+    #
+    def tsort_each_child(node) # :yields: child
+      raise NotImplementedError.new
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/lib/bundler/vendored_tsort.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Bundler; end
+require_relative "vendor/tsort/lib/tsort"

data/lib/bundler/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: false
 
 module Bundler
-  VERSION = "2.2.27".freeze
+  VERSION = "2.2.31".freeze
 
   def self.bundler_major_version
     @bundler_major_version ||= VERSION.split(".").first.to_i

data/lib/bundler/worker.rb

@@ -21,8 +21,8 @@ module Bundler
     # @param func [Proc] job to run in inside the worker pool
     def initialize(size, name, func)
       @name = name
-      @request_queue = Queue.new
-      @response_queue = Queue.new
+      @request_queue = Thread::Queue.new
+      @response_queue = Thread::Queue.new
       @func = func
       @size = size
       @threads = nil

data/lib/bundler.rb

@@ -37,12 +37,13 @@ module Bundler
   environment_preserver = EnvironmentPreserver.from_env
   ORIGINAL_ENV = environment_preserver.restore
   environment_preserver.replace_with_backup
-  SUDO_MUTEX = Mutex.new
+  SUDO_MUTEX = Thread::Mutex.new
 
   autoload :Definition,             File.expand_path("bundler/definition", __dir__)
   autoload :Dependency,             File.expand_path("bundler/dependency", __dir__)
   autoload :DepProxy,               File.expand_path("bundler/dep_proxy", __dir__)
   autoload :Deprecate,              File.expand_path("bundler/deprecate", __dir__)
+  autoload :Digest,                 File.expand_path("bundler/digest", __dir__)
   autoload :Dsl,                    File.expand_path("bundler/dsl", __dir__)
   autoload :EndpointSpecification,  File.expand_path("bundler/endpoint_specification", __dir__)
   autoload :Env,                    File.expand_path("bundler/env", __dir__)