Refactor graph package (addresses #166)

__tests__/dependencies.ts

@@ -64,7 +64,7 @@ describe("Manually constructed simple precedence graphs", () => {
   graph.addNode(nodes[0]);
 
   it("graph equality", () => {
-    expect([...graph.nodes()]).toEqual(nodes);
+    expect([...graph.getNodes()]).toEqual(nodes);
   });
 });
 
@@ -96,11 +96,21 @@ describe("Manually constructed precedence graphs", () => {
     expect(graph.size()[0]).toEqual(6); // V
     expect(graph.size()[1]).toEqual(7); // E
     expect(graph.toString()).toBe(
-      StringUtil.dontIndent`digraph G {
-            "app.R[R0]"->"app.R[R1]"->"app.R[R4]"->"app.R[R3]"->"app.R[R5]";
-            "app.R[R0]"->"app.R[R4]";
-            "app.R[R1]"->"app.R[R2]"->"app.R[R3]";
-            }`
+      StringUtil.dontIndent
+      `graph
+        0["app.R[R3]"]
+        1["app.R[R5]"]
+        2["app.R[R4]"]
+        3["app.R[R2]"]
+        4["app.R[R1]"]
+        5["app.R[R0]"]
+        1 --> 0
+        0 --> 2
+        0 --> 3
+        3 --> 4
+        2 --> 4
+        4 --> 5
+        2 --> 5`
     );
   });
 
@@ -119,11 +129,19 @@ describe("Manually constructed precedence graphs", () => {
     expect(graph.size()[0]).toEqual(6); // V
     expect(graph.size()[1]).toEqual(6); // E
     expect(graph.toString()).toBe(
-      `digraph G {
-"app.R[R0]"->"app.R[R1]"->"app.R[R2]"->"app.R[R3]"->"app.R[R5]";
-"app.R[R1]"->"app.R[R4]";
-"app.R[R0]"->"app.R[R4]";
-}`
+      StringUtil.dontIndent`graph
+      0["app.R[R3]"]
+      1["app.R[R5]"]
+      2["app.R[R4]"]
+      3["app.R[R2]"]
+      4["app.R[R1]"]
+      5["app.R[R0]"]
+      1 --> 0
+      0 --> 3
+      3 --> 4
+      2 --> 4
+      4 --> 5
+      2 --> 5`
     );
   });
 
@@ -133,25 +151,37 @@ describe("Manually constructed precedence graphs", () => {
     expect(graph.size()[1]).toEqual(3); // E
     Log.global.debug(graph.toString());
     expect(graph.toString()).toBe(
-      StringUtil.dontIndent`digraph G {
-            "app.R[R2]"->"app.R[R3]"->"app.R[R5]";
-            "app.R[R0]"->"app.R[R4]";
-            }`
+      StringUtil.dontIndent`graph
+        0["app.R[R3]"]
+        1["app.R[R5]"]
+        2["app.R[R4]"]
+        3["app.R[R2]"]
+        4["app.R[R0]"]
+        1 --> 0
+        0 --> 3
+        2 --> 4`
     );
   });
 
   it("add node 7, make 3 dependent on it", () => {
     graph.addNode(nodes[6]);
-    graph.addEdges(nodes[2], new Set([nodes[6], nodes[3]]));
+    graph.addEdge(nodes[2], nodes[6]);
+    graph.addEdge(nodes[2], nodes[3]);
     expect(graph.size()[0]).toEqual(6); // V
     expect(graph.size()[1]).toEqual(4); // E
     Log.global.debug(graph.toString());
     expect(graph.toString()).toBe(
-      StringUtil.dontIndent`digraph G {
-            "app.R[R2]"->"app.R[R3]"->"app.R[R5]";
-            "app.R[R0]"->"app.R[R4]";
-            "app.R[R2]"->"app.R[R6]";
-            }`
+      StringUtil.dontIndent`graph
+        0["app.R[R3]"]
+        1["app.R[R5]"]
+        2["app.R[R4]"]
+        3["app.R[R2]"]
+        4["app.R[R0]"]
+        5["app.R[R6]"]
+        1 --> 0
+        0 --> 3
+        5 --> 3
+        2 --> 4`
     );
   });
 

__tests__/graph.test.ts

@@ -38,12 +38,12 @@ d2.addNode(node1);
 d2.addNode(node2);
 d2.addEdge(node1, node2);
 
-test("test leafNodes() helper function", () => {
-  expect(d2.leafNodes()).toEqual(new Set([node1]));
+test("test pureEffectNodes() helper function", () => {
+  expect(d2.pureEffectNodes()).toEqual(new Set([node1]));
 });
 
-test("test rootNodes() helper function", () => {
-  expect(d2.rootNodes()).toEqual(new Set([node2]));
+test("test pureOriginNodes() helper function", () => {
+  expect(d2.pureOriginNodes()).toEqual(new Set([node2]));
 });
 
 const d3 = new DependencyGraph<number>();
@@ -136,15 +136,15 @@ const d7 = new DependencyGraph<number>();
 const d8 = new DependencyGraph<number>();
 const d9 = new DependencyGraph<number>();
 test("test dependency graph", () => {
-  expect(d7.getEdges(node1).size).toBe(0);
+  expect(d7.getOriginsOfEffect(node1).size).toBe(0);
   d7.merge(d5);
   expect(d7.size()).toStrictEqual(d5.size());
 
   d8.addNode(node1);
   d9.addEdge(node1, node2);
   d8.merge(d9);
   expect(d8.size()).toStrictEqual(d9.size());
-  expect(d9.getBackEdges(node2).size).toBe(1);
+  expect(d9.getEffectsOfOrigin(node2).size).toBe(1);
   d8.removeNode(node2);
   expect(d8.size()).toStrictEqual([1, 0]);
 });
@@ -154,13 +154,16 @@ test("test add/remove Edges", () => {
   d10.addEdge(node1, node2); // {(node1 -> node2)}
   expect(d10.size()).toStrictEqual([2, 1]);
 
-  d10.addBackEdges(node2, new Set<number>().add(node1).add(node3)); // {(node1 -> node2), (node3 -> node2)}
+  d10.addEdge(node1, node2);
+  d10.addEdge(node3, node2);
   expect(d10.size()).toStrictEqual([3, 2]);
 
-  d10.addEdges(node1, new Set<number>().add(node2).add(node3).add(node4)); // {(node1 -> node2), (node1 -> node3), (node1 -> node4), (node3 -> node2)}
+  d10.addEdge(node1, node2);
+  d10.addEdge(node1, node3);
+  d10.addEdge(node1, node4);
   expect(d10.size()).toStrictEqual([4, 4]);
 
-  d10.addEdges(node5, new Set<number>().add(node1)); // {(node1 -> node2), (node1 -> node3), (node1 -> node4), (node3 -> node2), {node5 -> node1}}
+  d10.addEdge(node5, node1);
   expect(d10.size()).toStrictEqual([5, 5]);
 
   d10.removeEdge(node1, node2); // {(node1 -> node3), (node1 -> node4), (node3 -> node2), {node5 -> node1}}
@@ -170,40 +173,40 @@ test("test add/remove Edges", () => {
 const d11 = new DependencyGraph<number>();
 const d12 = new DependencyGraph<Object>();
 test("test the DOT representation of the dependency graph", () => {
-  expect(d11.toString()).toBe("digraph G {" + "\n}");
+  expect(d11.toDOTRepresentation()).toBe("digraph G {" + "\n}");
 
   d11.addNode(node1); // { node1 }
-  expect(d11.toString()).toBe('digraph G {\n"1";\n}');
+  expect(d11.toDOTRepresentation()).toBe('digraph G {\n"1";\n}');
 
   d11.addEdge(node1, node2); // { (node1 -> node2) }
   d11.addEdge(node2, node3); // { (node1 -> node2 -> node3) }
-  expect(d11.toString()).toBe('digraph G {\n"1"->"2"->"3";\n}');
+  expect(d11.toDOTRepresentation()).toBe('digraph G {\n"1"->"2"->"3";\n}');
 
   const obj = {0: 1};
   d12.addNode(obj);
-  expect(d12.toString()).toBe('digraph G {\n"[object Object]";\n}');
+  expect(d12.toDOTRepresentation()).toBe('digraph G {\n"[object Object]";\n}');
 
   d11.addEdge(node2, node1);
-  expect(d11.toString()).toBe('digraph G {\n"2"->"1"->"2"->"3";\n}');
+  expect(d11.toDOTRepresentation()).toBe('digraph G {\n"2"->"1"->"2"->"3";\n}');
   d11.addEdge(node1, node3);
-  expect(d11.toString()).toBe('digraph G {\n"1"->"2"->"1"->"3";\n"2"->"3";\n}');
+  expect(d11.toDOTRepresentation()).toBe('digraph G {\n"1"->"2"->"1"->"3";\n"2"->"3";\n}');
 });
 
 const d13 = new DependencyGraph<number>();
 test("test for reachableOrigins function of the dependency graph", () => {
   d13.addEdge(node1, node2);
   d13.addEdge(node1, node3);
   d13.addEdge(node2, node4); // { (node1 -> node2 -> node4), (node1 -> node3) }
-  expect(d13.reachableOrigins(node1, new Set<number>(d13.nodes())).size).toBe(
+  expect(d13.reachableOrigins(node1, new Set<number>(d13.getNodes())).size).toBe(
     3
   );
-  expect(d13.reachableOrigins(node2, new Set<number>(d13.nodes())).size).toBe(
+  expect(d13.reachableOrigins(node2, new Set<number>(d13.getNodes())).size).toBe(
     1
   );
-  expect(d13.reachableOrigins(node3, new Set<number>(d13.nodes())).size).toBe(
+  expect(d13.reachableOrigins(node3, new Set<number>(d13.getNodes())).size).toBe(
     0
   );
-  expect(d13.reachableOrigins(node4, new Set<number>(d13.nodes())).size).toBe(
+  expect(d13.reachableOrigins(node4, new Set<number>(d13.getNodes())).size).toBe(
     0
   );
 });

__tests__/simple.ts

@@ -68,13 +68,12 @@ describe("Test names for contained reactors", () => {
 
       it("graph before connect", () => {
         expect(this._getPrecedenceGraph().toString()).toBe(
-          "digraph G {" +
-            "\n" +
-            '"myApp.x[M0]"->"myApp[M0]";' +
-            "\n" +
-            '"myApp.y[M0]"->"myApp[M0]";' +
-            "\n" +
-            "}"
+          StringUtil.dontIndent`graph
+          0["myApp.x[M0]"]
+          1["myApp[M0]"]
+          2["myApp.y[M0]"]
+          1 --> 0
+          1 --> 2`
         );
       });
 
@@ -92,23 +91,29 @@ describe("Test names for contained reactors", () => {
 
       it("graph after connect and before disconnect", () => {
         expect(this._getPrecedenceGraph().toString()).toBe(
-          StringUtil.dontIndent`digraph G {
-                "myApp.x.a"->"myApp.y.b";
-                "myApp.x[M0]"->"myApp[M0]";
-                "myApp.y[M0]"->"myApp[M0]";
-                }`
+          StringUtil.dontIndent`graph
+            0["myApp.x.a"]
+            1["myApp.y.b"]
+            2["myApp.x[M0]"]
+            3["myApp[M0]"]
+            4["myApp.y[M0]"]
+            1 --> 0
+            3 --> 2
+            3 --> 4`
         );
       });
 
       it("graph after disconnect", () => {
         this._disconnect(this.y.b, this.x.a);
         expect(this._getPrecedenceGraph().toString()).toBe(
-          StringUtil.dontIndent`digraph G {
-                "myApp.x.a";
-                "myApp.y.b";
-                "myApp.x[M0]"->"myApp[M0]";
-                "myApp.y[M0]"->"myApp[M0]";
-                }`
+          StringUtil.dontIndent`graph
+            0["myApp.x.a"]
+            1["myApp.y.b"]
+            2["myApp.x[M0]"]
+            3["myApp[M0]"]
+            4["myApp.y[M0]"]
+            3 --> 2
+            3 --> 4`
         );
       });