rgl 0.3.1 → 0.4.0

data/lib/rgl/transitivity.rb

@@ -0,0 +1,179 @@
+require 'enumerator'
+
+require 'rgl/adjacency'
+require 'rgl/base'
+require 'rgl/condensation'
+
+module RGL
+  module Graph
+    # Returns an RGL::DirectedAdjacencyGraph which is the transitive closure of
+    # this graph.  Meaning, for each path u -> ... -> v in this graph, the path
+    # is copied and the edge u -> v is added.  This method supports working with
+    # cyclic graphs by ensuring that edges are created between every pair of
+    # vertices in the cycle, including self-referencing edges.
+    #
+    # This method should run in O(|V||E|) time, where |V| and |E| are the number
+    # of vertices and edges respectively.
+    #
+    # Raises RGL::NotDirectedError if run on an undirected graph.
+    def transitive_closure
+      raise NotDirectedError,
+        "transitive_closure only supported for directed graphs" unless directed?
+
+      # Compute a condensation graph in order to hide cycles.
+      cg = condensation_graph
+
+      # Use a depth first search to calculate the transitive closure over the
+      # condensation graph.  This ensures that as we traverse up the graph we
+      # know the transitive closure of each subgraph rooted at each node
+      # starting at the leaves.  Subsequent root nodes which consume these
+      # subgraphs by way of the nodes' immediate successors can then immediately
+      # add edges to the roots of the subgraphs and to every successor of those
+      # roots.
+      tc_cg = DirectedAdjacencyGraph.new
+      cg.depth_first_search do |v|
+        # For each vertex v, w, and x where the edges v -> w and w -> x exist in
+        # the source graph, add edges v -> w and v -> x to the target graph.
+        cg.each_adjacent(v) do |w|
+          tc_cg.add_edge(v, w)
+          tc_cg.each_adjacent(w) do |x|
+            tc_cg.add_edge(v, x)
+          end
+        end
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        tc_cg.add_vertex(v)
+      end
+
+      # Expand the condensed transitive closure.
+      #
+      # For each trivial strongly connected component in the condensed graph,
+      # add the single node it contains to the new graph and add edges for each
+      # edge the node begins in the original graph.
+      # For each NON-trivial strongly connected component in the condensed
+      # graph, add each node it contains to the new graph and add edges to
+      # every node in the strongly connected component, including self
+      # referential edges.  Then for each edge of the original graph from any
+      # of the contained nodes, add edges from each of the contained nodes to
+      # all the edge targets.
+      g = DirectedAdjacencyGraph.new
+      tc_cg.each_vertex do |scc|
+        scc.each do |v|
+          # Add edges between all members of non-trivial strongly connected
+          # components (size > 1) and ensure that self referential edges are
+          # added when necessary for trivial strongly connected components.
+          if scc.size > 1 || has_edge?(v, v) then
+            scc.each do |w|
+              g.add_edge(v, w)
+            end
+          end
+          # Ensure that a vertex with no in or out edges is added to the graph.
+          g.add_vertex(v)
+        end
+        # Add an edge from every member of a strongly connected component to
+        # every member of each strongly connected component to which the former
+        # points.
+        tc_cg.each_adjacent(scc) do |scc2|
+          scc.each do |v|
+            scc2.each do |w|
+              g.add_edge(v, w)
+            end
+          end
+        end
+      end
+
+      # Finally, the transitive closure...
+      g
+    end
+
+    # Returns an RGL::DirectedAdjacencyGraph which is the transitive reduction
+    # of this graph.  Meaning, that each edge u -> v is omitted if path
+    # u -> ... -> v exists.  This method supports working with cyclic graphs;
+    # however, cycles are arbitrarily simplified which may lead to variant,
+    # although equally valid, results on equivalent graphs.
+    #
+    # This method should run in O(|V||E|) time, where |V| and |E| are the number
+    # of vertices and edges respectively.
+    #
+    # Raises RGL::NotDirectedError if run on an undirected graph.
+    def transitive_reduction
+      raise NotDirectedError,
+        "transitive_reduction only supported for directed graphs" unless directed?
+
+      # Compute a condensation graph in order to hide cycles.
+      cg = condensation_graph
+
+      # Use a depth first search to compute the transitive reduction over the
+      # condensed graph.  This is similar to the computation of the transitive
+      # closure over the graph in that for any node of the graph all nodes
+      # reachable from the node are tracked.  Using a depth first search ensures
+      # that all nodes reachable from a target node are known when considering
+      # whether or not to add an edge pointing to that target.
+      tr_cg = DirectedAdjacencyGraph.new
+      paths_from = {}
+      cg.depth_first_search do |v|
+        paths_from[v] = Set.new
+        cg.each_adjacent(v) do |w|
+          # Only add the edge v -> w if there is no other edge v -> x such that
+          # w is reachable from x.  Make sure to completely skip the case where
+          # x == w.
+          unless Enumerable::Enumerator.new(cg, :each_adjacent, v).any? do |x|
+            x != w && paths_from[x].include?(w)
+          end then
+            tr_cg.add_edge(v, w)
+
+            # For each vertex v, track all nodes reachable from v by adding node
+            # w to the list as well as all the nodes readable from w.
+            paths_from[v] << w
+            paths_from[v].merge(paths_from[w])
+          end
+        end
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        tr_cg.add_vertex(v)
+      end
+
+      # Expand the condensed transitive reduction.
+      #
+      # For each trivial strongly connected component in the condensed graph,
+      # add the single node it contains to the new graph and add edges for each
+      # edge the node begins in the original graph.
+      # For each NON-trivial strongly connected component in the condensed
+      # graph, add each node it contains to the new graph and add arbitrary
+      # edges between the nodes to form a simple cycle.  Then for each strongly
+      # connected component adjacent to the current one, find and add the first
+      # edge which exists in the original graph, starts in the first strongly
+      # connected component, and ends in the second strongly connected
+      # component.
+      g = DirectedAdjacencyGraph.new
+      tr_cg.each_vertex do |scc|
+        # Make a cycle of the contents of non-trivial strongly connected
+        # components.
+        scc_arr = scc.to_a
+        if scc.size > 1 || has_edge?(scc_arr.first, scc_arr.first) then
+          0.upto(scc_arr.size - 2) do |idx|
+            g.add_edge(scc_arr[idx], scc_arr[idx + 1])
+          end
+          g.add_edge(scc_arr.last, scc_arr.first)
+        end
+
+        # Choose a single edge between the members of two different strongly
+        # connected component to add to the graph.
+        edges = Enumerable::Enumerator.new(self, :each_edge)
+        tr_cg.each_adjacent(scc) do |scc2|
+          g.add_edge(
+            *edges.find do |v, w|
+              scc.member?(v) && scc2.member?(w)
+            end
+          )
+        end
+
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        scc.each do |v|
+          g.add_vertex(v)
+        end
+      end
+
+      # Finally, the transitive reduction...
+      g
+    end
+  end                           # module Graph
+end                             # module RGL

