Update GraphViz (#8)

* Update GraphViz

* Update Snapshots + remove linux test files

* Remove linux directive

* Revert "Remove linux directive"

This reverts commit 001808b.

* Fix error on linux

* Update package version

* Update macOS CI

* Fix Linux ci

* Fix everything

Author: ctreffs

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ jobs:
         run: sudo xcode-select -s /Applications/Xcode_${{ matrix.xcode }}.app
 
       - name: Test
-        run: swift test -v --skip-update --parallel --enable-code-coverage
+        run: swift test --parallel --enable-code-coverage
         env:
           DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 

Package.resolved

@@ -1,25 +1,32 @@
-// swift-tools-version:5.2
+// swift-tools-version:5.3
 
 import PackageDescription
 
 let package = Package(
     name: "FirebladeGraph",
+    platforms: [
+        .macOS(.v11),
+        .iOS(.v13),
+    ],
     products: [
         .library(
             name: "FirebladeGraph",
-            targets: ["FirebladeGraph"]),
+            targets: ["FirebladeGraph"]
+        ),
     ],
     dependencies: [
-        .package(url: "https://github.com/ctreffs/GraphViz.git", .branch("master")),
+        .package(url: "https://github.com/SwiftDocOrg/GraphViz.git", from: "0.4.1"),
         .package(url: "https://github.com/davecom/SwiftGraph.git", from: "3.1.0"),
-        .package(name: "SnapshotTesting", url: "https://github.com/pointfreeco/swift-snapshot-testing.git", from: "1.11.0")
+        .package(name: "SnapshotTesting", url: "https://github.com/pointfreeco/swift-snapshot-testing.git", from: "1.11.0"),
     ],
     targets: [
         .target(
             name: "FirebladeGraph",
-            dependencies: ["GraphViz", "SwiftGraph"]),
+            dependencies: ["GraphViz", "SwiftGraph"]
+        ),
         .testTarget(
             name: "FirebladeGraphTests",
-            dependencies: ["FirebladeGraph", "SnapshotTesting"]),
+            dependencies: ["FirebladeGraph", "SnapshotTesting"]
+        ),
     ]
 )

Package.swift

@@ -7,28 +7,30 @@
 
 import struct Foundation.Data
 import struct Foundation.UUID
-import DOT
 import GraphViz
 
 public protocol GraphVizNodeRepresentable {
     func graphVizNodeDescription() -> String
 }
 
 extension GraphVizNodeRepresentable {
-    internal func graphVizNode() -> GraphViz.Node {
+    func graphVizNode() -> GraphViz.Node {
         .init(graphVizNodeDescription())
     }
 }
 
 extension String: GraphVizNodeRepresentable {
     public func graphVizNodeDescription() -> String { self }
 }
+
 extension Int: GraphVizNodeRepresentable {
     public func graphVizNodeDescription() -> String { "\(self)" }
 }
+
 extension UInt: GraphVizNodeRepresentable {
     public func graphVizNodeDescription() -> String { "\(self)" }
 }
+
 extension UInt8: GraphVizNodeRepresentable {
     public func graphVizNodeDescription() -> String { "\(self)" }
 }
@@ -38,32 +40,52 @@ extension UUID: GraphVizNodeRepresentable {
 }
 
 public protocol GraphVizRenderable {
-    func renderGraph(as format: Format) -> Data?
+    func renderGraph(as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void)
+}
+
+public enum ImageError: Swift.Error {
+    case failedToCreateImage(_ from: Data)
 }
 
 #if canImport(AppKit)
-import class AppKit.NSImage
-public typealias Image = NSImage
-extension GraphVizRenderable {
-    public func renderGraphAsImage() -> Image? {
-        guard let data = renderGraph(as: .png) else {
-            return nil
-        }
+    import class AppKit.NSImage
+    public typealias Image = NSImage
+    public extension GraphVizRenderable {
+        func renderGraphAsImage(completion: @escaping (Result<Image, Swift.Error>) -> Void) {
+            renderGraph(as: .png) { result in
+                switch result {
+                case let .success(data):
+                    if let image = Image(data: data) {
+                        completion(.success(image))
+                    } else {
+                        completion(.failure(ImageError.failedToCreateImage(data)))
+                    }
 
-        return Image(data: data)
+                case let .failure(failure):
+                    completion(.failure(failure))
+                }
+            }
+        }
     }
-}
 
 #elseif canImport(UIKit)
-import class UIKit.UIImage
-public typealias Image = UIImage
-extension GraphVizRenderable {
-    public final func renderGraphAsImage() -> Image? {
-        guard let data = renderGraph(as: .png) else {
-            return nil
-        }
+    import class UIKit.UIImage
+    public typealias Image = UIImage
+    public extension GraphVizRenderable {
+        func renderGraphAsImage(completion: @escaping (Result<Image, Swift.Error>) -> Void) {
+            renderGraph(as: .png) { result in
+                switch result {
+                case let .success(data):
+                    if let image = Image(data: data) {
+                        completion(.success(image))
+                    } else {
+                        completion(.failure(ImageError.failedToCreateImage(data)))
+                    }
 
-        return Image(data: data)
+                case let .failure(failure):
+                    completion(.failure(failure))
+                }
+            }
+        }
     }
-}
 #endif

Sources/FirebladeGraph/GraphvizRepresentable.swift

@@ -5,22 +5,18 @@
 //  Created by Christian Treffs on 24.03.20.
 //
 
-import GraphViz
 import struct Foundation.Data
+import GraphViz
 
 extension Node: GraphVizRenderable where Content: GraphVizNodeRepresentable {
-    public final func renderGraph(as format: Format) -> Data? {
+    public final func renderGraph(as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) {
         var graph = Graph(directed: true, strict: true)
 
         descend { node in
             node.renderNode(in: &graph)
         }
 
-        do {
-            return try graph.render(using: .dot, to: format)
-        } catch {
-            return nil
-        }
+        graph.render(using: .dot, to: format, completion: completion)
     }
 
     final func renderNode(in graph: inout GraphViz.Graph) {

Sources/FirebladeGraph/Node+Graphviz.swift

@@ -25,7 +25,7 @@ open class Node<Content> {
 
     public init(_ content: Content) {
         self.content = content
-        self.children = []
+        children = []
     }
 
     deinit {
@@ -164,66 +164,70 @@ open class Node<Content> {
     /// Splitting the implementation of the update away from the update call
     /// itself allows the detail to be overridden without disrupting the
     /// general sequence of updateFromParent (e.g. raising events).
-    open func updateFromParent() {
-    }
+    open func updateFromParent() {}
 
     open func childrenNeedingUpdate() -> AnyIterator<ChildNode> {
         AnyIterator(children.makeIterator())
     }
 }
 
 // MARK: Equatable
+
 extension Node: Equatable where Content: Equatable {
     public static func == (lhs: Node<Content>, rhs: Node<Content>) -> Bool {
         lhs.content == rhs.content
     }
 }
 
 // MARK: Comparable
+
 extension Node: Comparable where Content: Comparable {
     public static func < (lhs: Node<Content>, rhs: Node<Content>) -> Bool {
         lhs.content < rhs.content
     }
 }
 
 // MARK: CustomStringConvertible
+
 extension Node: CustomStringConvertible {
-    open var description: String {
+    public var description: String {
         "<\(type(of: self))>"
     }
 }
 
 // MARK: CustomDebugStringConvertible
+
 extension Node: CustomDebugStringConvertible {
-    open var debugDescription: String {
+    public var debugDescription: String {
         "<\(type(of: self)) \(content)>"
     }
 }
 
 // MARK: Recursive description
-extension Node {
+
+public extension Node {
     /// Recursively descripes this node and all it's children.
-    public var descriptionDescending: String {
+    var descriptionDescending: String {
         describeDescending(self) { $0.description }
     }
 
     /// Recursively debug descripes this node and all it's children.
-    public var debugDescriptionDescending: String {
+    var debugDescriptionDescending: String {
         describeDescending(self) { $0.debugDescription }
     }
 
     /// Recursively describe given node and all it's children using a given closure.
     /// - Parameter node: the start node.
     /// - Parameter level: current indentation level.
     /// - Parameter closure: a closure to apply for each node.
-    public func describeDescending(_ node: Node<Content>, _ level: Int = 0, using closure: (Node<Content>) -> String) -> String {
+    func describeDescending(_ node: Node<Content>, _ level: Int = 0, using closure: (Node<Content>) -> String) -> String {
         let prefix = String(repeating: "   ", count: level) + "⮑ "
-        return prefix + closure(node) + "\n" + self.children.map { $0.describeDescending($0, level + 1, using: closure) }.joined()
+        return prefix + closure(node) + "\n" + children.map { $0.describeDescending($0, level + 1, using: closure) }.joined()
     }
 }
 
-extension Node where Content == Void {
-    public convenience init() {
+public extension Node where Content == Void {
+    convenience init() {
         self.init(())
     }
 }

Sources/FirebladeGraph/Node.swift

@@ -5,30 +5,29 @@
 //  Created by Christian Treffs on 24.03.20.
 //
 
-import DOT
 import Foundation
 import GraphViz
 @_exported import SwiftGraph
 
 extension UniqueElementsGraph: GraphVizRenderable where V: GraphVizNodeRepresentable {
-    public final func renderGraph(as format: Format) -> Data? {
-        drawGraphUnweigted(self, as: format)
+    public final func renderGraph(as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) {
+        drawGraphUnweigted(self, as: format, completion: completion)
     }
 }
 
 extension UnweightedGraph: GraphVizRenderable where V: GraphVizNodeRepresentable {
-    public final func renderGraph(as format: Format) -> Data? {
-        drawGraphUnweigted(self, as: format)
+    public final func renderGraph(as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) {
+        drawGraphUnweigted(self, as: format, completion: completion)
     }
 }
 
 extension WeightedGraph: GraphVizRenderable where V: GraphVizNodeRepresentable, W: Numeric {
-    public final func renderGraph(as format: Format) -> Data? {
-        drawGraphWeigted(self, as: format)
+    public final func renderGraph(as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) {
+        drawGraphWeigted(self, as: format, completion: completion)
     }
 }
 
-private func drawGraphUnweigted<G>(_ graph: G, as format: Format) -> Data? where G: SwiftGraph.Graph, G.V: GraphVizNodeRepresentable {
+private func drawGraphUnweigted<G>(_ graph: G, as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) where G: SwiftGraph.Graph, G.V: GraphVizNodeRepresentable {
     let directed = graph.isDAG
     var graphvizGraph = Graph(directed: directed, strict: true)
 
@@ -47,14 +46,10 @@ private func drawGraphUnweigted<G>(_ graph: G, as format: Format) -> Data? where
 
     let layout: LayoutAlgorithm = directed ? .dot : .sfdp
 
-    do {
-        return try graphvizGraph.render(using: layout, to: format)
-    } catch {
-        return nil
-    }
+    graphvizGraph.render(using: layout, to: format, completion: completion)
 }
 
-private func drawGraphWeigted<G, W>(_ graph: G, as format: Format) -> Data? where G: SwiftGraph.Graph, G.V: GraphVizNodeRepresentable, G.E == WeightedEdge<W>, W: Numeric {
+private func drawGraphWeigted<G, W>(_ graph: G, as format: Format, completion: @escaping (Result<Data, Swift.Error>) -> Void) where G: SwiftGraph.Graph, G.V: GraphVizNodeRepresentable, G.E == WeightedEdge<W>, W: Numeric {
     let directed = graph.isDAG
     var graphvizGraph = Graph(directed: directed, strict: true)
 
@@ -76,9 +71,5 @@ private func drawGraphWeigted<G, W>(_ graph: G, as format: Format) -> Data? wher
 
     let layout: LayoutAlgorithm = directed ? .dot : .sfdp
 
-    do {
-        return try graphvizGraph.render(using: layout, to: format)
-    } catch {
-        return nil
-    }
+    graphvizGraph.render(using: layout, to: format, completion: completion)
 }