Rename some stuff. Add tests. Add convenience functions.

Author: flowtoolz

Code/Graph+Algorithms/Graph+Condensation.swift renamed to Code/Graph+Algorithms/Graph+CondensationGraph.swift

@@ -8,7 +8,7 @@ public extension Graph
 
      See <https://en.wikipedia.org/wiki/Strongly_connected_component>
      */
-    func makeCondensation() -> CondensationGraph
+    func makeCondensationGraph() -> CondensationGraph
     {
         // get SCCs
         let sccs = findStronglyConnectedComponents().map { StronglyConnectedComponent(nodes: $0) }

Code/Graph+Algorithms/Graph+TransitiveReduction.swift renamed to Code/Graph+Algorithms/Graph+MinimumEquivalentGraph.swift

@@ -27,6 +27,16 @@ public class Graph<NodeID: Hashable, NodeValue>
 
     // MARK: - Edges
 
+    public func removeEdge(from sourceID: NodeID, to targetID: NodeID)
+    {
+        removeEdge(with: .init(sourceID, targetID))
+    }
+    
+    public func removeEdge(from source: Node, to target: Node)
+    {
+        removeEdge(with: .init(source, target))
+    }
+    
     public func removeEdge(with id: Edge.ID)
     {
         guard let edge = edgesByID[id] else { return }
@@ -63,7 +73,7 @@ public class Graph<NodeID: Hashable, NodeValue>
                         to target: Node,
                         count: Int = 1) -> Edge
     {
-        let edgeID = Edge.ID(source: source, target: target)
+        let edgeID = Edge.ID(source, target)
 
         if let edge = edgesByID[edgeID]
         {
@@ -94,7 +104,7 @@ public class Graph<NodeID: Hashable, NodeValue>
 
     public func edge(from sourceID: NodeID, to targetID: NodeID) -> Edge?
     {
-        edgesByID[.init(sourceID: sourceID, targetID: targetID)]
+        edgesByID[.init(sourceID, targetID)]
     }
 
     public var edges: Dictionary<Edge.ID, Edge>.Values

Code/Graph+Algorithms/Graph+SCCs.swift renamed to Code/Graph+Algorithms/Graph+StronglyConnectedComponents.swift

@@ -10,16 +10,16 @@ public class GraphEdge<NodeID: Hashable, NodeValue>: Identifiable, Hashable
 
     // MARK: - Identity
 
-    public var id: ID { ID(source: source, target: target) }
+    public var id: ID { ID(source, target) }
 
     public struct ID: Hashable
     {   
-        internal init(source: Node, target: Node)
+        internal init(_ source: Node, _ target: Node)
         {
-            self.init(sourceID: source.id, targetID: target.id)
+            self.init(source.id, target.id)
         }
 
-        internal init(sourceID: NodeID, targetID: NodeID)
+        internal init(_ sourceID: NodeID, _ targetID: NodeID)
         {
             self.sourceID = sourceID
             self.targetID = targetID

Code/Graph/Graph.swift

@@ -3,6 +3,90 @@ import XCTest
 
 class SwiftNodesTests: XCTestCase {
 
+    func testCodeExamplesFromREADME() throws {
+        let graph = Graph<String, Int> { "id\($0)" }  // NodeID == String, NodeValue == Int
+        let node1 = graph.insert(1)                   // node1.id == "id1"
+        
+        let valueForID1 = graph.value(for: "id1")     // valueForID1 == 1
+        let nodeForID1 = graph.node(for: "id1")       // nodeForID1 === node1
+        
+        XCTAssertEqual(valueForID1, node1.value)
+        XCTAssertIdentical(nodeForID1, node1)
+    }
+    
+    func testAddingEdges() throws {
+        let graph = Graph<String, Int> { "id\($0)" }
+        let node1 = graph.insert(1)
+        let node2 = graph.insert(2)
+        graph.addEdge(from: node1, to: node2)
+        
+        XCTAssertNotNil(graph.edge(from: node1, to: node2))
+        XCTAssertNil(graph.edge(from: node2, to: node1))
+        XCTAssertEqual(graph.edge(from: node1, to: node2)?.count, 1)
+    }
+    
+    func testAddingEdgeWithBigCount() throws {
+        let graph = Graph<String, Int> { "id\($0)" }
+        let node1 = graph.insert(1)
+        let node2 = graph.insert(2)
+        
+        graph.addEdge(from: node1, to: node2, count: 42)
+        XCTAssertEqual(graph.edge(from: node1, to: node2)?.count, 42)
+        
+        graph.addEdge(from: node1, to: node2, count: 58)
+        XCTAssertEqual(graph.edge(from: node1, to: node2)?.count, 100)
+    }
+    
+    func testEdgesAreDirected() throws {
+        let graph = Graph<String, Int> { "id\($0)" }
+        let node1 = graph.insert(1)
+        let node2 = graph.insert(2)
+        XCTAssertNotNil(graph.addEdge(from: node1, to: node2))
+        XCTAssertNil(graph.edge(from: node2, to: node1))
+    }
+    
+    func testUUIDAsID() throws {
+        let graph = Graph<UUID, Int> { _ in UUID() }  // NodeID == UUID, NodeValue == Int
+        let node1 = graph.insert(1)
+        let node2 = graph.insert(1)
+        XCTAssertNotIdentical(node1, node2)
+        XCTAssertEqual(node1.value, node2.value)
+        XCTAssertNotEqual(node1.id, node2.id)
+    }
+    
+    func testOmittingClosureForIdentifiableValues() throws {
+        struct IdentifiableValue: Identifiable { let id = UUID() }
+        let graph = Graph<UUID, IdentifiableValue>()  // NodeID == NodeValue.ID == UUID
+        let node = graph.insert(IdentifiableValue())  // node.id == node.value.id
+        XCTAssertEqual(node.id, node.value.id)
+    }
+    
+    func testSorting() throws {
+        let graph = Graph<Int, Int>()
+        
+        let node1 = graph.insert(1)
+        let node2 = graph.insert(2)
+        let edge = graph.addEdge(from: node1, to: node2)
+        
+        graph.remove(edge)
+        graph.removeEdge(with: edge.id)
+        graph.removeEdge(with: .init(node1, node2))
+        graph.removeEdge(with: .init(node1.id, node2.id))
+        graph.removeEdge(from: node1, to: node2)
+        graph.removeEdge(from: node1.id, to: node2.id)
+    }
+    
+    func testWaysToRemoveAnEdgeCompile() {
+        let graph = Graph<Int, Int>()
+        graph.insert(5)
+        graph.insert(3)
+        
+        graph.remove(edge)
+        graph.removeEdge(from: node1, to: node2)
+        graph.removeEdge(from: node1.id, to: node2.id)
+        graph.removeEdge(with: edge.id)
+    }
+    
     func testInsertingConnectingAndDisconnectingValues() throws {
         let graph = Graph<String, Int> { "id\($0)" }
         XCTAssertNil(graph.node(for: "id1"))