data/tests/TestGraph.rb

@@ -11,40 +11,56 @@ class TestGraph < Test::Unit::TestCase
   end
 
   def setup
-    @dg = DirectedAdjacencyGraph.new
+    @dg1 = DirectedAdjacencyGraph.new
     @edges = [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]]
-    @edges.each do |(src,target)| 
-      @dg.add_edge(src, target)
+    @edges.each do |(src,target)|
+      @dg1.add_edge(src, target)
+    end
+    @loan_vertices = [7, 8, 9]
+    @loan_vertices.each do |vertex|
+      @dg1.add_vertex(vertex)
+    end
+
+    @dg2 = DirectedAdjacencyGraph[*@edges.flatten]
+    @loan_vertices.each do |vertex|
+      @dg2.add_vertex(vertex)
     end
 
     @ug = AdjacencyGraph.new(Array)
     @ug.add_edges(*@edges)
+    @ug.add_vertices(*@loan_vertices)
   end
 
   def test_equality
-    assert @dg == @dg
-    assert @dg == @dg.dup
-    assert @ug == @ug.dup
-    assert @ug != @dg
-    assert @dg != @ug
-    assert @dg != 42
-    dup = DirectedAdjacencyGraph[*@edges.flatten]
-    assert @dg == dup
-    @dg.add_vertex 42
-    assert @dg != dup
+    assert_equal @dg1, @dg1
+    assert_equal @dg1, @dg1.dup
+    assert_equal @ug, @ug.dup
+    assert_not_equal @ug, @dg1
+    assert_not_equal @dg1, @ug
+    assert_not_equal @dg1, 42
+    assert_equal @dg1, @dg2
+    @dg1.add_vertex 42
+    assert_not_equal @dg1, @dg2
+  end
+
+  def test_to_adjacency
+    assert_equal @dg1, @dg1.to_adjacency
+    assert_equal @ug, @ug.to_adjacency
   end
 
   def test_merge
