feat: add DictionaryStore with file watching and DictionaryCorrector

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 15:16:21 +02:00
parent 57eb455edb
commit bf731dab37
2 changed files with 198 additions and 0 deletions
@@ -0,0 +1,116 @@
+import Foundation
+import SstCore
+
+/// Owns `dictionary.txt`: reads, writes atomically, and notices edits made in another editor.
+@MainActor
+public final class DictionaryStore {
+    public static let header = """
+    # Sst woordenboek
+    # Eén invoer per regel. Een los woord is een term (voorrang bij het model).
+    # 'gehoord => schrijf' is een correctie, bijvoorbeeld: cloud code => Claude Code
+
+    """
+
+    public let fileURL: URL
+    public private(set) var file = DictionaryFile()
+    public var onChange: (() -> Void)?
+
+    private var lastText = ""
+    private var watcher: DispatchSourceFileSystemObject?
+    private var debounce: Task<Void, Never>?
+
+    public init(fileURL: URL) {
+        self.fileURL = fileURL
+    }
+
+    public var entries: [DictionaryEntry] { file.entries }
+
+    /// Reads the file; creates it with a short header when it does not exist yet.
+    public func load() throws {
+        try FileManager.default.createDirectory(
+            at: fileURL.deletingLastPathComponent(), withIntermediateDirectories: true)
+        if !FileManager.default.fileExists(atPath: fileURL.path) {
+            try Self.header.write(to: fileURL, atomically: true, encoding: .utf8)
+        }
+        let text = try String(contentsOf: fileURL, encoding: .utf8)
+        lastText = text
+        file = DictionaryFile(parsing: text)
+        onChange?()
+    }
+
+    /// Applies an edit and writes the file straight away.
+    public func apply(_ mutate: (inout DictionaryFile) -> Void) throws {
+        var updated = file
+        mutate(&updated)
+        let text = updated.serialized()
+        try text.write(to: fileURL, atomically: true, encoding: .utf8)
+        file = updated
+        lastText = text
+        onChange?()
+    }
+
+    /// Re-reads the file when its text differs from what we last wrote or read.
+    public func reloadIfChanged() {
+        guard let text = try? String(contentsOf: fileURL, encoding: .utf8), text != lastText else { return }
+        lastText = text
+        file = DictionaryFile(parsing: text)
+        onChange?()
+    }
+
+    /// Watches the folder (editors replace files instead of editing them in place).
+    public func startWatching() {
+        guard watcher == nil else { return }
+        let descriptor = open(fileURL.deletingLastPathComponent().path, O_EVTONLY)
+        guard descriptor >= 0 else { return }
+        let source = DispatchSource.makeFileSystemObjectSource(
+            fileDescriptor: descriptor, eventMask: .write, queue: .main)
+        source.setEventHandler { [weak self] in
+            MainActor.assumeIsolated { self?.scheduleReload() }
+        }
+        source.setCancelHandler { close(descriptor) }
+        source.resume()
+        watcher = source
+    }
+
+    public func stopWatching() {
+        watcher?.cancel()
+        watcher = nil
+        debounce?.cancel()
+    }
+
+    private func scheduleReload() {
+        debounce?.cancel()
+        debounce = Task { [weak self] in
+            try? await Task.sleep(for: .milliseconds(200))
+            guard !Task.isCancelled else { return }
+            self?.reloadIfChanged()
+        }
+    }
+}
+
+/// Bridges the dictionary to the controller: thread-safe, can be switched off, rebuilt when the dictionary changes.
+public final class DictionaryCorrector: TextCorrecting, @unchecked Sendable {
+    private let lock = NSLock()
+    private let knowledge: WordKnowledge
+    private var engine: CorrectionEngine
+    private var enabled = true
+
+    public init(knowledge: WordKnowledge) {
+        self.knowledge = knowledge
+        self.engine = CorrectionEngine(entries: [], knowledge: knowledge)
+    }
+
+    public func update(entries: [DictionaryEntry]) {
+        let rebuilt = CorrectionEngine(entries: entries, knowledge: knowledge)
+        lock.withLock { engine = rebuilt }
+    }
+
+    public func setEnabled(_ value: Bool) {
+        lock.withLock { enabled = value }
+    }
+
+    public func correct(_ text: String) -> CorrectionResult {
+        let (current, isOn) = lock.withLock { (engine, enabled) }
+        return isOn ? current.correct(text) : CorrectionResult(text: text, corrections: [])
+    }
+}