Phase 5: Nachladen, Startseiten-Layout

Nachladen
- DownloadRefiller wählt aus, WELCHE Folgen fehlen; wie viele, rechnet
  die Regel-Engine. Getrennt, weil das Rechnen ohne Server auskommt und
  damit prüfbar ist.
- In Ausstrahlungsreihenfolge, Specials in Staffel 0 bleiben außen vor.
- Läuft nach dem Ansehen und beim Start, nicht auf einem Zeitgeber: eine
  App, die im Hintergrund unaufgefordert Gigabytes lädt, wäre eine
  unangenehme Überraschung auf der Mobilfunkrechnung.

Startseiten-Layout
- Reihen ein-/ausblenden und per Bearbeiten-Modus umsortieren.
- Die Anordnungslogik liegt als HubArrangement in PlexKit statt im
  App-Target — dort ist sie ohne Simulator testbar, und dort sitzen die
  unangenehmen Fälle: neue Reihen vom Server landen am Ende statt zu
  verschwinden, verschwundene aus der gespeicherten Liste stören nicht,
  ein doppelter Eintrag stürzt nicht ab. 11 Tests.

126 Tests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/FlixyKit/Sources/PlexKit/Models/HubArrangement.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+/// Wie die Reihen der Startseite angeordnet werden.
+///
+/// Reine Rechnung ohne Speicher und ohne Oberfläche — die Stelle, an der die
+/// zwei unangenehmen Fälle entschieden werden: was mit Reihen geschieht, die
+/// der Server neu liefert, und was mit gespeicherten, die es nicht mehr gibt.
+public struct HubArrangement: Sendable, Equatable {
+    /// Ausdrücklich ausgeblendete Reihen.
+    public var hidden: Set<String>
+    /// Die gewünschte Reihenfolge. Reihen, die hier fehlen, landen am Ende.
+    public var order: [String]
+
+    public init(hidden: Set<String> = [], order: [String] = []) {
+        self.hidden = hidden
+        self.order = order
+    }
+
+    /// Wendet Auswahl und Reihenfolge an.
+    ///
+    /// Unbekannte Reihen landen am Ende statt zu verschwinden. Sie zu
+    /// verwerfen wäre die einfachere Regel — und der Grund dafür, dass ein
+    /// neu angelegtes Regal auf dem Server in der App nie aufgetaucht wäre.
+    public func apply(to hubs: [PlexHub]) -> [PlexHub] {
+        let visible = hubs.filter { !hidden.contains($0.hubIdentifier) }
+        guard !order.isEmpty else { return visible }
+
+        let positions = Dictionary(
+            order.enumerated().map { ($1, $0) },
+            // Ein doppelter Eintrag in der gespeicherten Reihenfolge — etwa
+            // nach einem fehlgeschlagenen Schreibvorgang — soll nicht
+            // abstürzen. Die erste Position gewinnt.
+            uniquingKeysWith: { first, _ in first }
+        )
+
+        return visible.enumerated().sorted { left, right in
+            let leftPosition = positions[left.element.hubIdentifier] ?? Int.max
+            let rightPosition = positions[right.element.hubIdentifier] ?? Int.max
+            // Bei gleicher Position — beide unbekannt — bleibt die Reihenfolge
+            // des Servers erhalten. Ohne diese Rückfalllinie wäre die
+            // Anordnung neuer Reihen zufällig.
+            if leftPosition == rightPosition { return left.offset < right.offset }
+            return leftPosition < rightPosition
+        }.map(\.element)
+    }
+
+    /// Die Liste für den Einstellungsbildschirm: gespeicherte Reihenfolge
+    /// zuerst, danach alles, was der Server sonst noch liefert.
+    ///
+    /// Gespeicherte Reihen, die es nicht mehr gibt, fallen dabei heraus — sie
+    /// anzuzeigen hieße, eine Reihe anzubieten, die nie erscheinen kann.
+    public func arrangedIdentifiers(from hubs: [PlexHub]) -> [String] {
+        var result: [String] = []
+        var seen = Set<String>()
+
+        for identifier in order
+        where !seen.contains(identifier) && hubs.contains(where: { $0.hubIdentifier == identifier }) {
+            result.append(identifier)
+            seen.insert(identifier)
+        }
+        for hub in hubs where !seen.contains(hub.hubIdentifier) {
+            result.append(hub.hubIdentifier)
+            seen.insert(hub.hubIdentifier)
+        }
+        return result
+    }
+}

Packages/FlixyKit/Tests/PlexKitTests/HubArrangementTests.swift