-    merge = DirectedAdjacencyGraph.new(Array, @dg, @ug)
-    assert merge.num_edges == 12
-    merge = DirectedAdjacencyGraph.new(Set, @dg, @dg)
-    assert merge.num_edges == 6
+    merge = DirectedAdjacencyGraph.new(Array, @dg1, @ug)
+    assert_equal merge.num_edges, 12
+    assert_equal merge.num_vertices, 9
+    merge = DirectedAdjacencyGraph.new(Set, @dg1, @dg1)
+    assert_equal merge.num_edges, 6
+    assert_equal merge.num_vertices, 9
   end
 
   def test_set_edgelist_class
-    edges = @dg.edges
-    @dg.edgelist_class=Array
-    assert_equal edges, @dg.edges
+    edges = @dg1.edges
+    @dg1.edgelist_class=Array
+    assert_equal edges, @dg1.edges
   end
 
   def test_not_implemented

data/tests/TestRdot.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 require 'rgl/rdot'
 
-include DOT
+include RGL
 
 # Add some helper methods to TestCase
 class Test::Unit::TestCase
@@ -18,476 +18,500 @@ class Test::Unit::TestCase
 
 end
 
-# Tests for DOTPort
+# Tests for DOT::Port
 class TestDotPort < Test::Unit::TestCase
   def test_name
-    port = DOTPort.new()
+    port = DOT::Port.new()
     assert_equal('', port.to_s)
 
-    port = DOTPort.new('test_name')
+    port = DOT::Port.new('test_name')
     assert_equal('<test_name>', port.to_s)
   end
 
   def test_label
-    port = DOTPort.new(nil, 'test_label')
+    port = DOT::Port.new(nil, 'test_label')
     assert_equal('test_label', port.to_s)
   end
 
   def test_name_and_label
-    port = DOTPort.new('test_name', 'test_label')
+    port = DOT::Port.new('test_name', 'test_label')
     assert_equal('<test_name> test_label', port.to_s)
   end
 
   def test_nested_ports
-    port = DOTPort.new([DOTPort.new(nil, 'a'), DOTPort.new(nil, 'b')])
+    port = DOT::Port.new([DOT::Port.new(nil, 'a'), DOT::Port.new(nil, 'b')])
     assert_equal('{a | b}', port.to_s)
   end
 
   def test_name_label_and_nested_ports
-    port = DOTPort.new('test_name', 'test_label')
-    port.ports = [DOTPort.new(nil, 'a'), DOTPort.new(nil, 'b')]
+    port = DOT::Port.new('test_name', 'test_label')
+    port.ports = [DOT::Port.new(nil, 'a'), DOT::Port.new(nil, 'b')]
     assert_equal('{a | b}', port.to_s)
   end
 end
 
-# Tests for DOTNode
+# Tests for DOT::Node
 class TestDotNode < Test::Unit::TestCase
 
   def test_no_name
-    node = DOTNode.new()
+    node = DOT::Node.new()
     dot = node.to_s
     assert_nil(dot)
   end
 
   # bug 16125
   def test_1prop_0comma
