Add GraphViz package dependency

Replace ad-hoc implementation of DOT diagram encoding

Author: mattt

Package.resolved

@@ -6,18 +6,19 @@ import PackageDescription
 let package = Package(
     name: "swift-doc",
     dependencies: [
+        .package(url: "https://github.com/apple/swift-syntax.git", .revision("swift-5.2-DEVELOPMENT-SNAPSHOT-2020-03-09-a")),
+        .package(url: "https://github.com/SwiftDocOrg/SwiftSemantics.git", .branch("swift-5.2")),
         .package(url: "https://github.com/SwiftDocOrg/CommonMark.git", .branch("master")),
         .package(url: "https://github.com/SwiftDocOrg/SwiftMarkup.git", .upToNextMinor(from: "0.0.4")),
-        .package(url: "https://github.com/SwiftDocOrg/SwiftSemantics.git", .branch("swift-5.2")),
-        .package(url: "https://github.com/apple/swift-syntax.git", .revision("swift-5.2-DEVELOPMENT-SNAPSHOT-2020-03-09-a")),
+        .package(url: "https://github.com/SwiftDocOrg/GraphViz.git", .upToNextMinor(from: "0.0.1")),
         .package(url: "https://github.com/apple/swift-argument-parser", .upToNextMinor(from: "0.0.2")),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
             name: "swift-doc",
-            dependencies: ["ArgumentParser", "SwiftDoc", "SwiftSemantics", "SwiftMarkup", "CommonMarkBuilder", "DCOV"]
+            dependencies: ["ArgumentParser", "SwiftDoc", "SwiftSemantics", "SwiftMarkup", "CommonMarkBuilder", "DCOV", "GraphViz"]
         ),
         .target(
             name: "DCOV",

Package.swift

@@ -23,7 +23,23 @@ public final class Interface: Codable {
 
     public private(set) lazy var baseClasses: [Symbol] = {
         return symbols.filter { $0.declaration is Class &&
-                                typesInherited(by: $0).isEmpty }
+            typesInherited(by: $0).isEmpty }
+    }()
+
+    public private(set) lazy var classHierarchies: [Symbol: Set<Symbol>] = {
+        var classClusters: [Symbol: Set<Symbol>] = [:]
+
+        for baseClass in baseClasses {
+            var superclasses = Set(CollectionOfOne(baseClass))
+
+            while !superclasses.isEmpty {
+                let subclasses = Set(superclasses.flatMap { typesInheriting(from: $0) }.filter { $0.isPublic })
+                defer { superclasses = subclasses }
+                classClusters[baseClass, default: []].formUnion(subclasses)
+            }
+        }
+
+        return classClusters
     }()
 
     public private(set) lazy var relationships: [Relationship] = {

Sources/SwiftDoc/Interface.swift

@@ -2,84 +2,81 @@ import ArgumentParser
 import Foundation
 import SwiftDoc
 import SwiftSemantics
+import GraphViz
+import DOT
 
 extension SwiftDoc {
     struct Diagram: ParsableCommand {
         struct Options: ParsableArguments {
             @Argument(help: "One or more paths to Swift files")
             var inputs: [String]
         }
-
+        
         static var configuration = CommandConfiguration(abstract: "Generates diagram of Swift symbol relationships")
-
+        
         @OptionGroup()
         var options: Options
-
+        
         func run() throws {
             let module = try Module(paths: options.inputs)
-            print(GraphViz.diagram(of: module), to: &standardOutput)
+            print(diagram(of: module), to: &standardOutput)
         }
     }
 }
 
 // MARK: -
 
-enum GraphViz {
-    static func diagram(of module: Module) -> String {
-        var lines: [String] = []
+fileprivate func diagram(of module: Module) -> String {
+    var graph = Graph(directed: true)
+    
+    for (baseClass, subclasses) in module.interface.classHierarchies {
+        var subgraph = Subgraph(id: "cluster_\(baseClass.id.description.replacingOccurrences(of: ".", with: "_"))")
 
-        var classClusters: [Symbol: Set<Symbol>] = [:]
-        for baseClass in module.interface.baseClasses {
-            var superclasses = Set(CollectionOfOne(baseClass))
+        for subclass in subclasses {
+            var subclassNode = Node("\(subclass.id)")
+            subclassNode.shape = .box
 
-            while !superclasses.isEmpty {
-                let subclasses = Set(superclasses.flatMap { module.interface.typesInheriting(from: $0) }
-                    .filter { $0.isPublic })
-                defer { superclasses = subclasses }
-                classClusters[baseClass, default: []].formUnion(subclasses)
+            if subclass.declaration.modifiers.contains(where: { $0.name == "final" }) {
+                subclassNode.strokeWidth = 2.0
             }
-        }
 
-        for (baseClass, cluster) in classClusters {
-            var clusterLines: [String] = []
-
-            for subclass in cluster {
-                if subclass.declaration.modifiers.contains(where: { $0.name == "final" }) {
-                    clusterLines.append(#""\#(subclass.id)" [shape=box,peripheries=2];"#)
-                } else {
-                    clusterLines.append(#""\#(subclass.id)" [shape=box];"#)
-                }
-
-                for superclass in module.interface.typesInherited(by: subclass) {
-                    clusterLines.append(#""\#(subclass.id)" -> "\#(superclass.id)";"#)
-                }
-            }
+            subgraph.append(subclassNode)
+            
+            for superclass in module.interface.typesInherited(by: subclass) {
+                let superclassNode = Node("\(superclass.id)")
+                subgraph.append(superclassNode)
 
-            if cluster.count > 1 {
-                clusterLines = (
-                    ["", "subgraph cluster_\(baseClass.id.description.replacingOccurrences(of: ".", with: "_")) {"] +
-                        clusterLines.map { $0.indented() } +
-                        ["}", ""]
-                )
+                let edge = Edge(from: subclassNode, to: superclassNode)
+                subgraph.append(edge)
             }
-
-            lines.append(contentsOf: clusterLines)
         }
+        
+        if subclasses.count > 1 {
+            graph.append(subgraph)
+        } else {
+            subgraph.nodes.forEach { graph.append($0) }
+            subgraph.edges.forEach { graph.append($0) }
+        }
+    }
+    
 
-        lines.append("")
+    for symbol in (module.interface.symbols.filter { $0.isPublic && $0.declaration is Type }) {
+        let symbolNode = Node("\(symbol.id)")
+        graph.append(symbolNode)
 
-        for symbol in (module.interface.symbols.filter { $0.isPublic && $0.declaration is Type }) {
-            for inherited in module.interface.typesConformed(by: symbol) {
-                lines.append(#""\#(symbol.id)" -> "\#(inherited.id)";"#)
-            }
+        for inherited in module.interface.typesConformed(by: symbol) {
+            let inheritedNode = Node("\(inherited.id.description)")
+            let edge = Edge(from: symbolNode, to: inheritedNode)
+
+            graph.append(inheritedNode)
+            graph.append(edge)
         }
+    }
 
-        lines = ["digraph \(module.name) {"] +
-            lines.map { $0.indented() } +
-            ["}"]
+    let encoder = DOTEncoder()
+    let dot = encoder.encode(graph)
 
-        return lines.joined(separator: "\n")
-    }
+    return dot
 }
 
 // MARK: -