@@ -0,0 +1,104 @@
+import Foundation
+import Testing
+@testable import PlexKit
+
+private func hub(_ identifier: String) -> PlexHub {
+    PlexHub(hubIdentifier: identifier, title: identifier.capitalized)
+}
+
+@Suite("Anordnung der Startseiten-Reihen")
+struct HubArrangementTests {
+    private let serverHubs = [hub("continue"), hub("recent"), hub("watchlist"), hub("collections")]
+
+    @Test("Ohne Einstellungen bleibt die Reihenfolge des Servers")
+    func defaultKeepsServerOrder() {
+        let result = HubArrangement().apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["continue", "recent", "watchlist", "collections"])
+    }
+
+    @Test("Ausgeblendete Reihen verschwinden")
+    func hiddenRowsAreRemoved() {
+        let arrangement = HubArrangement(hidden: ["watchlist", "collections"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["continue", "recent"])
+    }
+
+    @Test("Die gespeicherte Reihenfolge wird angewendet")
+    func storedOrderIsApplied() {
+        let arrangement = HubArrangement(order: ["watchlist", "continue", "recent", "collections"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["watchlist", "continue", "recent", "collections"])
+    }
+
+    @Test("Neue Reihen vom Server landen am Ende statt zu verschwinden")
+    func unknownRowsAppearAtTheEnd() {
+        // Der Fall, der die einfachere Regel — nur Bekanntes anzeigen — zur
+        // Falle macht: ein neu angelegtes Regal auf dem Server wäre in der App
+        // nie aufgetaucht, ohne dass jemand den Grund gesehen hätte.
+        let arrangement = HubArrangement(order: ["recent", "continue"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
+    }
+
+    @Test("Mehrere neue Reihen behalten die Reihenfolge des Servers")
+    func multipleUnknownRowsKeepServerOrder() {
+        // Ohne stabile Rückfalllinie wäre ihre Anordnung zufällig — und
+        // änderte sich bei jedem Start.
+        let arrangement = HubArrangement(order: ["collections"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["collections", "continue", "recent", "watchlist"])
+    }
+
+    @Test("Gespeicherte Reihen, die es nicht mehr gibt, stören nicht")
+    func staleOrderEntriesAreIgnored() {
+        // Entsteht beim Löschen einer Mediathek auf dem Server.
+        let arrangement = HubArrangement(order: ["geloescht", "recent", "continue"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["recent", "continue", "watchlist", "collections"])
+    }
+
+    @Test("Ein doppelter Eintrag in der Reihenfolge stürzt nicht ab")
+    func duplicateOrderEntriesAreTolerated() {
+        // Kann nach einem abgebrochenen Schreibvorgang entstehen. Ein
+        // Dictionary aus doppelten Schlüsseln wäre ein harter Absturz.
+        let arrangement = HubArrangement(order: ["recent", "recent", "continue"])
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.first?.hubIdentifier == "recent")
+        #expect(result.count == 4)
+    }
+
+    @Test("Ausblenden und Sortieren greifen zusammen")
+    func hidingAndOrderingCombine() {
+        let arrangement = HubArrangement(
+            hidden: ["recent"],
+            order: ["collections", "recent", "continue"]
+        )
+        let result = arrangement.apply(to: serverHubs)
+        #expect(result.map(\.hubIdentifier) == ["collections", "continue", "watchlist"])
+    }
+
+    // MARK: - Die Liste für die Einstellungen
+
+    @Test("Der Einstellungsbildschirm zeigt Gespeichertes zuerst")
+    func settingsListPutsStoredFirst() {
+        let arrangement = HubArrangement(order: ["watchlist", "continue"])
+        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
+        #expect(identifiers == ["watchlist", "continue", "recent", "collections"])
+    }
+
+    @Test("Der Einstellungsbildschirm zeigt auch ausgeblendete Reihen")
+    func settingsListIncludesHidden() {
+        // Sonst ließe sich eine einmal ausgeblendete Reihe nie wieder
+        // einschalten — eine Einbahnstraße.
+        let arrangement = HubArrangement(hidden: ["recent"])
+        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
+        #expect(identifiers.contains("recent"))
+    }
+
+    @Test("Verschwundene Reihen erscheinen nicht in den Einstellungen")
+    func settingsListDropsStaleEntries() {
+        let arrangement = HubArrangement(order: ["geloescht", "recent"])
+        let identifiers = arrangement.arrangedIdentifiers(from: serverHubs)
+        #expect(!identifiers.contains("geloescht"))
+    }
+}