graphr 0.2.0

data/LICENSE

@@ -0,0 +1,18 @@
+Graph-related Ruby classes written by Robert Feld in 2001.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+This license also applies to the included Stanford CoreNLP files.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Author: Robert Feldt, feldt@ce.chalmers.se. All rights reserved.

data/README.md

@@ -0,0 +1,46 @@
+##graphr
+
+###About
+
+Graph-related Ruby classes [written by Robert Feld](http://rockit.sourceforge.net/subprojects/graphr/) in 2001, but never released as a gem.
+
+* DirectedGraph - fairly extensive directed graph class.
+* DotGraphPrinter - output a graph in GraphViz's dot format and invoke dot.
+
+###Example Usage
+
+```ruby
+# Lets crank out a simple graph...
+require 'graph/graphviz_dot'
+
+# In this simple example we don't even have a "real" graph
+# just an Array with the links. The optional third element 
+# of a link is link information. The nodes in this graph are 
+# implicit in the links. If we had additional nodes that were
+# not linked we would supply them in an array as 2nd parameter.
+links = [[:start, 1, "*"], [1, 1, "a"], [1, 2, "~a"], [2, :stop, "*"]]
+dgp = DotGraphPrinter.new(links)
+
+# We specialize the printer to change the shape of nodes
+# based on their names.
+dgp.node_shaper = proc do |n|
+  ["start", "stop"].include?(n.to_s) ? "doublecircle" : "box"
+end
+
+# We can also set the attributes on individual nodes and edges.
+# These settings override the default shapers and labelers.
+dgp.set_node_attributes(2, :shape => "diamond")
+
+# Add URL link from node (this only work in some output formats?)
+# Note the extra quotes needed!
+dgp.set_node_attributes(2, :URL => '"node2.html"')
+
+# And now output to files
+dgp.write_to_file("g.png", "png")  # Generate png file
+dgp.orientation = "landscape"      # Dot problem with PS orientation
+dgp.write_to_file("g.ps")          # Generate postscript file
+```
+
+###License
+
+Copyright (c) 2001 Robert Feldt, feldt@ce.chalmers.se. All rights reserved. Distributed under GPL. See LICENSE.

data/RELEASE

@@ -0,0 +1,46 @@
+2012-07-23, LM
+  * Released as 0.2.0
+  * First version published as a gem.
+  
+2001-11-16, RF
+	* Released 0.1.9
+	* Added DirectedGraph#strongly_connected_components and
+	  DirectedGraph#num_vertices with tests, all written by Tanaka Akira.
+	  Thanks Tanaka-san! (Or is it Akira-san?)
+	* Released 0.1.8
+	* Added test that negative hash values are never used in
+	  node names. Dot can't handle them.
+	* Released 0.1.7
+	* Added "n" char in front of the node names so that they can
+	  be used in well-formed XML docs (nums not allowed in first char).
+	  Thanks to Tobias Reif for this one.
+	* Extended example in README to show how URL's can be added to nodes.
+	
+2001-11-01, RF
+	* Use hash value as node number in dot files instead of id value,
+	  since the latter is not the same for strings even though they
+	  are equal.
+	* Added node attributes in the same way as edge attributes.
+	
+2001-10-26, RF
+	* Released as 0.1.3.
+	* Redesign. Skipped DotGraph and DotGraphFormatter class and moved 
+	  everything to new class DotGRaphPrinter.
+	* Size does not have a default value so dot uses its default.
+	* Default value for orientation is "porttrait" which fits most
+	  image output formats (except postscript!).
+
+2001-10-26, RF
+	* Release 0.1.2
+	* Added DotGraphFormatter#set_edge_attributes
+	* Added unit tests for DotGraphFormatter
+	* Added accessors to DotGraphFormatter for orientation and size 
+	* Added this Changelog
+
+2001-10-23, RF
+	* Fixed minor bugs relating to file structure.
+	
+2001-10-23, Robert Feldt (RF)
+	* First version 0.1.0 released.
+	* Created from files in rockit. Extracted since people asked for
+	  support for GraphViz's dot.

data/lib/graph/Rakefile

@@ -0,0 +1,6 @@
+task :test do
+  $:.unshift './test'
+  require File.basename('test/test.rb')
+end
+
+task :default => :test

data/lib/graph/base_extensions.rb

@@ -0,0 +1,70 @@
+class Array
+  def equality_uniq
+    uniq_elements = []
+    self.each {|e| uniq_elements.push(e) unless uniq_elements.index(e)}
+    uniq_elements
+  end
+
+  def delete_at_indices(indices = [])
+    not_deleted = Array.new
+    self.each_with_index {|e,i| not_deleted.push(e) if !indices.include?(i)} 
+    not_deleted
+  end
+end
+
+class DefaultInitArray < Array
+  def initialize(*args, &initblock)
+    super(*args)
+    @initblock = initblock
+  end
+
+  def [](index)
+    super(index) || (self[index] = @initblock.call(index))
+  end
+end
+
+class ArrayOfArrays < DefaultInitArray
+  @@create_array = proc{|i| Array.new}
+  def initialize(*args)
+    super(*args, &@@create_array)
+  end
+end
+
+class ArrayOfHashes < DefaultInitArray
+  @@create_hash = proc{|i| Hash.new}
+  def initialize(*args)
+    super(*args, &@@create_hash)
+  end
+end
+
+# Hash which takes a block that is called to give a default value when a key
+# has the value nil in the hash.
+class DefaultInitHash < Hash
+  def initialize(*args, &initblock)
+    super(*args)
+    @initblock = initblock
+  end
+
+  def [](key)
+    super(key) || (self[key] = @initblock.call(key))
+  end
+end
+
+unless Object.constants.include?("TimesClass")
+  TimesClass = (RUBY_VERSION < "1.7") ? Time : Process
+end
+
+def time_and_puts(string, &block)
+  if $TIME_AND_PUTS_VERBOSE
+    print string; STDOUT.flush
+  end
+  starttime = [Time.new, TimesClass.times]
+  block.call
+  endtime = [Time.new, TimesClass.times] 
+  duration = endtime[0] - starttime[0]
+  begin
+    load = [((endtime[1].utime+endtime[1].stime)-(starttime[1].utime+starttime[1].stime))/duration*100.0, 100.0].min
+    puts " (%.2f s %.2f%%)" % [duration, load] if $TIME_AND_PUTS_VERBOSE
+  rescue FloatDomainError
+  end
+end

data/lib/graph/directed_graph.rb

@@ -0,0 +1,476 @@
+require 'graph/base_extensions'
+require 'graph/graphviz_dot'
+
+class HashOfHash < DefaultInitHash
+  def initialize(&initBlock)
+    super do
+      if initBlock
+	DefaultInitHash.new(&initBlock)
+      else
+	Hash.new
+      end
+    end
+  end
+end
+
+GraphLink = Struct.new("GraphLink", :from, :to, :info)
+class GraphLink
+  def inspect
+    info_str = info ? info.inspect + "-" : ""
+    "#{from.inspect}-#{info_str}>#{to.inspect}"
+  end
+end
+
+class GraphTraversalException < Exception
+  attr_reader :node, :links, :link_info
+  def initialize(node, links, linkInfo)
+    @node, @links, @link_info = node, links, linkInfo
+    super(message)
+  end
+
+  def message
+    "There is no link from #{@node.inspect} having info #{@link_info.inspect} (valid links are #{@links.inspect})"  
+  end
+  alias inspect message
+end
+
+class DirectedGraph
+  # This is a memory expensive variant that manages several additional
+  # information data structures to cut down on processing when the graph
+  # has been built.
+
+  attr_reader :links
+  
+  def initialize
+    @link_map = HashOfHash.new {Array.new} # [from][to] -> array of links
+    @links = Array.new # All links in one array
+    @is_root = Hash.new # true iff root node
+    @is_leaf = Hash.new # true iff leaf node
+  end
+
+  def nodes
+    @is_root.keys
+  end
+
+  def add_node(node)
+    unless include_node?(node)
+      @is_root[node] = @is_leaf[node] = true
+    end
+  end
+
+  def root?(node)
+    @is_root[node]
+  end
+
+  def leaf?(node)
+    @is_leaf[node]
+  end
+
+  def include_node?(node)
+    @is_root.has_key?(node)
+  end
+
+  def links_from_to(from, to)
+    @link_map[from][to]
+  end    
+
+  def links_from(node)
+    @link_map[node].map {|to, links| links}.flatten
+  end
+
+  def children(node)
+    @link_map[node].keys.select {|k| @link_map[node][k].length > 0}
+  end
+
+  # (Forced) add link will always add link even if there are already links 
+  # between the nodes.
+  def add_link(from, to, informationOnLink = nil)
+    add_link_nodes(from, to)
+    link = GraphLink.new(from, to, informationOnLink)
+    links_from_to(from, to).push link
+    add_to_links(link)
+    link
+  end
+
+  def add_link_nodes(from, to)
+    add_node(from)
+    add_node(to)
+    @is_leaf[from] = @is_root[to] = false
+  end
+
+  # Add link if not already linked
+  def link_nodes(from, to, info = nil)
+    links_from_to?(from, to) ? nil : add_link(from, to, info)
+  end
+
+  def links_from_to?(from, to)
+    not links_from_to(from, to).empty?
+  end
+  alias linked? links_from_to?
+  
+  def add_to_links(link)
+    @links.push link
+  end
+  private :add_to_links
+
+  def each_reachable_node_once_depth_first(node, inclusive = true, &block)
+    children(node).each do |c|
+      recurse_each_reachable_depth_first_visited(c, Hash.new, &block)
+    end
+    block.call(node) if inclusive
+  end
+  alias each_reachable_node each_reachable_node_once_depth_first
+
+  def recurse_each_reachable_depth_first_visited(node, visited, &block)    
+    visited[node] = true
+    children(node).each do |c|
+      unless visited[c]
+	recurse_each_reachable_depth_first_visited(c, visited, &block)
+      end
+    end
+    block.call(node)
+  end
+
+  def each_reachable_node_once_breadth_first(node, inclusive = true, &block)
+    block.call(node) if inclusive
+    children(node).each do |c|
+      recurse_each_reachable_breadth_first_visited(c, Hash.new, &block)
+    end
+  end
+  alias each_reachable_node each_reachable_node_once_depth_first
+
+  def recurse_each_reachable_breadth_first_visited(node, visited, &block)    
+    visited[node] = true
+    block.call(node)
+    children(node).each do |c|
+      unless visited[c]
+	recurse_each_reachable_breadth_first_visited(c, visited, &block)
+      end
+    end
+  end
+
+  def root_nodes
+    @is_root.reject {|key,val| val == false}.keys
+  end
+  alias_method :roots, :root_nodes
+
+  def leaf_nodes
+    @is_leaf.reject {|key,val| val == false}.keys
+  end
+  alias_method :leafs, :leaf_nodes
+
+  def internal_node?(node)
+    !root?(node) and !leaf?(node) 
+  end
+
+  def internal_nodes
+    nodes.reject {|n| root?(n) or leaf?(n)}
+  end
+
+  def recurse_cyclic?(node, visited)
+    visited[node] = true
+    children(node).each do |c|
+      return true if visited[c] || recurse_cyclic?(c, visited)
+    end
+    false
+  end
+
+  def cyclic?
+    visited = Hash.new
+    root_nodes.each {|root| return true if recurse_cyclic?(root, visited)}
+    false
+  end
+
+  def acyclic?
+    not cyclic?
+  end
+
+  def transition(state, linkInfo)
+    link = links_from(state).detect {|l| l.info == linkInfo}
+    begin
+      link.to
+    rescue Exception
+      raise GraphTraversalException.new(state, links_from(state), linkInfo)
+    end
+  end
+
+  def traverse(fromState, alongLinksWithInfo = [])
+    state, len = fromState, alongLinksWithInfo.length
+    alongLinksWithInfo = alongLinksWithInfo.clone
+    while len > 0
+      state = transition(state, alongLinksWithInfo.shift)
+      len -= 1
+    end
+    state
+  end
+
+  def to_dot(nodeShaper = nil, nodeLabeler = nil, linkLabeler = nil)
+    dgp = DotGraphPrinter.new(links, nodes)
+    dgp.node_shaper = nodeShaper if nodeShaper
+    dgp.node_labeler = nodeLabeler if nodeLabeler
+    dgp.link_labeler = linkLabeler if linkLabeler
+    dgp
+  end
+
+  def to_postscript_file(filename, nodeShaper = nil, nodeLabeler = nil, 
+			 linkLabeler = nil)
+    to_dot(nodeShaper, nodeLabeler, linkLabeler).write_to_file(filename)
+  end
+
+  # Floyd-Warshal algorithm which should be O(n^3) where n is the number of 
+  # nodes. We can probably work a bit on the constant factors!
+  def transitive_closure_floyd_warshal
+    vertices = nodes
+    tcg = DirectedGraph.new
+    num_nodes = vertices.length
+
+    # Direct links
+    for k in (0...num_nodes)
+      for s in (0...num_nodes)
+	vk, vs = vertices[k], vertices[s]	
+	if vk == vs
+	  tcg.link_nodes(vk,vs)
+	elsif linked?(vk, vs)
+	  tcg.link_nodes(vk,vs)
+	end
+      end
+    end
+
+    # Indirect links
+    for i in (0...num_nodes)
+      for j in (0...num_nodes)
+	for k in (0...num_nodes)
+	  vi, vj, vk = vertices[i], vertices[j], vertices[k]
+	  if not tcg.linked?(vi,vj)
+	    tcg.link_nodes(vi, vj) if linked?(vi,vk) and linked?(vk,vj)
+	  end
+	end
+      end
+    end
+    tcg
+  end
+  alias_method :transitive_closure, :transitive_closure_floyd_warshal
+
+  def num_vertices
+    @is_root.size
+  end
+  alias num_nodes num_vertices
+
+  # strongly_connected_components uses the algorithm described in
+  # following paper.
+  # @Article{Tarjan:1972:DFS,
+  #   author =       "R. E. Tarjan",
+  #   key =          "Tarjan",
+  #   title =        "Depth First Search and Linear Graph Algorithms",
+  #   journal =      "SIAM Journal on Computing",
+  #   volume =       "1",
+  #   number =       "2",
+  #   pages =        "146--160",
+  #   month =        jun,
+  #   year =         "1972",
+  #   CODEN =        "SMJCAT",
+  #   ISSN =         "0097-5397 (print), 1095-7111 (electronic)",
+  #   bibdate =      "Thu Jan 23 09:56:44 1997",
+  #   bibsource =    "Parallel/Multi.bib, Misc/Reverse.eng.bib",
+  # }
+  def strongly_connected_components
+    order_cell = [0]
+    order_hash = {}
+    node_stack = []
+    components = []
+
+    order_hash.default = -1
+
+    nodes.each {|node|
+      if order_hash[node] == -1
+        recurse_strongly_connected_components(node, order_cell, order_hash, node_stack, components)
+      end
+    }
+
+    components
+  end
+
+  def recurse_strongly_connected_components(node, order_cell, order_hash, node_stack, components)
+    order = (order_cell[0] += 1)
+    reachable_minimum_order = order
+    order_hash[node] = order
+    stack_length = node_stack.length
+    node_stack << node
+
+    links_from(node).each {|link|
+      nextnode = link.to
+      nextorder = order_hash[nextnode]
+      if nextorder != -1
+        if nextorder < reachable_minimum_order
+          reachable_minimum_order = nextorder
+        end
+      else
+        sub_minimum_order = recurse_strongly_connected_components(nextnode, order_cell, order_hash, node_stack, components)
+        if sub_minimum_order < reachable_minimum_order
+          reachable_minimum_order = sub_minimum_order
+        end
+      end
+    }
+
+    if order == reachable_minimum_order
+      scc = node_stack[stack_length .. -1]
+      node_stack[stack_length .. -1] = []
+      components << scc
+      scc.each {|n|
+        order_hash[n] = num_vertices
+      }
+    end
+    return reachable_minimum_order;
+  end
+end
+
+# Parallel propagation in directed acyclic graphs. Should be faster than 
+# traversing all links from each start node if the graph is dense so that 
+# many traversals can be merged.
+class DagPropagator
+  def initialize(directedGraph, startNodes, &propagationBlock)
+    @graph, @block = directedGraph, propagationBlock
+    init_start_nodes(startNodes)
+    @visited = Hash.new
+  end
+
+  def init_start_nodes(startNodes)
+    @startnodes = startNodes
+  end
+
+  def propagate
+    @visited.clear
+    propagate_recursive
+  end
+
+  def propagate_recursive
+    next_start_nodes = Array.new
+    @startnodes.each do |parent|
+      @visited[parent] = true
+      @graph.children(parent).each do |child|
+	@block.call(parent, child)
+	unless @visited[child] or next_start_nodes.include?(child)
+	  next_start_nodes.push(child)
+	end
+      end
+    end
+    if next_start_nodes.length > 0
+      @startnodes = next_start_nodes
+      propagate_recursive
+    end
+  end
+end
+
+# Directed graph with fast traversal from children to parents (back)
+class BackLinkedDirectedGraph < DirectedGraph
+  def initialize(*args)
+    super
+    @back_link_map = HashOfHash.new {Array.new} # [to][from] -> array of links
+    @incoming_links_info = DefaultInitHash.new {Array.new}
+  end
+
+  def add_link(from, to, informationOnLink = nil)
+    link = super
+    links_to_from(to, from).push link
+    if informationOnLink and 
+	!@incoming_links_info[to].include?(informationOnLink)
+      @incoming_links_info[to].push informationOnLink
+    end
+    link
+  end
+
+  def incoming_links_info(node)
+    @incoming_links_info[node]
+  end
+
+  def back_transition(node, backLinkInfo)
+    link = links_to(node).detect {|l| l.info == backLinkInfo}
+    begin
+      link.from
+    rescue Exception
+      raise GraphTraversalException.new(node, links_to(node), backLinkInfo)
+    end
+  end
+
+  def back_traverse(state, alongLinksWithInfo = [])
+    len = alongLinksWithInfo.length
+    alongLinksWithInfo = alongLinksWithInfo.clone
+    while len > 0
+      state = back_transition(state, alongLinksWithInfo.pop)
+      len -= 1
+    end
+    state
+  end
+
+  def links_to(node)
+    @back_link_map[node].map {|from, links| links}.flatten
+  end
+
+  protected
+
+  def links_to_from(to, from)
+    @back_link_map[to][from]
+  end    
+end
+
+def calc_masks(start, stop, masks = Array.new)
+  mask = 1 << start
+  (start..stop).each {|i| masks[i] = mask; mask <<= 1}
+  masks
+end
+
+class BooleanMatrix
+  def initialize(objects)
+    @index, @objects, @matrix = Hash.new, objects, Array.new 
+    cnt = 0
+    objects.each do |o| 
+      @index[o] = cnt
+      @matrix[cnt] = 0 # Use Integers to represent the booleans
+      cnt += 1
+    end
+    @num_obects = cnt
+  end
+
+  @@masks_max = 1000
+  @@masks = calc_masks(0,@@masks_max)
+
+  def mask(index)
+    mask = @@masks[index]
+    unless mask
+      calc_masks(@@masks_max+1, index, @@masks)
+      mask = @masks[index]
+    end
+    mask
+  end
+
+  def or(index1, index2)
+    @matrix[index1] |= @matrix[index2]
+  end
+
+  def indices(anInteger)
+    index = 0
+    while anInteger > 0
+      yeild(index) if anInteger & 1
+      anInteger >>= 1
+      index += 1
+    end
+  end
+
+  def directed_graph
+    dg = Directedgraph.new
+    @matrix.each_with_index do |v,i|
+      indices(v) do |index|
+	dg.link_nodes(@objects[i], @objects[index])
+      end 
+    end
+    dg
+  end
+
+  def transitive_closure
+    for i in (0..@num_obects)
+      for j in (0..@num_obects)
+	
+      end
+    end
+  end
+end

data/lib/graph/graphviz_dot.rb

@@ -0,0 +1,182 @@
+class DotGraphPrinter
+  attr_accessor :orientation, :size, :color
+
+  # The following can be set to blocks of code that gives a default
+  # value for the node shapes, node labels and link labels, respectively.
+  attr_accessor :node_shaper, :node_labeler, :link_labeler
+
+  # A node shaper maps each node to a string describing its shape.
+  # Valid shapes are: 
+  #   "ellipse"   (default)
+  #   "box"
+  #   "circle"
+  #   "plaintext" (no outline)
+  #   "doublecircle"
+  #   "diamond"
+  # Not yet supported or untested once are:
+  #   "polygon", "record", "epsf"
+  @@default_node_shaper = proc{|n| "box"}
+
+  @@default_node_labeler = proc{|n| 
+    if Symbol===n
+      n.id2name 
+    elsif String===n
+      n
+    else
+      n.inspect
+    end
+  }
+
+  @@default_link_labeler = proc{|info| info ? info.inspect : nil}
+
+  # links is either array of 
+  #                   arrays [fromNode, toNode [, infoOnLink]], or
+  #                   objects with attributes :from, :to, :info
+  # nodes is array of node objects
+  # All nodes used in the links are used as nodes even if they are not 
+  # in the "nodes" parameters.
+  def initialize(links = [], nodes = [])
+    @links, @nodes = links, add_nodes_in_links(links, nodes)
+    @node_attributes, @edge_attributes = Hash.new, Hash.new
+    set_default_values
+  end
+
+  def set_default_values
+    @color = "black"
+    @size = "9,11"
+    @orientation = "portrait"
+    @node_shaper = @@default_node_shaper
+    @node_labeler = @@default_node_labeler
+    @link_labeler = @@default_link_labeler
+  end
+
+  def write_to_file(filename, fileType = "ps")
+    dotfile = temp_filename(filename)
+    File.open(dotfile, "w") {|f| f.write to_dot_specification}
+    system "dot -T#{fileType} -o #{filename} #{dotfile}"
+    File.delete(dotfile)
+  end
+
+  def set_edge_attributes(anEdge, aHash)
+    # TODO check if attributes are valid dot edge attributes
+    edge = find_edge(anEdge)
+    set_attributes(edge, @edge_attributes, true, aHash)
+  end
+
+  def set_node_attributes(aNode, aHash)
+    # TODO check if attributes are valid dot node attributes
+    set_attributes(aNode, @node_attributes, true, aHash)
+  end
+
+  def to_dot_specification
+    set_edge_labels(@links)
+    set_node_labels_and_shape(@nodes)
+    "digraph G {\n" +
+      graph_parameters_to_dot_specification +
+      @nodes.uniq.map {|n| format_node(n)}.join(";\n") + ";\n" +
+      @links.uniq.map {|l| format_link(l)}.join(";\n") + ";\n" +
+      "}"
+  end
+
+  protected
+
+  def find_edge(anEdge)
+    @links.each do |link|
+      return link if source_and_dest(link) == source_and_dest(anEdge)
+    end
+  end
+
+  def set_attributes(key, hash, override, newAttributeHash)
+    h = hash[key] || Hash.new
+    newAttributeHash = all_keys_to_s(newAttributeHash) 
+    newAttributeHash.each do |k, value|
+      h[k] = value unless h[k] and !override
+    end
+    hash[key] = h
+  end
+
+  def graph_parameters_to_dot_specification
+    "graph [\n" + 
+      (self.size ? "  size = #{@size.inspect},\n" : "") +
+      (self.orientation ? "  orientation = #{@orientation},\n" : "") +
+      (self.color ? "  color = #{@color}\n" : "") +
+      "]\n"
+  end
+
+  def each_node_in_links(links)
+    links.each do |l|
+      src, dest = source_and_dest(l)
+      yield src
+      yield dest
+    end
+  end
+
+  def add_nodes_in_links(links, nodes)
+    new_nodes = []
+    each_node_in_links(links) {|node| new_nodes.push node}
+    (nodes + new_nodes).uniq
+  end
+
+  def all_keys_to_s(aHash)
+    # MAYBE reuse existing hash?
+    Hash[*(aHash.map{|p| p[0] = p[0].to_s; p}.flatten)]
+  end
+
+  def set_edge_labels(edges)
+    edges.each do |edge|
+      src, dest, info = get_link_data(edge)
+      if info
+	label = @link_labeler.call(info)
+	set_attributes(edge, @edge_attributes, false, :label =>label) if label 
+      end
+    end
+  end
+
+  def set_node_labels_and_shape(nodes)
+    nodes.each do |node|
+      set_attributes(node, @node_attributes, false,
+		     :label => @node_labeler.call(node).inspect,
+		     :shape => @node_shaper.call(node).inspect)
+    end
+  end
+
+  def get_link_data(link)
+    begin
+      return link.from, link.to, link.info
+    rescue Exception
+      return link[0], link[1], link[2]
+    end
+  end
+  
+  def source_and_dest(link)
+    get_link_data(link)[0,2]
+  end
+
+  def format_attributes(attributes)
+    return "" unless attributes
+    strings = attributes.map {|a, v| "#{a}=#{v}"}
+    strings.length > 0 ? (" [" + strings.join(", ") + "]") : ("")
+  end
+
+  def mangle_node_name(node)
+    "n" + node.hash.abs.inspect
+  end
+
+  def format_link(link)
+    from, to, info = get_link_data(link)
+    mangle_node_name(from) + " -> " + mangle_node_name(to) + 
+      format_attributes(@edge_attributes[link])
+  end
+
+  def format_node(node)
+    mangle_node_name(node) + format_attributes(@node_attributes[node])
+  end
+
+  def temp_filename(base = "tmp")
+    tmpfile = base + rand(100000).inspect
+    while test(?f, tmpfile)
+      tmpfile = base + rand(100000).inspect
+    end
+    tmpfile
+  end
+end

data/lib/graph/version.rb

@@ -0,0 +1,3 @@
+class GraphR
+  VERSION = "0.2.0"
+end

data/tests/directed_graph.rb

@@ -0,0 +1,215 @@
+require 'graph/directed_graph'
+
+class TestDirectedGraph < Test::Unit::TestCase
+  def setup
+    @dg = DirectedGraph.new
+    [[1,2],[2,3],[3,2],[2,4]].each_with_index do |(src,dest),i| 
+      @dg.add_link(src, dest, i)
+    end
+  end
+
+  def test_initialize
+    assert_kind_of(DirectedGraph, @dg)
+  end
+
+  def test_links
+    assert_equals(4, @dg.links.length)
+    assert_equals([1,2,2,3], @dg.links.map {|l| l.from}.sort)
+    assert_equals([2,2,3,4], @dg.links.map {|l| l.to}.sort)
+    assert_equals([0,1,2,3], @dg.links.map {|l| l.info}.sort)
+  end
+
+  def test_nodes
+    assert_equals([1,2,3,4], @dg.nodes.sort)
+  end
+
+  def test_root?
+    assert_equals(true, @dg.root?(1))
+    assert_equals(false, @dg.root?(2))
+    assert_equals(false, @dg.root?(3))
+    assert_equals(false, @dg.root?(4))
+  end
+
+  def test_roots
+    assert_equals([1], @dg.roots)
+  end
+
+  def test_leaf?
+    assert_equals(false, @dg.leaf?(1))
+    assert_equals(false, @dg.leaf?(2))
+    assert_equals(false, @dg.leaf?(3))
+    assert_equals(true, @dg.leaf?(4))
+  end
+
+  def test_leafs
+    assert_equals([4], @dg.leafs)
+  end
+
+  def test_internal_nodes
+    assert_equals([2,3], @dg.internal_nodes.sort)
+  end
+
+  def test_acyclic?
+    assert_equals(false, @dg.acyclic?)
+
+    dg = DirectedGraph.new
+    [[1,2],[2,3],[2,4]].each {|f,t| dg.add_link(f,t)}
+    assert_equals(true, dg.acyclic?)
+  end
+
+  def test_cyclic?
+    assert_equals(true, @dg.cyclic?)
+
+    dg = DirectedGraph.new
+    [[1,2],[2,3],[2,4]].each {|f,t| dg.add_link(f,t)}
+    assert_equals(false, dg.cyclic?)
+  end
+
+  def test_each_reachable_node_once_depth_first
+    # Test inclusive visit
+    visited_nodes = Array.new
+    @dg.each_reachable_node_once_depth_first(1) {|n| visited_nodes.push(n)}
+    assert_equals(4, visited_nodes.length)
+    assert_equals([3,4], visited_nodes[0..1].sort)
+    assert_equals([2,1], visited_nodes[2..3])
+
+    # Test exclusive visit
+    visited_nodes.clear
+    @dg.each_reachable_node_once_depth_first(1, false) do |n| 
+      visited_nodes.push(n)
+    end
+    assert_equals(3, visited_nodes.length)
+    assert_equals([3,4], visited_nodes[0..1].sort)
+    assert_equals([2], visited_nodes[2..2])
+  end
+
+  def test_each_reachable_node_once_breadth_first
+    # Test inclusive visit
+    visited_nodes = Array.new
+    @dg.each_reachable_node_once_breadth_first(1) {|n| visited_nodes.push(n)}
+    assert_equals(4, visited_nodes.length)
+    assert_equals([1,2], visited_nodes[0..1])
+    assert_equals([3,4], visited_nodes[2..3].sort)
+
+    # Test exclusive visit
+    visited_nodes.clear
+    @dg.each_reachable_node_once_breadth_first(1, false) do |n| 
+      visited_nodes.push(n)
+    end
+    assert_equals(3, visited_nodes.length)
+    assert_equals([3,4], visited_nodes[1..2].sort)
+    assert_equals([2], visited_nodes[0..0])
+  end
+
+  def test_link_from_to
+    assert_equals(1, @dg.links_from_to(1,2).length)
+    assert_equals(1, @dg.links_from_to(2,3).length)
+    assert_equals(1, @dg.links_from_to(3,2).length)
+    assert_equals(1, @dg.links_from_to(2,4).length)
+    assert_equals(0, @dg.links_from_to(4,2).length)
+    assert_equals(0, @dg.links_from_to(4,1).length)
+    assert_equals(0, @dg.links_from_to(2,1).length)
+    assert_equals(0, @dg.links_from_to(3,1).length)
+  end
+
+  def test_link_from_to?
+    assert_equals(true, @dg.links_from_to?(1,2))
+    assert_equals(true, @dg.links_from_to?(2,3))
+    assert_equals(true, @dg.links_from_to?(3,2))
+    assert_equals(true, @dg.links_from_to?(2,4))
+    assert_equals(false, @dg.links_from_to?(2,1))
+    assert_equals(false, @dg.links_from_to?(3,1))
+    assert_equals(false, @dg.links_from_to?(4,1))
+    assert_equals(false, @dg.links_from_to?(4,2))
+  end
+
+  def test_link_nodes
+    len = @dg.links.length
+    @dg.link_nodes(1,2)
+    assert_equals(len, @dg.links.length)
+    @dg.link_nodes(1,4)
+    assert_equals(len+1, @dg.links.length)
+  end
+
+  def temp_filename(suffix = "", prefix = "tmp")
+    filename = prefix + rand(100000).inspect + suffix
+    while test(?f, filename)
+      filename = prefix + rand(100000).inspect + suffix
+    end
+    filename
+  end
+
+  def test_to_dot
+    d = @dg.to_dot
+    assert_kind_of(DotGraphPrinter, d)
+    d.write_to_file(filename = temp_filename(".ps"))
+    assert(test(?f, filename))
+    File.delete(filename)
+  end
+
+  def test_to_postscript_file
+    filename = temp_filename(".ps")
+    d = @dg.to_postscript_file(filename)
+    assert(test(?f, filename))
+    File.delete(filename)
+  end
+
+  def test_transition
+    assert_equals(2, @dg.transition(1, 0))
+    assert_equals(3, @dg.transition(2, 1))
+    assert_equals(2, @dg.transition(3, 2))
+    assert_equals(4, @dg.transition(2, 3))
+    assert_exception(GraphTraversalException) {@dg.transition(2,-1)}
+  end
+
+  def test_traverse
+    assert_equals(4, @dg.traverse(1,[0,3]))
+    assert_equals(3, @dg.traverse(1,[0,1]))
+    assert_equals(2, @dg.traverse(1,[0,1,2]))
+    assert_equals(4, @dg.traverse(1,a = [0,1,2,3]))
+    assert_equals([0,1,2,3], a)
+    assert_equals(1, @dg.traverse(1,[]))
+    assert_exception(GraphTraversalException) {@dg.traverse(1,[0,1,2,-1])}
+  end
+
+  DecoratedNode = Struct.new("DecoratedNode", :num, :set)
+
+  def test_propagation
+    dg = DirectedGraph.new
+    nodes = Hash.new
+    [1,2,3,4].each {|n| nodes[n] = DecoratedNode.new(n,[n])}
+    [[1,2],[2,3],[3,2],[2,4]].each_with_index do |ft,i| 
+      dg.add_link(nodes[ft[0]], nodes[ft[1]], i)
+    end
+    prop = DagPropagator.new(dg, dg.roots) {|p, c| c.set |= p.set}
+    prop.propagate
+    nodes = dg.nodes.sort {|n1, n2| n1.num <=> n2.num}
+    assert_equals([1], nodes[0].set)
+    assert_equals([1,2,3], nodes[1].set.sort)
+    assert_equals([1,2,3], nodes[2].set.sort)
+    # Note that cycles are not correctly handled! If they were the set below
+    # should be [1,2,3,4]!
+    assert_equals([1,2,4], nodes[3].set.sort)
+  end
+
+  def test_transitive_closure
+    tcg = @dg.transitive_closure
+    assert_kind_of(DirectedGraph, tcg)
+    assert_equals([1,2,3,4], tcg.children(1).sort)
+    assert_equals([2,3,4], tcg.children(2).sort)
+    assert_equals([2,3,4], tcg.children(3).sort)
+    assert_equals([4], tcg.children(4).sort)
+  end
+
+  def test_num_vertices
+    assert_equals(4, @dg.num_vertices)
+  end
+
+  def test_strongly_connected_components
+    components = @dg.strongly_connected_components
+    assert_equal(3, components.length)
+    assert_equal([[4], [2, 3], [1]], components.map {|ns| ns.sort})
+  end
+end
+
+RUNIT::CUI::TestRunner.run(TestDirectedGraph.suite) if $0 == __FILE__

data/tests/graphviz_dot.rb

@@ -0,0 +1,140 @@
+require 'graph/graphviz_dot'
+
+class TestDotGraphPrinter < Test::Unit::TestCase
+  def test_initialize
+    dgf = DotGraphPrinter.new
+    assert_kind_of(DotGraphPrinter, dgf)
+  end
+
+  # TODO refactor
+  def assert_dotgraph(dotGraph, 
+		      expectedNodeAttributes = {},
+		      expectedEdgeAttributes = {},
+		      expectedParameters = nil)
+    if expectedNodeAttributes
+      expectedNodeAttributes = 
+	replace_nodes_with_their_mangled_names(expectedNodeAttributes)
+    end
+    if expectedEdgeAttributes
+      expectedEdgeAttributes = 
+	replace_nodes_with_their_mangled_names(expectedEdgeAttributes, true)
+    end
+    lines = dotGraph.to_dot_specification.split("\n")
+    assert_equals("digraph G {", lines[0])
+    assert_equals("}", lines[-1])
+    lines[1..-2].each do |line|
+      if line =~ /(\w+)\s*->\s*(\w+)\s*(\[.*\])?/ && expectedEdgeAttributes
+	source, dest = $1, $2
+	expected = expectedEdgeAttributes[[source, dest]]
+	if expected
+	  if $3
+	    attributes = $3[1..-2].split(/\s*,\s*/) 
+	    assert_edge_attributes(expected, attributes)
+	  else
+	    assert(false, "There are no attributes but we expected #{expected.inspect}")
+	  end
+	end
+      elsif line =~ /(\w+)\s+(\[.*\])?$/ && expectedNodeAttributes
+	nodeid, attributes = $1, $2[1..-2].split(", ")
+	assert_node_attributes(expectedNodeAttributes[nodeid], attributes)
+      elsif line =~ /(\w+)\s*=\s*([\w\"]+)/ && expectedParameters
+	parameter, value = $1, $2
+	expected = expectedParameters[parameter]
+	assert_equals(expected, $2) if expected
+      end
+    end
+  end
+
+  def assert_edge_attributes(expected, actualAttributes)
+    actualAttributes.each do |attr|
+      attr =~ /(\w+)\s*=\s*(\w+)/
+      assert_equals(expected[$1], $2) if expected[$1]
+    end
+  end
+
+  def mangle_node_name(node)
+    "n" + node.hash.inspect
+  end
+
+  # The objects are referred to with their ids in the DotGraph, so we
+  # must map them to ids.
+  def replace_nodes_with_their_mangled_names(aHash, edges = false)
+    h = Hash.new
+    if edges
+      aHash.each do |k, val| 
+	k[0] = mangle_node_name(k[0])
+	k[1] = mangle_node_name(k[1])
+	h[k] = val
+      end
+    else
+      aHash.each {|key, val| h[mangle_node_name(key)] = val}
+    end
+    h
+  end
+
+  def assert_node_attributes(expected, attributes)
+    return unless expected
+    attributes.each do |attr|
+      attr =~ /(\w+)=([\w\"]+)/
+      assert_equals(expected[$1], $2) if expected[$1]
+    end
+  end
+
+  def test_format
+    dgp = DotGraphPrinter.new([[1,2]])
+    assert_dotgraph(dgp, {1 => {"shape" => '"box"', "label" => '"1"'},
+		          2 => {"shape" => '"box"', "label" => '"2"'}})
+  end
+
+  def test_custom_node_shape
+    dgp = DotGraphPrinter.new([[1,2]])
+    dgp.node_shaper = proc{|n| n < 2 ? "doublecircle" : "ellipse"}
+    assert_dotgraph(dgp, {1 => {"shape" => '"doublecircle"', "label" => '"1"'},
+		          2 => {"shape" => '"ellipse"', "label" => '"2"'}})
+  end
+
+  def test_changing_orientation
+    dgp = DotGraphPrinter.new([[1,2]])
+    dgp.orientation = "portrait"
+    assert_dotgraph(dgp, nil, nil, {"orientation" => "portrait"})
+
+    dgp.orientation = "landscape"
+    assert_dotgraph(dgp, nil, nil, {"orientation" => "landscape"})
+  end
+
+  def test_setting_edge_attributes
+    # If we want a graph with arrows going up we can achieve this by
+    #   * reversing all edges, and
+    #   * adding an edge attribute "dir=back", which changes the direction
+    #     of the arrow.
+    #
+    # This is the only way to acheive this according to the dot user manual
+    # in section 2.4 on page 9.
+    # 
+    # Below is an example.
+    #
+    edges = [[1,2]]
+    reversed_edges = edges.map {|e| e.reverse}
+    dgp = DotGraphPrinter.new
+    reversed_edges.each do |edge|
+      dgp.set_edge_attributes(edge, "dir" => "back")
+    end
+
+    assert_dotgraph(dgp, nil, {[2,1] => {"dir" => "back"}})
+  end
+
+  def test_node_url_attribute
+    dgp = DotGraphPrinter.new [[1,2]]
+    dgp.set_node_attributes(1, :URL => "node1.html")
+    assert_dotgraph(dgp, {1 => {"URL" => '"node1.html"'}})
+  end
+
+  def test_handles_negative_hash_values
+    dgp = DotGraphPrinter.new [[-1,-2]]
+    dgp.set_node_attributes(-11, :URL => "node1.html")
+    assert_dotgraph(dgp, {-11 => {"URL" => '"node1.html"'}})
+    assert_equals(nil, dgp.to_dot_specification =~ /n-\d+/)
+  end
+end
+
+RUNIT::CUI::TestRunner.run(TestDotGraphPrinter.suite) if $0 == __FILE__

data/tests/test.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+Dir["./tests/*.rb"].each { |f| require f unless f.include?('test.rb') }

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: graphr
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Robert Feld
+- Louis Mullie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-24 00:00:00.000000000 Z
+dependencies: []
+description: ! ' Graph-related Ruby classes, including a fairly extensive directed
+  graph class, and an interface to Graphviz'' DOT graph generator. '
+email:
+- feldt@ce.chalmers.se
+- louis.mullie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/graph/base_extensions.rb
+- lib/graph/directed_graph.rb
+- lib/graph/graphviz_dot.rb
+- lib/graph/Rakefile
+- lib/graph/version.rb
+- tests/directed_graph.rb
+- tests/graphviz_dot.rb
+- tests/test.rb
+- README.md
+- LICENSE
+- RELEASE
+homepage: https://github.com/louismullie/graphr
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Graph-related Ruby classes.
+test_files: []