1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[rubygems/rubygems] Bump Molinillo and tsort

Browse Source 
And configure tsort to be vendored as a dependency of Molinillo.

https://github.com/rubygems/rubygems/commit/8ec749f891
This commit is contained in:
David Rodríguez 2022-12-10 22:05:03 +01:00 committed by git
parent 9477ec732b
commit d82328ffc8
4 changed files with 345 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/rubygems/resolver/molinillo/lib/molinillo/dependency_graph.rb
View File

@ -32,7 +32,7 @@ module Gem::Resolver::Molinillo
# all belong to the same graph. # all belong to the same graph.
# @return [Array<Vertex>] The sorted vertices. # @return [Array<Vertex>] The sorted vertices.
def self.tsort(vertices) def self.tsort(vertices)
TSort.tsort( Gem::TSort.tsort(
lambda { |b| vertices.each(&b) }, lambda { |b| vertices.each(&b) },
lambda { |v, &b| (v.successors & vertices).each(&b) } lambda { |v, &b| (v.successors & vertices).each(&b) }
) )

60
lib/rubygems/resolver/molinillo/lib/molinillo/errors.rb
View File

@ -107,36 +107,42 @@ module Gem::Resolver::Molinillo
end end
end end
conflicts.sort.reduce(''.dup) do |o, (name, conflict)| full_message_for_conflict = opts.delete(:full_message_for_conflict) do
o << "\n" << incompatible_version_message_for_conflict.call(name, conflict) << "\n" proc do |name, conflict|
if conflict.locked_requirement o = "\n".dup << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
o << %( In snapshot (#{name_for_locking_dependency_source}):\n) if conflict.locked_requirement
o << %( #{printable_requirement.call(conflict.locked_requirement)}\n) o << %( In snapshot (#{name_for_locking_dependency_source}):\n)
o << %(\n) o << %( #{printable_requirement.call(conflict.locked_requirement)}\n)
end o << %(\n)
o << %( In #{name_for_explicit_dependency_source}:\n)
trees = reduce_trees.call(conflict.requirement_trees)
o << trees.map do |tree|
t = ''.dup
depth = 2
tree.each do |req|
t << ' ' * depth << printable_requirement.call(req)
unless tree.last == req
if spec = conflict.activated_by_name[name_for(req)]
t << %( was resolved to #{version_for_spec.call(spec)}, which)
end
t << %( depends on)
end
t << %(\n)
depth += 1
end end
t o << %( In #{name_for_explicit_dependency_source}:\n)
end.join("\n") trees = reduce_trees.call(conflict.requirement_trees)
additional_message_for_conflict.call(o, name, conflict) o << trees.map do |tree|
t = ''.dup
depth = 2
tree.each do |req|
t << ' ' * depth << printable_requirement.call(req)
unless tree.last == req
if spec = conflict.activated_by_name[name_for(req)]
t << %( was resolved to #{version_for_spec.call(spec)}, which)
end
t << %( depends on)
end
t << %(\n)
depth += 1
end
t
end.join("\n")
o additional_message_for_conflict.call(o, name, conflict)
o
end
end
conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
o << full_message_for_conflict.call(name, conflict)
end.strip end.strip
end end
end end

2
lib/rubygems/resolver/molinillo/lib/molinillo/gem_metadata.rb
View File

@ -2,5 +2,5 @@
module Gem::Resolver::Molinillo module Gem::Resolver::Molinillo
# The version of Gem::Resolver::Molinillo. # The version of Gem::Resolver::Molinillo.
VERSION = '0.7.0'.freeze VERSION = '0.8.0'.freeze
end end

622
lib/rubygems/tsort/lib/tsort.rb
View File

@ -121,334 +121,332 @@
# <em>SIAM Journal on Computing</em>, Vol. 1, No. 2, pp. 146-160, June 1972. # <em>SIAM Journal on Computing</em>, Vol. 1, No. 2, pp. 146-160, June 1972.
# #
module Gem module Gem::TSort
module TSort class Cyclic < StandardError
class Cyclic < StandardError end
end
# Returns a topologically sorted array of nodes. # Returns a topologically sorted array of nodes.
# The array is sorted from children to parents, i.e. # The array is sorted from children to parents, i.e.
# the first element has no child and the last node has no parent. # the first element has no child and the last node has no parent.
# #
# If there is a cycle, Gem::TSort::Cyclic is raised. # If there is a cycle, Gem::TSort::Cyclic is raised.
# #
# class G # class G
# include Gem::TSort # include Gem::TSort
# def initialize(g) # def initialize(g)
# @g = g # @g = g
# end # end
# def tsort_each_child(n, &b) @g[n].each(&b) end # def tsort_each_child(n, &b) @g[n].each(&b) end
# def tsort_each_node(&b) @g.each_key(&b) end # def tsort_each_node(&b) @g.each_key(&b) end
# end # end
# #
# graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}) # graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
# p graph.tsort #=> [4, 2, 3, 1] # p graph.tsort #=> [4, 2, 3, 1]
# #
# graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}) # graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
# p graph.tsort # raises Gem::TSort::Cyclic # p graph.tsort # raises Gem::TSort::Cyclic
# #
def tsort def tsort
each_node = method(:tsort_each_node) each_node = method(:tsort_each_node)
each_child = method(:tsort_each_child) each_child = method(:tsort_each_child)
Gem::TSort.tsort(each_node, each_child) Gem::TSort.tsort(each_node, each_child)
end end
# Returns a topologically sorted array of nodes. # Returns a topologically sorted array of nodes.
# The array is sorted from children to parents, i.e. # The array is sorted from children to parents, i.e.
# the first element has no child and the last node has no parent. # the first element has no child and the last node has no parent.
# #
# The graph is represented by _each_node_ and _each_child_. # 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_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. # _each_child_ should have +call+ method which takes a node argument and yields for each child node.
# #
# If there is a cycle, Gem::TSort::Cyclic is raised. # If there is a cycle, Gem::TSort::Cyclic is raised.
# #
# g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]} # g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# p Gem::TSort.tsort(each_node, each_child) #=> [4, 2, 3, 1] # p Gem::TSort.tsort(each_node, each_child) #=> [4, 2, 3, 1]
# #
# g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} # g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# p Gem::TSort.tsort(each_node, each_child) # raises Gem::TSort::Cyclic # p Gem::TSort.tsort(each_node, each_child) # raises Gem::TSort::Cyclic
# #
def TSort.tsort(each_node, each_child) def self.tsort(each_node, each_child)
Gem::TSort.tsort_each(each_node, each_child).to_a tsort_each(each_node, each_child).to_a
end end
# The iterator version of the #tsort method. # 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 # <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. # modification of _obj_ during the iteration may lead to unexpected results.
# #
# #tsort_each returns +nil+. # #tsort_each returns +nil+.
# If there is a cycle, Gem::TSort::Cyclic is raised. # If there is a cycle, Gem::TSort::Cyclic is raised.
# #
# class G # class G
# include Gem::TSort # include Gem::TSort
# def initialize(g) # def initialize(g)
# @g = g # @g = g
# end # end
# def tsort_each_child(n, &b) @g[n].each(&b) end # def tsort_each_child(n, &b) @g[n].each(&b) end
# def tsort_each_node(&b) @g.each_key(&b) end # def tsort_each_node(&b) @g.each_key(&b) end
# end # end
# #
# graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}) # graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
# graph.tsort_each {|n| p n } # graph.tsort_each {|n| p n }
# #=> 4 # #=> 4
# # 2 # # 2
# # 3 # # 3
# # 1 # # 1
# #
def tsort_each(&block) # :yields: node def tsort_each(&block) # :yields: node
each_node = method(:tsort_each_node) each_node = method(:tsort_each_node)
each_child = method(:tsort_each_child) each_child = method(:tsort_each_child)
Gem::TSort.tsort_each(each_node, each_child, &block) Gem::TSort.tsort_each(each_node, each_child, &block)
end end
# The iterator version of the Gem::TSort.tsort method. # The iterator version of the Gem::TSort.tsort method.
# #
# The graph is represented by _each_node_ and _each_child_. # 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_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. # _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=>[]} # g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# Gem::TSort.tsort_each(each_node, each_child) {|n| p n } # Gem::TSort.tsort_each(each_node, each_child) {|n| p n }
# #=> 4 # #=> 4
# # 2 # # 2
# # 3 # # 3
# # 1 # # 1
# #
def TSort.tsort_each(each_node, each_child) # :yields: node def self.tsort_each(each_node, each_child) # :yields: node
return to_enum(__method__, each_node, each_child) unless block_given? return to_enum(__method__, each_node, each_child) unless block_given?
Gem::TSort.each_strongly_connected_component(each_node, each_child) {|component| each_strongly_connected_component(each_node, each_child) {|component|
if component.size == 1 if component.size == 1
yield component.first yield component.first
else else
raise Cyclic.new("topological sort failed: #{component.inspect}") raise Cyclic.new("topological sort failed: #{component.inspect}")
end end
} }
end end
# Returns strongly connected components as an array of arrays of nodes. # Returns strongly connected components as an array of arrays of nodes.
# The array is sorted from children to parents. # The array is sorted from children to parents.
# Each elements of the array represents a strongly connected component. # Each elements of the array represents a strongly connected component.
# #
# class G # class G
# include Gem::TSort # include Gem::TSort
# def initialize(g) # def initialize(g)
# @g = g # @g = g
# end # end
# def tsort_each_child(n, &b) @g[n].each(&b) end # def tsort_each_child(n, &b) @g[n].each(&b) end
# def tsort_each_node(&b) @g.each_key(&b) end # def tsort_each_node(&b) @g.each_key(&b) end
# end # end
# #
# graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}) # graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
# p graph.strongly_connected_components #=> [[4], [2], [3], [1]] # p graph.strongly_connected_components #=> [[4], [2], [3], [1]]
# #
# graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}) # graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
# p graph.strongly_connected_components #=> [[4], [2, 3], [1]] # p graph.strongly_connected_components #=> [[4], [2, 3], [1]]
# #
def strongly_connected_components def strongly_connected_components
each_node = method(:tsort_each_node) each_node = method(:tsort_each_node)
each_child = method(:tsort_each_child) each_child = method(:tsort_each_child)
Gem::TSort.strongly_connected_components(each_node, each_child) Gem::TSort.strongly_connected_components(each_node, each_child)
end end
# Returns strongly connected components as an array of arrays of nodes. # Returns strongly connected components as an array of arrays of nodes.
# The array is sorted from children to parents. # The array is sorted from children to parents.
# Each elements of the array represents a strongly connected component. # Each elements of the array represents a strongly connected component.
# #
# The graph is represented by _each_node_ and _each_child_. # 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_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. # _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=>[]} # g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# p Gem::TSort.strongly_connected_components(each_node, each_child) # p Gem::TSort.strongly_connected_components(each_node, each_child)
# #=> [[4], [2], [3], [1]] # #=> [[4], [2], [3], [1]]
# #
# g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} # g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# p Gem::TSort.strongly_connected_components(each_node, each_child) # p Gem::TSort.strongly_connected_components(each_node, each_child)
# #=> [[4], [2, 3], [1]] # #=> [[4], [2, 3], [1]]
# #
def TSort.strongly_connected_components(each_node, each_child) def self.strongly_connected_components(each_node, each_child)
Gem::TSort.each_strongly_connected_component(each_node, each_child).to_a each_strongly_connected_component(each_node, each_child).to_a
end end
# The iterator version of the #strongly_connected_components method. # 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>.each_strongly_connected_component</tt> is similar to
# <tt><em>obj</em>.strongly_connected_components.each</tt>, but # <tt><em>obj</em>.strongly_connected_components.each</tt>, but
# modification of _obj_ during the iteration may lead to unexpected results. # modification of _obj_ during the iteration may lead to unexpected results.
# #
# #each_strongly_connected_component returns +nil+. # #each_strongly_connected_component returns +nil+.
# #
# class G # class G
# include Gem::TSort # include Gem::TSort
# def initialize(g) # def initialize(g)
# @g = g # @g = g
# end # end
# def tsort_each_child(n, &b) @g[n].each(&b) end # def tsort_each_child(n, &b) @g[n].each(&b) end
# def tsort_each_node(&b) @g.each_key(&b) end # def tsort_each_node(&b) @g.each_key(&b) end
# end # end
# #
# graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}) # graph = G.new({1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]})
# graph.each_strongly_connected_component {|scc| p scc } # graph.each_strongly_connected_component {|scc| p scc }
# #=> [4] # #=> [4]
# # [2] # # [2]
# # [3] # # [3]
# # [1] # # [1]
# #
# graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}) # graph = G.new({1=>[2], 2=>[3, 4], 3=>[2], 4=>[]})
# graph.each_strongly_connected_component {|scc| p scc } # graph.each_strongly_connected_component {|scc| p scc }
# #=> [4] # #=> [4]
# # [2, 3] # # [2, 3]
# # [1] # # [1]
# #
def each_strongly_connected_component(&block) # :yields: nodes def each_strongly_connected_component(&block) # :yields: nodes
each_node = method(:tsort_each_node) each_node = method(:tsort_each_node)
each_child = method(:tsort_each_child) each_child = method(:tsort_each_child)
Gem::TSort.each_strongly_connected_component(each_node, each_child, &block) Gem::TSort.each_strongly_connected_component(each_node, each_child, &block)
end end
# The iterator version of the Gem::TSort.strongly_connected_components method. # The iterator version of the Gem::TSort.strongly_connected_components method.
# #
# The graph is represented by _each_node_ and _each_child_. # 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_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. # _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=>[]} # g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# Gem::TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc } # Gem::TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc }
# #=> [4] # #=> [4]
# # [2] # # [2]
# # [3] # # [3]
# # [1] # # [1]
# #
# g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} # g = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
# each_node = lambda {|&b| g.each_key(&b) } # each_node = lambda {|&b| g.each_key(&b) }
# each_child = lambda {|n, &b| g[n].each(&b) } # each_child = lambda {|n, &b| g[n].each(&b) }
# Gem::TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc } # Gem::TSort.each_strongly_connected_component(each_node, each_child) {|scc| p scc }
# #=> [4] # #=> [4]
# # [2, 3] # # [2, 3]
# # [1] # # [1]
# #
def TSort.each_strongly_connected_component(each_node, each_child) # :yields: nodes def self.each_strongly_connected_component(each_node, each_child) # :yields: nodes
return to_enum(__method__, each_node, each_child) unless block_given? return to_enum(__method__, each_node, each_child) unless block_given?
id_map = {} id_map = {}
stack = [] stack = []
each_node.call {|node| each_node.call {|node|
unless id_map.include? node unless id_map.include? node
Gem::TSort.each_strongly_connected_component_from(node, each_child, id_map, stack) {|c| 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 Gem::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
Gem::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.
#
# #Gem::TSort.each_strongly_connected_component_from is a class method and
# it doesn't need a class to represent a graph which includes Gem::TSort.
#
# graph = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
# each_child = lambda {|n, &b| graph[n].each(&b) }
# Gem::TSort.each_strongly_connected_component_from(1, each_child) {|scc|
# p scc
# }
# #=> [4]
# # [2, 3]
# # [1]
#
def self.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 =
each_strongly_connected_component_from(child, each_child, id_map, stack) {|c|
yield c yield c
} }
end minimum_id = sub_minimum_id if sub_minimum_id < minimum_id
}
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 Gem::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
Gem::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.
#
# #Gem::TSort.each_strongly_connected_component_from is a class method and
# it doesn't need a class to represent a graph which includes Gem::TSort.
#
# graph = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]}
# each_child = lambda {|n, &b| graph[n].each(&b) }
# Gem::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 =
Gem::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 end
}
minimum_id if node_id == minimum_id
component = stack.slice!(stack_length .. -1)
component.each {|n| id_map[n] = nil}
yield component
end end
# Should be implemented by a extended class. minimum_id
# end
# #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. # Should be implemented by a extended class.
# #
# #tsort_each_child is used to iterate for child nodes of _node_. # #tsort_each_node is used to iterate for all nodes over a graph.
# #
def tsort_each_child(node) # :yields: child def tsort_each_node # :yields: node
raise NotImplementedError.new raise NotImplementedError.new
end 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 end