ProgressBar: Various fixes (apple#1025)

There's a couple things I don't think are intuitive about this.

1. Because of the internal task, render() can still be called even after
finish() completes. Ideally async defers are supported and we could just
await the final render completing after cancelling the task and setting
.finished, but alas. To fix this we can just lock across the methods for
now.
2. We always clear the screen in the destructor, even if we don't use
the
progress bar. I don't think we should honestly do anything in the
destructor.
Feels a programmer error not to defer { bar.finish() } or call it
somewhere.
3. Our spaces based line clearing. Use the ansi escape sequence for
clearing line;
I think our calculations were slightly off and it would leave trailing
output ( "s]" )
in some cases.
4. Shrinking the window until the output is smaller than the terminal
window (and vice
versa) is wonky on various term emulators. Truthfully, this is just a
hard problem,
but we can truncate our output and still provide some useful info.

This fixes some single line output (cat /etc/hostname etc.) getting
cleared in our atexit handler, as well as the need for the usleep.

Author: dcantah

Sources/TerminalProgress/ProgressBar+State.swift

@@ -17,10 +17,10 @@
 import Foundation
 
 extension ProgressBar {
-    /// A configuration struct for the progress bar.
-    public struct State {
+    /// State for the progress bar.
+    struct State {
         /// A flag indicating whether the progress bar is finished.
-        public var finished = false
+        var finished = false
         var iteration = 0
         private let speedInterval: DispatchTimeInterval = .seconds(1)
 
@@ -41,6 +41,7 @@ extension ProgressBar {
                 calculateSizeSpeed()
             }
         }
+
         var totalSize: Int64?
         private var sizeUpdateSpeed: String?
         var sizeSpeed: String? {
@@ -66,6 +67,7 @@ extension ProgressBar {
 
         var startTime: DispatchTime
         var output = ""
+        var renderTask: Task<Void, Never>?
 
         init(
             description: String = "", subDescription: String = "", itemsName: String = "", tasks: Int = 0, totalTasks: Int? = nil, items: Int = 0, totalItems: Int? = nil,

Sources/TerminalProgress/ProgressBar+Terminal.swift

@@ -21,30 +21,39 @@ enum EscapeSequence {
     static let hideCursor = "\u{001B}[?25l"
     static let showCursor = "\u{001B}[?25h"
     static let moveUp = "\u{001B}[1A"
+    static let clearToEndOfLine = "\u{001B}[K"
 }
 
 extension ProgressBar {
-    private var terminalWidth: Int {
+    var termWidth: Int {
         guard
             let terminalHandle = term,
             let terminal = try? Terminal(descriptor: terminalHandle.fileDescriptor)
         else {
             return 0
         }
 
-        let terminalWidth = (try? Int(terminal.size.width)) ?? 0
-        return terminalWidth
+        return (try? Int(terminal.size.width)) ?? 0
     }
 
     /// Clears the progress bar and resets the cursor.
     public func clearAndResetCursor() {
-        clear()
-        resetCursor()
+        state.withLock { s in
+            clear(state: &s)
+            resetCursor()
+        }
     }
 
     /// Clears the progress bar.
     public func clear() {
-        displayText("")
+        state.withLock { s in
+            clear(state: &s)
+        }
+    }
+
+    /// Clears the progress bar (caller must hold state lock).
+    func clear(state: inout State) {
+        displayText("", state: &state)
     }
 
     /// Resets the cursor.
@@ -63,27 +72,24 @@ extension ProgressBar {
     }
 
     func displayText(_ text: String, terminating: String = "\r") {
-        var text = text
-
-        // Clears previously printed characters if the new string is shorter.
-        printedWidth.withLock {
-            text += String(repeating: " ", count: max($0 - text.count, 0))
-            $0 = text.count
-        }
-        state.withLock {
-            $0.output = text
+        state.withLock { s in
+            displayText(text, state: &s, terminating: terminating)
         }
+    }
+
+    func displayText(_ text: String, state: inout State, terminating: String = "\r") {
+        state.output = text
 
         // Clears previously printed lines.
         var lines = ""
-        if terminating.hasSuffix("\r") && terminalWidth > 0 {
-            let lineCount = (text.count - 1) / terminalWidth
+        if terminating.hasSuffix("\r") && termWidth > 0 {
+            let lineCount = (text.count - 1) / termWidth
             for _ in 0..<lineCount {
                 lines += EscapeSequence.moveUp
             }
         }
 
-        text = "\(text)\(terminating)\(lines)"
-        display(text)
+        let output = "\(text)\(EscapeSequence.clearToEndOfLine)\(terminating)\(lines)"
+        display(output)
     }
 }