-    node = DOTNode.new({"label"=>"the_label"})
+    node = DOT::Node.new({"label"=>"the_label"})
     dot = node.to_s
     assert_no_match(dot, /,/)
   end
 
   def test_2prop_1comma
-    node = DOTNode.new({"label"=>"the_label", "shape"=>"ellipse"})
+    node = DOT::Node.new({"label"=>"the_label", "shape"=>"ellipse"})
     dot = node.to_s
     assert_match(dot, /\[[^,]*,[^,]*\]/)
   end
 
   def test_name_without_label
-    node = DOTNode.new({"name"=>"test_name"})
+    node = DOT::Node.new({"name"=>"test_name"})
     dot = node.to_s
     assert_no_match(dot, /label/)
   end
 
   def test_no_label
-    node = DOTNode.new({"shape"=>"ellipse"})
+    node = DOT::Node.new({"shape"=>"ellipse"})
     dot = node.to_s
     assert_no_match(dot, /label/)
   end
 
   def test_Mrecord_no_label_no_ports
-    node = DOTNode.new({"name" => "test_name", "shape"=>"Mrecord"})
+    node = DOT::Node.new({"name" => "test_name", "shape"=>"Mrecord"})
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*Mrecord/)
     assert_no_match(dot, /label/)
   end
 
   def test_Mrecord_label_no_ports
-    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*Mrecord/)
     assert_match(dot, /label\s*=\s*test_label/)
   end
 
   def test_Mrecord_label_with_ports
-    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"Mrecord"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*Mrecord/)
     assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
   end
 
   def test_Mrecord_no_label_with_ports
-    node = DOTNode.new({"name" => "test_name", "shape"=>"Mrecord"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name", "shape"=>"Mrecord"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*Mrecord/)
     assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
   end
 
   def test_record_no_label_no_ports
-    node = DOTNode.new({"name" => "test_name", "shape"=>"record"})
+    node = DOT::Node.new({"name" => "test_name", "shape"=>"record"})
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*record/)
     assert_no_match(dot, /label/)
   end
 
   def test_record_label_no_ports
-    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*record/)
     assert_match(dot, /label\s*=\s*test_label/)
   end
 
   def test_record_label_with_ports
-    node = DOTNode.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name", "label" => "test_label", "shape"=>"record"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*record/)
     assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
   end
 
   def test_record_no_label_with_ports
