Merge pull request #456 from LNPANDY/v0lumehi/build-log-store

Move the build log into a BuildLog store (#387)

Author: v0lumehi

frontend/ARCHITECTURE.md

@@ -13,11 +13,12 @@ The plan and the steps are in [LNPANDY/NX2Apple#387](https://github.com/LNPANDY/
 
 ## Where it stands
 
-Step 1 of #387 made the targets and moved the files that already fit. Step 2 moved the language out of `BuildModel` into the `Localizer` store. The rest still lives in the app target and moves with the later steps.
+Step 1 of #387 made the targets and moved the files that already fit. Step 2 moved the language out of `BuildModel` into the `Localizer` store. Step 3 moved the build log into the `BuildLog` store. The rest still lives in the app target and moves with the later steps.
 
 - `BuildModel` is the model of the whole launcher and reaches into every layer, so the files that use it cannot leave the app target yet. It no longer owns the language: it holds the `Localizer` it was given and forwards `lang` and `t()` to it, for the text it writes itself (alerts, status, failures).
 - `NXCore` holds the value types and static functions that need only Foundation: app and engine update parsing, `Localization.swift`, the release notes, the device and signing tools, the cloud folder and saves migration, the bundled tools, input staging, the build target and the pipe reader.
-- `NXModel` holds `Localizer`: `lang` and `t()`. The app creates one with each `BuildModel`, and `ContentView` hands it to every view as an environment object. A view that shows text declares `@EnvironmentObject var loc: Localizer` and calls `loc.t(...)`. A language change redraws these views and nothing else. No other store exists yet.
+- `NXModel` holds `Localizer`: `lang` and `t()`. The app creates one with each `BuildModel`, and `ContentView` hands it to every view as an environment object. A view that shows text declares `@EnvironmentObject var loc: Localizer` and calls `loc.t(...)`. A language change redraws these views and nothing else.
+- `NXModel` also holds `BuildLog`: the log text, its tail trimming and the line buffer. `BuildModel` holds it in a `let` and does not publish it, and only `BuildLogView` (in `NXLauncher`) observes it. A log line redraws the log and no game card. `LauncherPerformanceTests` writes 1000 lines during a build and allows 0 cards. `BuildModel` is not `@MainActor` yet, so it reaches the log through `BuildLog.onMain`.
 - `NXLauncher` holds the views and styles that do not need `BuildModel`: `LauncherPalette`, `Typography`, `LauncherStyles`, `LauncherDropdown`, `PadFocus` and `EmbeddedFonts`.
 - `NX2Apple` holds everything else, including `BuildModel`.
 

frontend/Sources/NX2Apple/ContentView.swift

@@ -123,7 +123,12 @@ final class BuildModel: ObservableObject {
     @Published var staleFrameworks: [StaleFrameworks.Entry] = []   // the prompt of StaleFrameworksPrompt.swift (#449)
     // The shell folder (shellCachePath, shellRoot): ShellRoot.swift.
     @Published var stopping = false
-    @Published var logTail = ""
+    /// The build log. Not published: only `BuildLogView` observes it (#387), so a log line redraws the log and nothing else.
+    let log = BuildLog()
+    var logTail: String {
+        get { BuildLog.onMain { log.text } }
+        set { BuildLog.onMain { log.set(newValue) } }
+    }
     @Published var done = false
     @Published var doneNote = ""
     /// What the NSP script stopped on, when it is one of the known early stops (BuildFailure.swift). nil for a build that
@@ -223,7 +228,6 @@ final class BuildModel: ObservableObject {
     init(localizer: Localizer = Localizer()) { self.localizer = localizer }
 
     private var proc: Process?
-    private var lineBuf = ""
     private var staging: String?
 
     // ---- Process groups: Stop and quitting end the whole build ----
@@ -1244,7 +1248,7 @@ final class BuildModel: ObservableObject {
         shellDeviceChecked = false
         if target != BuildTarget.mac, askAboutStaleFrameworks() { return }   // StaleFrameworksPrompt.swift (#449)
         stopping = false
-        running = true; done = false; doneNote = ""; stages = []; logTail = ""; lineBuf = ""; chainNoteShown = false
+        running = true; done = false; doneNote = ""; stages = []; BuildLog.onMain { log.clear() }; chainNoteShown = false
         failure = nil; confirmingOverride = nil
         let override = takeOverrideFlag()   // for this build only: the next one asks again
         installedOn = ""; installedAppPath = ""
@@ -1677,7 +1681,7 @@ final class BuildModel: ObservableObject {
     }
 
     /// A stopped build leaves no half-finished stages behind: the progress starts empty again.
-    private func resetProgress() { stages = []; logTail = ""; lineBuf = "" }
+    private func resetProgress() { stages = []; BuildLog.onMain { log.clear() } }
 
     private func markAllDone() { for i in stages.indices where stages[i].state != .failed { stages[i].state = .done } }
 
@@ -1695,29 +1699,20 @@ final class BuildModel: ObservableObject {
     }
 
     private func say(_ s: String) { append(s + "\n") }
-    private func append(_ s: String) {
-        logTail += s
-        if logTail.count > 12000 { logTail = String(logTail.suffix(9000)) }
-    }
+    private func append(_ s: String) { BuildLog.onMain { log.append(s) } }
 
     /// Split into lines (the pipe delivers arbitrary chunks) and turn the script's progress into the stage list.
     /// `--progress json` writes one event per line (stage, step, progress with done / total / frac / eta, stage_end,
     /// say), a count change at most every half second; anything else on the pipe (a tool's traceback) is log text.
     /// The older `--progress lines` form is still understood:
     ///   [12:00:01] [2/7] extract v720896 …
     ///   [12:00:20] ✓ [2/7] extract v720896 (0:19): 30,000 files, 3.4 GB
-    private func ingest(_ chunk: String) {
-        lineBuf += chunk
-        while let i = lineBuf.firstIndex(of: "\n") {
-            let line = String(lineBuf[..<i]).replacingOccurrences(of: "\r", with: "")
-            lineBuf = String(lineBuf[lineBuf.index(after: i)...])
-            handle(line)
-        }
+    func ingest(_ chunk: String) {
+        for line in BuildLog.onMain({ log.feed(chunk) }) { handle(line) }
     }
 
     private func flushLines() {
-        guard !lineBuf.isEmpty else { return }
-        handle(lineBuf); lineBuf = ""
+        if let rest = BuildLog.onMain({ log.flush() }) { handle(rest) }
     }
 
     private func handle(_ line: String) {
@@ -3394,21 +3389,7 @@ struct BuilderView: View {
     }
 
     private var logView: some View {
-        ScrollViewReader { sp in
-            ScrollView {
-                Text(m.logTail.isEmpty ? loc.t("log.placeholder") : m.logTail)
-                    .font(.mono(11))
-                    .textSelection(.enabled)
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .foregroundStyle(.secondary)
-                    .padding(12)
-                    .id("end")
-            }
-            .frame(height: 220)
-            .background(Color.black.opacity(0.35), in: RoundedRectangle(cornerRadius: 10))
-            .onChange(of: m.logTail) { _ in sp.scrollTo("end", anchor: .bottom) }
-            .onAppear { sp.scrollTo("end", anchor: .bottom) }
-        }
+        BuildLogView(log: m.log,placeholder: loc.t("log.placeholder"))
     }
 
     /// The page's conclusion, at the end of its column: what is still missing, and the button.

frontend/Sources/NXLauncher/BuildLogView.swift

@@ -0,0 +1,32 @@
+import SwiftUI
+import NXModel
+
+/// The build log as a scrolling text. It is the only view that observes `BuildLog`, so a log line redraws this and not the
+/// launcher around it (LNPANDY/NX2Apple#387).
+package struct BuildLogView: View {
+    @ObservedObject var log: BuildLog
+    let placeholder: String
+
+    package init(log: BuildLog, placeholder: String) {
+        self.log = log
+        self.placeholder = placeholder
+    }
+
+    package var body: some View {
+        ScrollViewReader { sp in
+            ScrollView {
+                Text(log.text.isEmpty ? placeholder : log.text)
+                    .font(.mono(11))
+                    .textSelection(.enabled)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .foregroundStyle(.secondary)
+                    .padding(12)
+                    .id("end")
+            }
+            .frame(height: 220)
+            .background(Color.black.opacity(0.35), in: RoundedRectangle(cornerRadius: 10))
+            .onChange(of: log.text) { _ in sp.scrollTo("end", anchor: .bottom) }
+            .onAppear { sp.scrollTo("end", anchor: .bottom) }
+        }
+    }
+}

frontend/Sources/NXModel/BuildLog.swift

@@ -0,0 +1,61 @@
+import Foundation
+import Combine
+
+/// The text of the build log (LNPANDY/NX2Apple#387). It is a store of its own, so a line from the build script invalidates
+/// the views that show the log and nothing else: `BuildModel` holds it in a `let` and does not publish it, and no view above
+/// the log observes it. The failure classifier reads `text` once, when a build stops.
+///
+/// `text` keeps the tail: past `limit` characters it shrinks to the last `keep`. The pipe delivers arbitrary chunks, so
+/// `feed` also splits them into lines and holds back a partial last line until its newline arrives.
+@MainActor package final class BuildLog: ObservableObject {
+    package static let limit = 12000
+    package static let keep = 9000
+
+    @Published package private(set) var text = ""
+    private var partial = ""
+
+    nonisolated package init() {}
+
+    /// Adds text to the log. It is not split into lines: the caller ends a line itself.
+    package func append(_ s: String) {
+        text += s
+        if text.count > Self.limit { text = String(text.suffix(Self.keep)) }
+    }
+
+    /// Takes a chunk of the script's output and returns the lines it completes, without their line ends. The rest waits
+    /// for the next chunk. It does not add to `text`: the caller decides what of each line is log text.
+    package func feed(_ chunk: String) -> [String] {
+        partial += chunk
+        var lines: [String] = []
+        while let i = partial.firstIndex(of: "\n") {
+            lines.append(String(partial[..<i]).replacingOccurrences(of: "\r", with: ""))
+            partial = String(partial[partial.index(after: i)...])
+        }
+        return lines
+    }
+
+    /// The partial last line, if any, when the output ends without a newline.
+    package func flush() -> String? {
+        guard !partial.isEmpty else { return nil }
+        defer { partial = "" }
+        return partial
+    }
+
+    /// Empties the log and drops a partial line: a new build or a stopped one starts clean.
+    package func clear() {
+        text = ""
+        partial = ""
+    }
+
+    /// Replaces the text (tests set a log to classify).
+    package func set(_ s: String) { text = s }
+
+    /// Runs `body` as the main actor's. `BuildModel` is not `@MainActor` yet and every call that reaches the log runs on the
+    /// main queue already (pipe output is hopped over, the rest is UI actions). This is `MainActor.assumeIsolated` for
+    /// macOS 13. Drop it when `BuildModel` is `@MainActor`.
+    nonisolated package static func onMain<T>(_ body: @MainActor () -> T) -> T {
+        dispatchPrecondition(condition: .onQueue(.main))
+        typealias Plain = () -> T
+        return withoutActuallyEscaping(body) { unsafeBitCast($0, to: Plain.self)() }
+    }
+}

frontend/Tests/NX2AppleTests/BuildLogTests.swift

@@ -0,0 +1,84 @@
+import Combine
+import XCTest
+@testable import NXModel
+
+/// LNPANDY/NX2Apple#387, step 3: the build log is a store of its own and needs no SwiftUI.
+@MainActor final class BuildLogTests: XCTestCase {
+    func testAppendAddsText() {
+        let log = BuildLog()
+        log.append("one\n")
+        log.append("two\n")
+        XCTAssertEqual(log.text, "one\ntwo\n")
+    }
+
+    func testTheTextKeepsItsTail() {
+        let log = BuildLog()
+        let line = String(repeating: "x", count: 99) + "\n"   // 100 characters
+        for n in 0..<150 { log.append(n == 149 ? "last\n" : line) }
+        XCTAssertLessThanOrEqual(log.text.count, BuildLog.limit)
+        XCTAssertGreaterThanOrEqual(log.text.count, BuildLog.keep)
+        XCTAssertTrue(log.text.hasSuffix("last\n"), "the newest text stays")
+    }
+
+    func testTextUnderTheLimitIsKept() {
+        let log = BuildLog()
+        log.append(String(repeating: "y", count: BuildLog.limit))
+        XCTAssertEqual(log.text.count, BuildLog.limit)
+    }
+
+    func testFeedReturnsCompleteLines() {
+        let log = BuildLog()
+        XCTAssertEqual(log.feed("a\nb\n"), ["a", "b"])
+        XCTAssertNil(log.flush())
+    }
+
+    func testALineAcrossChunkBoundariesIsJoined() {
+        let log = BuildLog()
+        XCTAssertEqual(log.feed("hel"), [])
+        XCTAssertEqual(log.feed("lo wor"), [])
+        XCTAssertEqual(log.feed("ld\nnext"), ["hello world"])
+        XCTAssertEqual(log.feed("\n"), ["next"])
+    }
+
+    func testCarriageReturnsAreDropped() {
+        let log = BuildLog()
+        // A "\r" inside a line goes, as before. ("\r\n" is one Character in Swift, so it never matches "\n": the old code
+        // had the same gap, and the script's output has plain "\n".)
+        XCTAssertEqual(log.feed("a\rb\nc"), ["ab"])
+        XCTAssertEqual(log.flush(), "c")
+    }
+
+    func testFlushReturnsThePartialLineOnce() {
+        let log = BuildLog()
+        _ = log.feed("done\nno newline")
+        XCTAssertEqual(log.flush(), "no newline")
+        XCTAssertNil(log.flush())
+    }
+
+    func testFeedDoesNotTouchTheText() {
+        let log = BuildLog()
+        _ = log.feed("a\nb\n")
+        XCTAssertEqual(log.text, "")
+    }
+
+    func testClearEmptiesTheTextAndThePartialLine() {
+        let log = BuildLog()
+        log.append("old\n")
+        _ = log.feed("half")
+        log.clear()
+        XCTAssertEqual(log.text, "")
+        XCTAssertNil(log.flush())
+        XCTAssertEqual(log.feed("new\n"), ["new"])
+    }
+
+    func testOnlyTheTextPublishes() {
+        let log = BuildLog()
+        var changes = 0
+        let sink = log.objectWillChange.sink { changes += 1 }
+        _ = log.feed("a\nb")
+        XCTAssertEqual(changes, 0, "splitting lines is not a change of the text")
+        log.append("a\n")
+        XCTAssertEqual(changes, 1)
+        sink.cancel()
+    }
+}

frontend/Tests/NX2AppleTests/LauncherPerformanceTests.swift

@@ -159,6 +159,14 @@ final class LauncherPerformanceTests: XCTestCase {
                         cards: 120, fonts: 20, plistReads: 110, busyMs: 800),
             Interaction(name: "open Manage", action: { pad.perform(.y) }, undo: { pad.perform(.b) },
                         cards: 180, fonts: 20, plistReads: 180, busyMs: 400),
+            // A build writes its log while the player looks at the library. The log is its own store (#387), so no game card
+            // is built for it. Each line is its own turn of the run loop, as the pipe delivers them.
+            Interaction(name: "1000 log lines in a build", action: {
+                for n in 0..<1000 {
+                    model.ingest("[12:00:\(String(format: "%02d", n % 60))] line \(n) of the build script's output\n")
+                    RunLoop.main.run(until: Date().addingTimeInterval(0.0005))
+                }
+            }, cards: 0, fonts: 20, plistReads: 10, busyMs: 1500),
         ]
         let meter = MainThreadMeter()
         defer { meter.stop() }
@@ -202,6 +210,7 @@ final class LauncherPerformanceTests: XCTestCase {
                     + "then profile the release build with the Time Profiler.", step.name, busy, step.busyMs))
             }
         }
+        XCTAssertTrue(model.log.text.contains("line 999 of the build"), "the lines reached the log")
         print(report.joined(separator: "\n"))
         for failure in failures { XCTFail(failure) }
         #endif

frontend/Tests/NX2AppleTests/SourceSizeTests.swift

@@ -7,7 +7,7 @@ final class SourceSizeTests: XCTestCase {
 
     /// Path under frontend/Sources → its line count when the limit came in. Lower the number when the file shrinks.
     private static let aboveTheLimit: [String: Int] = [
-        "NX2Apple/ContentView.swift": 3749,
+        "NX2Apple/ContentView.swift": 3730,
         "NX2Apple/LauncherView.swift": 973,
         "NXCore/Localization.swift": 4237,
     ]