Refactor the dot graph generation out of cros_generate_deps_graphs

cros_generate_deps_graphs

 #!/usr/bin/python
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generates pretty dependency graphs for Chrome OS packages."""
 
+import dot_helper
 import optparse
 import os
-import subprocess
 import sys
 
 
 NORMAL_COLOR = 'black'
 TARGET_COLOR = 'red'
 SEED_COLOR = 'green'
 CHILD_COLOR = 'grey'
 
 
 def GetReverseDependencyClosure(full_name, deps_map):
@@ skipping 13 matching lines @@
   GetClosure(full_name)
   return s
 
 
 def GetOutputBaseName(node, options):
   """Gets the basename of the output file for a node."""
   return '%s_%s-%s.%s' % (node['category'], node['name'], node['version'],
                           options.format)
 
 
-def GetNodeLines(node, options, color):
+def AddNodeToSubgraph(subgraph, node, options, color):
   """Gets the dot definition for a node."""
   name = node['full_name']
-  tags = ['label="%s (%s)"' % (name, node['action']),
-          'color="%s"' % color,
-          'fontcolor="%s"' % color]
+  href = None
   if options.link:
     filename = GetOutputBaseName(node, options)
-    tags.append('href="%s%s"' % (options.base_url, filename))
-  return ['"%s" [%s];' % (name, ', '.join(tags))]
+    href = '%s%s' % (options.base_url, filename)
+  subgraph.AddNode(name, name, color, href)
 
 
-def GetReverseDependencyArcLines(node, options):
-  """Gets the dot definitions for the arcs leading to a node."""
-  lines = []
-  name = node['full_name']
-  for j in node['rev_deps']:
-    lines.append('"%s" -> "%s";' % (j, name))
-  return lines
-
 
 def GenerateDotGraph(package, deps_map, options):
   """Generates the dot source for the dependency graph leading to a node.
 
   The output is a list of lines."""
   deps = GetReverseDependencyClosure(package, deps_map)
   node = deps_map[package]
 
   # Keep track of all the emitted nodes so that we don't issue multiple
   # definitions
   emitted = set()
 
-  lines = ['digraph dep {',
-           'graph [name="%s"];' % package]
+  graph = dot_helper.Graph(package)
 
   # Add all the children if we want them, all of them in their own subgraph,
   # as a sink. Keep the arcs outside of the subgraph though (it generates
   # better layout).
-  has_children = False
+  children_subgraph = None
   if options.children and node['deps']:
-    has_children = True
-    lines += ['subgraph {',
-              'rank=sink;']
-    arc_lines = []
+    children_subgraph = graph.AddNewSubgraph('sink')
     for child in node['deps']:
       child_node = deps_map[child]
-      lines += GetNodeLines(child_node, options, CHILD_COLOR)
+      AddNodeToSubgraph(children_subgraph, child_node, options, CHILD_COLOR)
       emitted.add(child)
-      # If child is in the rev_deps, we'll get the arc later.
-      if not child in node['rev_deps']:
-        arc_lines.append('"%s" -> "%s";' % (package, child))
-    lines += ['}']
-    lines += arc_lines
+      graph.AddArc(package, child)
 
   # Add the package in its own subgraph. If we didn't have children, make it
   # a sink
-  lines += ['subgraph {']
-  if has_children:
-    lines += ['rank=same;']
+  if children_subgraph:
+    rank = 'same'
   else:
-    lines += ['rank=sink;']
-  lines += GetNodeLines(node, options, TARGET_COLOR)
+    rank = 'sink'
+  package_subgraph = graph.AddNewSubgraph(rank)
+  AddNodeToSubgraph(package_subgraph, node, options, TARGET_COLOR)
   emitted.add(package)
-  lines += ['}']
 
   # Add all the other nodes, as well as all the arcs.
   for dep in deps:
     dep_node = deps_map[dep]
     if not dep in emitted:
       color = NORMAL_COLOR
       if dep_node['action'] == 'seed':
         color = SEED_COLOR
-      lines += GetNodeLines(dep_node, options, color)
-    lines += GetReverseDependencyArcLines(dep_node, options)
+      AddNodeToSubgraph(graph, dep_node, options, color)
+    for j in dep_node['rev_deps']:
+      graph.AddArc(j, dep)
 
-  lines += ['}']
-  return lines
+  return graph.Gen()
 
 
 def GenerateImages(input, options):
   """Generate the output images for all the nodes in the input."""
   deps_map = eval(input.read())
 
   for package in deps_map:
     lines = GenerateDotGraph(package, deps_map, options)
-    data = '\n'.join(lines)
 
     filename = os.path.join(options.output_dir,
                             GetOutputBaseName(deps_map[package], options))
 
-    # Send the source to dot.
-    proc = subprocess.Popen(['dot', '-T' + options.format, '-o' + filename],
-                            stdin=subprocess.PIPE)
-    proc.communicate(data)
+    save_dot_filename = None
+    if options.save_dot:
+      save_dot_filename = filename + '.dot'
 
-    if options.save_dot:
-      file = open(filename + '.dot', 'w')
-      file.write(data)
-      file.close()
+    dot_helper.GenerateImage(lines, filename, options.format, save_dot_filename)
 
 
 def main():
   parser = optparse.OptionParser(usage='usage: %prog [options] input')
   parser.add_option('-f', '--format', default='svg',
                     help='Dot output format (png, svg, etc.).')
   parser.add_option('-o', '--output-dir', default='.',
                     help='Output directory.')
   parser.add_option('-c', '--children', action='store_true',
                     help='Also add children.')
@@ skipping 14 matching lines @@
   if not inputs:
     GenerateImages(sys.stdin, options)
   else:
     for i in inputs:
       file = open(i)
       GenerateImages(file, options)
       file.close()
 
 if __name__ == '__main__':
   main()