-    node = DOTNode.new({"name" => "test_name", "shape"=>"record"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name", "shape"=>"record"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_match(dot, /shape\s*=\s*record/)
     assert_match(dot, /label\s*=\s*"a\s*|\s*b"/)
   end
 
   def test_no_shape_no_label_no_ports
-    node = DOTNode.new({"name" => "test_name"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_no_match(dot, /shape\s*=\s/)
     assert_no_match(dot, /label\s*=\s*/)
   end
 
   def test_no_shape_no_label_with_ports
-    node = DOTNode.new({"name" => "test_name"})
-    node.ports << DOTPort.new(nil, "a")
-    node.ports << DOTPort.new(nil, "b")
+    node = DOT::Node.new({"name" => "test_name"})
+    node.ports << DOT::Port.new(nil, "a")
+    node.ports << DOT::Port.new(nil, "b")
     dot = node.to_s
     assert_no_match(dot, /shape\s*=\s*record/)
     assert_no_match(dot, /label\s*=\s*/)
   end
 
   def test_name_quoting
-    node = DOTNode.new({"name" => "Name with spaces"})
+    node = DOT::Node.new({"name" => "Name with spaces"})
     dot = node.to_s
     assert_match(dot, /^"Name with spaces"$/)
 
-    node = DOTNode.new({"name" => "Name with \"quotes\""})
+    node = DOT::Node.new({"name" => "Name with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /^"Name with \\"quotes\\""$/)
 
-    node = DOTNode.new({"name" => "Name with \\backslashes\\"})
+    node = DOT::Node.new({"name" => "Name with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /^"Name with \\\\backslashes\\\\"$/)
 
-    node = DOTNode.new({"name" => "123.456"})
+    node = DOT::Node.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Node.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Node.new({"name" => "123.456"})
     dot = node.to_s
     assert_match(dot, /^123.456$/)
 
-    node = DOTNode.new({"name" => ".456"})
+    node = DOT::Node.new({"name" => ".456"})
     dot = node.to_s
     assert_match(dot, /^.456$/)
 
-    node = DOTNode.new({"name" => "-.456"})
+    node = DOT::Node.new({"name" => "-.456"})
     dot = node.to_s
     assert_match(dot, /^-.456$/)
 
-    node = DOTNode.new({"name" => "-456"})
+    node = DOT::Node.new({"name" => "-456"})
     dot = node.to_s
     assert_match(dot, /^-456$/)
 
-    node = DOTNode.new({"name" => "-123.456"})
+    node = DOT::Node.new({"name" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /^-123.456$/)
 
-    node = DOTNode.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Node.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /^<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>$/)
   end
 
   def test_label_quoting
-    node = DOTNode.new({"name" => "test_name", "label" => "Label with spaces"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with spaces"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with spaces"/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Node.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
     dot = node.to_s
-    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Left justified label\\l"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "Right justified label\\r"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "123.456"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*123.456/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => ".456"})
+    node = DOT::Node.new({"name" => "test_name", "label" => ".456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*.456/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "-.456"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "-.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-.456/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "-456"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "-456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-456/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "-123.456"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-123.456/)
 
-    node = DOTNode.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Node.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_option_quoting
-    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "Comment with spaces"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "123.456"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*123.456/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => ".456"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => ".456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*.456/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "-.456"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-.456/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "-456"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-456/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "-123.456"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-123.456/)
 
-    node = DOTNode.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Node.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 end
 
-# Tests for DOTEdge
+# Tests for DOT::Edge
 class TestDotEdge < Test::Unit::TestCase
 
   def test_0prop
-    edge = DOTEdge.new({'from' => 'a', 'to' => 'b'})
+    edge = DOT::Edge.new({'from' => 'a', 'to' => 'b'})
     dot = edge.to_s
     assert_equal('a -- b', dot)
   end
 
   def test_1prop_0comma
-    edge = DOTEdge.new({"label"=>"the_label"})
+    edge = DOT::Edge.new({"label"=>"the_label"})
     dot = edge.to_s
     assert_no_match(dot, /,/)
   end
 
   def test_2prop_1comma
-    edge = DOTEdge.new({"label"=>"the_label", "weight"=>"2"})
+    edge = DOT::Edge.new({"label"=>"the_label", "weight"=>"2"})
     dot = edge.to_s
     assert_match(dot, /\[[^,]*,[^,]*\]/)
   end
 
   def test_no_label
-    edge = DOTEdge.new({"weight"=>"2"})
+    edge = DOT::Edge.new({"weight"=>"2"})
     dot = edge.to_s
     assert_no_match(dot, /label/)
   end
 end
 
-# Tests for DOTDirectedEdge
+# Tests for DOT::DirectedEdge
 class TestDotDirectedEdge < Test::Unit::TestCase
 
   def test_0prop
-    edge = DOTDirectedEdge.new({'from' => 'a', 'to' => 'b'})
+    edge = DOT::DirectedEdge.new({'from' => 'a', 'to' => 'b'})
     dot = edge.to_s
     assert_equal('a -> b', dot)
   end
 
   def test_1prop_0comma
-    edge = DOTDirectedEdge.new({"label"=>"the_label"})
+    edge = DOT::DirectedEdge.new({"label"=>"the_label"})
     dot = edge.to_s
     assert_no_match(dot, /,/)
   end
 
   def test_2prop_1comma
-    edge = DOTDirectedEdge.new({"label"=>"the_label", "weight"=>"2"})
+    edge = DOT::DirectedEdge.new({"label"=>"the_label", "weight"=>"2"})
     dot = edge.to_s
     assert_match(dot, /\[[^,]*,[^,]*\]/)
   end
 
   def test_no_label
-    edge = DOTDirectedEdge.new({"weight"=>"2"})
+    edge = DOT::DirectedEdge.new({"weight"=>"2"})
     dot = edge.to_s
     assert_no_match(dot, /label/)
   end
 end
 
-# Tests for DOTGraph
+# Tests for DOT::Graph
 class TestDotGraph < Test::Unit::TestCase
   def test_graph_statement
-    graph = DOTGraph.new()
+    graph = DOT::Graph.new()
     dot = graph.to_s
     assert_match(dot, /^\s*graph /)
   end
 
   def test_name_quoting
-    node = DOTGraph.new({"name" => "Name with spaces"})
+    node = DOT::Graph.new({"name" => "Name with spaces"})
     dot = node.to_s
     assert_match(dot, /^graph "Name with spaces" \{$/)
 
-    node = DOTGraph.new({"name" => "Name with \"quotes\""})
+    node = DOT::Graph.new({"name" => "Name with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /^graph "Name with \\"quotes\\"" \{$/)
 
-    node = DOTGraph.new({"name" => "Name with \\backslashes\\"})
+    node = DOT::Graph.new({"name" => "Name with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /^graph "Name with \\\\backslashes\\\\" \{$/)
 
-    node = DOTGraph.new({"name" => "123.456"})
+    node = DOT::Graph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Graph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Graph.new({"name" => "123.456"})
     dot = node.to_s
     assert_match(dot, /^graph 123.456 \{$/)
 
-    node = DOTGraph.new({"name" => ".456"})
+    node = DOT::Graph.new({"name" => ".456"})
     dot = node.to_s
     assert_match(dot, /^graph .456 \{$/)
 
-    node = DOTGraph.new({"name" => "-.456"})
+    node = DOT::Graph.new({"name" => "-.456"})
     dot = node.to_s
     assert_match(dot, /^graph -.456 \{$/)
 
-    node = DOTGraph.new({"name" => "-456"})
+    node = DOT::Graph.new({"name" => "-456"})
     dot = node.to_s
     assert_match(dot, /^graph -456 \{$/)
 
-    node = DOTGraph.new({"name" => "-123.456"})
+    node = DOT::Graph.new({"name" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /^graph -123.456 \{$/)
 
-    node = DOTGraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Graph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /^graph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
   end
 
   def test_label_quoting
-    node = DOTGraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with spaces"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with spaces"/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
     dot = node.to_s
-    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Left justified label\\l"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "Right justified label\\r"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "123.456"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*123.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => ".456"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => ".456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "-.456"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "-456"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-456/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "-123.456"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-123.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Graph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_option_quoting
-    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with spaces"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "123.456"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*123.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => ".456"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => ".456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "-.456"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "-456"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-456/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "-123.456"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-123.456/)
 
-    node = DOTGraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Graph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_element_containment
-    node1 = DOTNode.new('name' => 'test_node1')
-    node2 = DOTNode.new('name' => 'test_node2')
+    node1 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
 
-    graph = DOTGraph.new('name' => 'test_graph')
+    graph = DOT::Graph.new('name' => 'test_graph')
     assert_nil(graph.pop)
     assert_equal(graph, graph.push(node1))
     assert_equal(graph, graph << node2)
@@ -498,151 +522,163 @@ class TestDotGraph < Test::Unit::TestCase
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
 
-    graph = DOTGraph.new('name' => 'test_graph', 'elements' => [node1])
+    graph = DOT::Graph.new('name' => 'test_graph', 'elements' => [node1])
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
   end
 end
 
-# Tests for DOTDigraph
+# Tests for DOT::Digraph
 class TestDotDigraph < Test::Unit::TestCase
   def test_digraph_statement
-    digraph = DOTDigraph.new()
+    digraph = DOT::Digraph.new()
     dot = digraph.to_s
     assert_match(dot, /^\s*digraph /)
   end
 
   def test_name_quoting
-    node = DOTDigraph.new({"name" => "Name with spaces"})
+    node = DOT::Digraph.new({"name" => "Name with spaces"})
     dot = node.to_s
     assert_match(dot, /^digraph "Name with spaces" \{$/)
 
-    node = DOTDigraph.new({"name" => "Name with \"quotes\""})
+    node = DOT::Digraph.new({"name" => "Name with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /^digraph "Name with \\"quotes\\"" \{$/)
 
-    node = DOTDigraph.new({"name" => "Name with \\backslashes\\"})
+    node = DOT::Digraph.new({"name" => "Name with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /^digraph "Name with \\\\backslashes\\\\" \{$/)
 
-    node = DOTDigraph.new({"name" => "123.456"})
+    node = DOT::Digraph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Digraph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Digraph.new({"name" => "123.456"})
     dot = node.to_s
     assert_match(dot, /^digraph 123.456 \{$/)
 
-    node = DOTDigraph.new({"name" => ".456"})
+    node = DOT::Digraph.new({"name" => ".456"})
     dot = node.to_s
     assert_match(dot, /^digraph .456 \{$/)
 
-    node = DOTDigraph.new({"name" => "-.456"})
+    node = DOT::Digraph.new({"name" => "-.456"})
     dot = node.to_s
     assert_match(dot, /^digraph -.456 \{$/)
 
-    node = DOTDigraph.new({"name" => "-456"})
+    node = DOT::Digraph.new({"name" => "-456"})
     dot = node.to_s
     assert_match(dot, /^digraph -456 \{$/)
 
-    node = DOTDigraph.new({"name" => "-123.456"})
+    node = DOT::Digraph.new({"name" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /^digraph -123.456 \{$/)
 
-    node = DOTDigraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Digraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /^digraph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
   end
 
   def test_label_quoting
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with spaces"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with spaces"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
     dot = node.to_s
-    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "123.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*123.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => ".456"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => ".456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "-.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "-456"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "-123.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-123.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Digraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_option_quoting
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "123.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*123.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => ".456"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => ".456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "-.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "-456"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "-123.456"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-123.456/)
 
-    node = DOTDigraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Digraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_element_containment
-    node1 = DOTNode.new('name' => 'test_node1')
-    node2 = DOTNode.new('name' => 'test_node2')
+    node1 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
 
-    graph = DOTDigraph.new('name' => 'test_graph')
+    graph = DOT::Digraph.new('name' => 'test_graph')
     assert_nil(graph.pop)
     assert_equal(graph, graph.push(node1))
     assert_equal(graph, graph << node2)
@@ -653,151 +689,163 @@ class TestDotDigraph < Test::Unit::TestCase
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
 
-    graph = DOTDigraph.new('name' => 'test_graph', 'elements' => [node1])
+    graph = DOT::Digraph.new('name' => 'test_graph', 'elements' => [node1])
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
   end
 end
 
-# Tests for DOTSubgraph
+# Tests for DOT::Subgraph
 class TestDotSubgraph < Test::Unit::TestCase
   def test_subgraph_statement
-    subgraph = DOTSubgraph.new()
+    subgraph = DOT::Subgraph.new()
     dot = subgraph.to_s
     assert_match(dot, /^\s*subgraph /)
   end
 
   def test_name_quoting
-    node = DOTSubgraph.new({"name" => "Name with spaces"})
+    node = DOT::Subgraph.new({"name" => "Name with spaces"})
     dot = node.to_s
     assert_match(dot, /^subgraph "Name with spaces" \{$/)
 
-    node = DOTSubgraph.new({"name" => "Name with \"quotes\""})
+    node = DOT::Subgraph.new({"name" => "Name with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /^subgraph "Name with \\"quotes\\"" \{$/)
 
-    node = DOTSubgraph.new({"name" => "Name with \\backslashes\\"})
+    node = DOT::Subgraph.new({"name" => "Name with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /^subgraph "Name with \\\\backslashes\\\\" \{$/)
 
-    node = DOTSubgraph.new({"name" => "123.456"})
+    node = DOT::Subgraph.new({"name" => "Name with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name with\nembedded\nnewlines".*\Z/m)
+
+    node = DOT::Subgraph.new({"name" => "Name_with_trailing_newline\n"})
+    dot = node.to_s
+    assert_match(dot, /\A.*"Name_with_trailing_newline\n".*\Z/m)
+
+    node = DOT::Subgraph.new({"name" => "123.456"})
     dot = node.to_s
     assert_match(dot, /^subgraph 123.456 \{$/)
 
-    node = DOTSubgraph.new({"name" => ".456"})
+    node = DOT::Subgraph.new({"name" => ".456"})
     dot = node.to_s
     assert_match(dot, /^subgraph .456 \{$/)
 
-    node = DOTSubgraph.new({"name" => "-.456"})
+    node = DOT::Subgraph.new({"name" => "-.456"})
     dot = node.to_s
     assert_match(dot, /^subgraph -.456 \{$/)
 
-    node = DOTSubgraph.new({"name" => "-456"})
+    node = DOT::Subgraph.new({"name" => "-456"})
     dot = node.to_s
     assert_match(dot, /^subgraph -456 \{$/)
 
-    node = DOTSubgraph.new({"name" => "-123.456"})
+    node = DOT::Subgraph.new({"name" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /^subgraph -123.456 \{$/)
 
-    node = DOTSubgraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Subgraph.new({"name" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /^subgraph <html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html> \{$/)
   end
 
   def test_label_quoting
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with spaces"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with spaces"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with spaces"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\"quotes\\""/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Label with \\\\backslashes\\\\"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Label with\nembedded newline"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label with\nembedded\nnewlines"})
+    dot = node.to_s
+    assert_match(dot, /label\s*=\s*"Label with\\nembedded\\nnewlines"/)
+
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Label_with_a_trailing_newline\n"})
     dot = node.to_s
-    assert_match(dot, /label\s*=\s*"Label with\\nembedded newline"/)
+    assert_match(dot, /label\s*=\s*"Label_with_a_trailing_newline\\n"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Left justified label\\l"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Left justified label\\l"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "Right justified label\\r"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*"Right justified label\\r"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "123.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*123.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => ".456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => ".456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "-.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "-456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "-123.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*-123.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Subgraph.new({"name" => "test_name", "label" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /label\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_option_quoting
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with spaces"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with spaces"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with \"quotes\""})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\"quotes\\""/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "Comment with \\backslashes\\"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*"Comment with \\\\backslashes\\\\"/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "123.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*123.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => ".456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => ".456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "-123.456"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "-123.456"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*-123.456/)
 
-    node = DOTSubgraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
+    node = DOT::Subgraph.new({"name" => "test_name", "comment" => "<html><head><title>test</title></head>\n<body>text</body></html>"})
     dot = node.to_s
     assert_match(dot, /comment\s*=\s*<html><head><title>test<\/title><\/head>\n<body>text<\/body><\/html>/)
   end
 
   def test_element_containment
-    node1 = DOTNode.new('name' => 'test_node1')
-    node2 = DOTNode.new('name' => 'test_node2')
+    node1 = DOT::Node.new('name' => 'test_node1')
+    node2 = DOT::Node.new('name' => 'test_node2')
 
-    graph = DOTSubgraph.new('name' => 'test_graph')
+    graph = DOT::Subgraph.new('name' => 'test_graph')
     assert_nil(graph.pop)
     assert_equal(graph, graph.push(node1))
     assert_equal(graph, graph << node2)
@@ -808,7 +856,7 @@ class TestDotSubgraph < Test::Unit::TestCase
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
 
-    graph = DOTSubgraph.new('name' => 'test_graph', 'elements' => [node1])
+    graph = DOT::Subgraph.new('name' => 'test_graph', 'elements' => [node1])
     assert_equal(node1, graph.pop)
     assert_nil(graph.pop)
   end