FM / ruby-2.7.8

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8

Name	Size	Mode	Actions
benchmark/	-	0755	rm
bigdecimal/	-	0755	rm
bundler/	-	0755	rm
cgi/	-	0755	rm
csv/	-	0755	rm
delegate/	-	0755	rm
did_you_mean/	-	0755	rm
digest/	-	0755	rm
drb/	-	0755	rm
fiddle/	-	0755	rm
forwardable/	-	0755	rm
getoptlong/	-	0755	rm
io/	-	0755	rm
irb/	-	0755	rm
json/	-	0755	rm
logger/	-	0755	rm
matrix/	-	0755	rm
net/	-	0755	rm
observer/	-	0755	rm
open3/	-	0755	rm
openssl/	-	0755	rm
optparse/	-	0755	rm
ostruct/	-	0755	rm
pstore/	-	0755	rm
psych/	-	0755	rm
racc/	-	0755	rm
rdoc/	-	0755	rm
reline/	-	0755	rm
rexml/	-	0755	rm
rinda/	-	0755	rm
ripper/	-	0755	rm
rss/	-	0755	rm
rubygems/	-	0755	rm
singleton/	-	0755	rm
syslog/	-	0755	rm
timeout/	-	0755	rm
tracer/	-	0755	rm
unicode_normalize/	-	0755	rm
uri/	-	0755	rm
webrick/	-	0755	rm
yaml/	-	0755	rm
abbrev.rb	3529	0644	edit dl rm
base64.rb	3379	0644	edit dl rm
benchmark.rb	18453	0644	edit dl rm
bigdecimal.rb	24	0644	edit dl rm
bundler.rb	23718	0644	edit dl rm
cgi.rb	10037	0644	edit dl rm
coverage.rb	368	0644	edit dl rm
csv.rb	55643	0644	edit dl rm
date.rb	1066	0644	edit dl rm
debug.rb	30624	0644	edit dl rm
delegate.rb	11343	0644	edit dl rm
did_you_mean.rb	3806	0644	edit dl rm
digest.rb	2894	0644	edit dl rm
drb.rb	50	0644	edit dl rm
English.rb	6258	0644	edit dl rm
erb.rb	29504	0644	edit dl rm
expect.rb	2217	0644	edit dl rm
fiddle.rb	1722	0644	edit dl rm
fileutils.rb	49271	0644	edit dl rm
find.rb	2526	0644	edit dl rm
forwardable.rb	9130	0644	edit dl rm
getoptlong.rb	15787	0644	edit dl rm
ipaddr.rb	19989	0644	edit dl rm
irb.rb	27603	0644	edit dl rm
json.rb	1809	0644	edit dl rm
kconv.rb	5861	0644	edit dl rm
logger.rb	16792	0644	edit dl rm
matrix.rb	61703	0644	edit dl rm
mkmf.rb	88539	0644	edit dl rm
monitor.rb	6920	0644	edit dl rm
mutex_m.rb	2214	0644	edit dl rm
observer.rb	5971	0644	edit dl rm
open-uri.rb	26088	0644	edit dl rm
open3.rb	22336	0644	edit dl rm
openssl.rb	469	0644	edit dl rm
optionparser.rb	59	0644	edit dl rm
optparse.rb	60919	0644	edit dl rm
ostruct.rb	10785	0644	edit dl rm
pathname.rb	16558	0644	edit dl rm
pp.rb	15978	0644	edit dl rm
prettyprint.rb	16276	0644	edit dl rm
prime.rb	12670	0644	edit dl rm
pstore.rb	15063	0644	edit dl rm
psych.rb	21718	0644	edit dl rm
racc.rb	137	0644	edit dl rm
rdoc.rb	5000	0644	edit dl rm
readline.rb	113	0644	edit dl rm
reline.rb	13253	0644	edit dl rm
resolv-replace.rb	1805	0644	edit dl rm
resolv.rb	79564	0644	edit dl rm
ripper.rb	2494	0644	edit dl rm
rss.rb	2963	0644	edit dl rm
rubygems.rb	39108	0644	edit dl rm
securerandom.rb	9528	0644	edit dl rm
set.rb	24622	0644	edit dl rm
shellwords.rb	6816	0644	edit dl rm
singleton.rb	4158	0644	edit dl rm
socket.rb	44702	0644	edit dl rm
tempfile.rb	11213	0644	edit dl rm
time.rb	24590	0644	edit dl rm
timeout.rb	4075	0644	edit dl rm
tmpdir.rb	4142	0644	edit dl rm
tracer.rb	6640	0644	edit dl rm
tsort.rb	14642	0644	edit dl rm
un.rb	10202	0644	edit dl rm
uri.rb	3039	0644	edit dl rm
weakref.rb	1473	0644	edit dl rm
webrick.rb	6890	0644	edit dl rm
yaml.rb	1845	0644	edit dl rm

Edit: /opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/tsort.rb (14642B)

# 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",
# SIAM Journal on Computing, Vol. 1, No. 2, pp. 146-160, June 1972.
#

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>obj.tsort_each</tt> is similar to <tt>obj.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>obj.each_strongly_connected_component</tt> is similar to
 # <tt>obj.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

cmd: