Add CLI Helpers

Author: jkmassel

Sources/libhostmgr/CLI/Console.swift

@@ -0,0 +1,199 @@
+import Foundation
+import ConsoleKit
+
+public struct Console {
+
+    let terminal = Terminal()
+
+    @discardableResult public func heading(_ message: String, underline: String = "=") -> Self {
+        self.terminal.output(message, style: .plain)
+        self.terminal.output(String.init(repeating: underline, count: message.count), style: .plain)
+        return self
+    }
+
+    @discardableResult public func success(_ message: String) -> Self {
+        self.terminal.success(message)
+        return self
+    }
+
+    @discardableResult public func error(_ message: String) -> Self {
+        self.terminal.error(message)
+        return self
+    }
+
+    @discardableResult public func warn(_ message: String) -> Self {
+        self.terminal.warning(message)
+        return self
+    }
+
+    @discardableResult public func info(_ message: String) -> Self {
+        self.terminal.info(message)
+        return self
+    }
+
+    @discardableResult public func log(_ message: String) -> Self {
+        self.terminal.print(message)
+        return self
+    }
+
+    @discardableResult func message(_ message: String, style: ConsoleStyle) -> Self {
+        self.terminal.output(message, style: style)
+        return self
+    }
+
+    @discardableResult public func printList(_ list: [String], title: String) -> Self {
+        self.terminal.print(title)
+
+        guard !list.isEmpty else {
+            self.terminal.print("  [Empty]")
+            return self
+        }
+
+        for item in list {
+            self.terminal.print("  " + item)
+        }
+
+        return self
+    }
+
+    @discardableResult public func printTable(
+        data: Table,
+        columnTitles: [String] = [],
+        columnSeparator: String = "  "
+    ) -> Self {
+
+        if data.isEmpty {
+            self.terminal.print("[Empty]")
+            return self
+        }
+
+        // Prepend the Column Titles, if present
+        let table = columnTitles.isEmpty ? data : [columnTitles] + data
+
+        let columnCount = columnCounts(for: table)
+
+        for row in table {
+            let string = zip(row, columnCount).map(self.padString).joined(separator: columnSeparator)
+            self.terminal.print(string)
+        }
+
+        return self
+    }
+}
+
+public struct ProgressBar {
+
+    private let terminal = Terminal()
+    private let startDate = Date()
+
+    init(title: String) {
+        terminal.info(title)
+        terminal.print() // Deliberately empty string
+    }
+
+    public static func start(title: String) -> Self {
+        return ProgressBar(title: title)
+    }
+
+    public func update(_ progress: FileTransferProgress) {
+        terminal.clear(lines: 1)
+
+        let elapsedTime = Date().timeIntervalSince(startDate)
+
+        let rate = progress.dataRate(timeIntervalSinceStart: elapsedTime)
+        let remaining = progress.estimatedTimeRemaining(timeIntervalSinceStart: elapsedTime)
+
+        terminal.print("\(progress.formattedPercentage)% [\(rate)/s, \(Format.time(remaining))]")
+    }
+}
+
+// MARK: Static Helpers
+extension Console {
+    public static func startProgress(_ string: String) -> ProgressBar {
+        ProgressBar(title: string)
+    }
+
+    public static func startImageDownload(_ image: RemoteVMImage) -> ProgressBar {
+        let size = Format.fileBytes(image.imageObject.size)
+        return ProgressBar(title: "Downloading \(image.fileName) (\(size))")
+    }
+
+    public static func startFileDownload(_ file: S3Object) -> ProgressBar {
+        let size = Format.fileBytes(file.size)
+        return ProgressBar(title: "Downloading \(file.key) (\(size))")
+    }
+}
+
+// MARK: Static Initializers
+extension Console {
+    @discardableResult public static func heading(_ message: String) -> Self {
+        return Console().heading(message)
+    }
+
+    @discardableResult public static func success(_ message: String) -> Self {
+        return Console().success(message)
+    }
+
+    @discardableResult public static func error(_ message: String) -> Self {
+        return Console().error(message)
+    }
+
+    @discardableResult public static func warn(_ message: String) -> Self {
+        return Console().warn(message)
+    }
+
+    @discardableResult public static func info(_ message: String) -> Self {
+        return Console().info(message)
+    }
+
+    @discardableResult public static func log(_ message: String) -> Self {
+        return Console().log(message)
+    }
+
+    @discardableResult public static func printList(_ list: [String], title: String) -> Self {
+        return Console().printList(list, title: title)
+    }
+
+    @discardableResult public static func printTable(data: Table, columnTitles: [String] = []) -> Self {
+        return Console().printTable(data: data, columnTitles: columnTitles)
+    }
+
+    public static func crash(message: String, reason error: ExitCode) -> Never {
+        Console().error(message)
+        Foundation.exit(error.rawValue)
+    }
+
+    public static func exit(message: String = "", style: ConsoleStyle = .plain) -> Never {
+        Console().message(message, style: style)
+        Foundation.exit(0)
+    }
+}
+
+// MARK: Table Support
+extension Console {
+    public typealias Table = [[String]]
+
+    func columnCounts(for table: Table) -> [Int] {
+        transpose(matrix: table).map { $0.map(\.count).max() ?? 0 }
+    }
+
+    func transpose(matrix: Table) -> Table {
+        guard let numberOfColumns = matrix.first?.count else {
+            return matrix
+        }
+
+        var newTable = [[String]](repeating: [String](repeating: "", count: matrix.count), count: numberOfColumns)
+
+        for (rowIndex, row) in matrix.enumerated() {
+            for (colIndex, col) in row.enumerated() {
+                newTable[colIndex][rowIndex] = col
+            }
+        }
+
+        return newTable
+    }
+
+    func padString(_ string: String, toLength length: Int) -> String {
+        string.padding(toLength: length, withPad: " ", startingAt: 0)
+    }
+}

Sources/libhostmgr/CLI/ExitCode.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+public enum ExitCode: Int32, Error {
+    case fileNotFound
+    case unableToFindRemoteImage
+    case unableToImportVM
+    case invalidVMStatus
+    case notEnoughLocalDiskSpace
+    case parallelsVirtualMachineDoesNotExist
+    case parallelsVirtualMachineIsNotStopped
+    case parallelsVirtualMachineAlreadyExists
+}

Sources/libhostmgr/CLI/Format.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+public struct Format {
+
+    public static func fileBytes(_ count: Int) -> String {
+        fileBytes(Int64(count))
+    }
+
+    public static func fileBytes(_ count: Int64) -> String {
+        let formatter = ByteCountFormatter()
+        formatter.zeroPadsFractionDigits = true
+        formatter.countStyle = .file
+        return formatter.string(fromByteCount: count)
+    }
+
+    public static func memoryBytes(_ count: UInt64) -> String {
+        memoryBytes(Int64(count))
+    }
+
+    public static func memoryBytes(_ count: Int64) -> String {
+        let formatter = ByteCountFormatter()
+        formatter.zeroPadsFractionDigits = true
+        formatter.countStyle = .memory
+        return formatter.string(fromByteCount: count)
+    }
+
+    public static func time(_ interval: TimeInterval) -> String {
+        let formatter = RelativeDateTimeFormatter()
+        formatter.formattingContext = .standalone
+        return formatter.localizedString(fromTimeInterval: interval)
+    }
+}

Tests/libhostmgrTests/CLI/ConsoleTests.swift

@@ -0,0 +1,24 @@
+import XCTest
+@testable import libhostmgr
+
+final class ConsoleTests: XCTestCase {
+
+    // MARK: Table Calculations
+    func testThatColumnCountWorks() throws {
+        let table = [["Jack", "Reacher"], ["James", "Bond"], ["Jason", "Bourne"]]
+        XCTAssertEqual([5, 7], Console().columnCounts(for: table))
+    }
+
+    func testThatTransposeWorks() throws {
+        let original = [
+            ["Jack", "Reacher"],
+            ["James", "Bond"],
+            ["Jason", "Bourne"]
+        ]
+        let transposed = [
+            ["Jack", "James", "Jason"],
+            ["Reacher", "Bond", "Bourne"]
+        ]
+        XCTAssertEqual(transposed, Console().transpose(matrix: original))
+    }
+}