From 50434d3ce6a3a253f4271325641f79e872b3edd4 Mon Sep 17 00:00:00 2001 From: Matt Van Horn <455140+mvanhorn@users.noreply.github.com> Date: Sun, 4 Oct 2026 00:40:50 -0700 Subject: [PATCH] show unread dictionary lines in settings Entry.parse now returns a Result that distinguishes those three failures. MemoryDict stores each one as a DictReadFailure (line number, raw text, and reason), and DictLoadStatus.loaded carries that array on both the initial load and later edit notifications; failedEntryCount is the array length, which the existing user-dictionary notification still uses. In dictionary settings, a loaded dictionary with failures shows a button that opens a sheet listing the line number, a localized reason, and the selectable raw line, with English and Japanese strings. Fixes #503 --- macSKK/Dict.swift | 35 +++++++++- macSKK/Entry.swift | 30 +++++++-- macSKK/FileDict.swift | 6 +- macSKK/MemoryDict.swift | 29 ++++---- macSKK/Settings/DictionariesView.swift | 90 ++++++++++++++++++++++--- macSKK/Settings/SettingsViewModel.swift | 6 +- macSKK/en.lproj/Localizable.strings | 6 ++ macSKK/ja.lproj/Localizable.strings | 6 ++ macSKKTests/EntryTests.swift | 25 +++++++ macSKKTests/FileDictTests.swift | 49 +++++++++++--- macSKKTests/MemoryDictTests.swift | 29 ++++++++ 11 files changed, 268 insertions(+), 43 deletions(-) diff --git a/macSKK/Dict.swift b/macSKK/Dict.swift index 22913a2a..5107e9db 100644 --- a/macSKK/Dict.swift +++ b/macSKK/Dict.swift @@ -13,10 +13,39 @@ enum DictReferringOption { case okuri(String) } +/// 従来形式の辞書で1行を読み込めなかった内容。コメント行と空行は含まない。 +struct DictReadFailure: Equatable, Sendable { + /// 1始まりの行番号 + let lineNumber: Int + /// 読み込めなかった行の生テキスト + let line: String + let reason: Reason + + enum Reason: Error, Equatable, Sendable { + /// " /" で読みと変換候補が区切られていない + case missingSeparator + /// 読みに空白が含まれる + case spaceInYomi + /// 変換候補がスラッシュで終わっていない + case unterminatedCandidates + + var localizedDescription: String { + switch self { + case .missingSeparator: + String(localized: "DictReadFailureReasonMissingSeparator") + case .spaceInYomi: + String(localized: "DictReadFailureReasonSpaceInYomi") + case .unterminatedCandidates: + String(localized: "DictReadFailureReasonUnterminatedCandidates") + } + } + } +} + /// 辞書の読み込み状態 enum DictLoadStatus { - /// 正常に読み込み済み。引数は読み込めたエントリ数と読み込みできなかった行数 - case loaded(success: Int, failure: Int) + /// 正常に読み込み済み。引数は読み込めたエントリ数と読み込めなかった行 + case loaded(success: Int, failures: [DictReadFailure]) case loading /// 無効に設定されている case disabled @@ -31,7 +60,7 @@ struct DictLoadEvent { case load /// 変換・確定にともなう学習 (`FileDict.add`/`delete`)。 /// - /// 学習でも読み込み状態 (エントリ数) は更新されるが、失敗行数は読み込み時に一度決まる値なので、 + /// 学習でも読み込み状態 (エントリ数と失敗行) は更新されるが、失敗行は読み込み時に一度決まる値なので、 /// これを `.load` と区別しないと失敗通知が変換のたびに繰り返し出てしまう。 case edit } diff --git a/macSKK/Entry.swift b/macSKK/Entry.swift index fbc10de3..a355854d 100644 --- a/macSKK/Entry.swift +++ b/macSKK/Entry.swift @@ -27,14 +27,34 @@ struct Entry: Sendable { // コメント行 return nil } - let words = line.split(separator: " /", maxSplits: 1) - if words.count != 2 || words[0].contains(" ") { + guard case .success(let entry) = Self.parse(line: line, dictId: dictId) else { return nil } - yomi = String(words[0]).replacing("う゛", with: "ゔ") - guard let candidates = Self.parseWords(words[1], dictId: dictId) else { return nil } + self = entry + } + + /** + * SKK辞書の一行をパースする。 + * + * 読みの「う゛」は「ゔ」に変換して返す。 + * 空文字列の変換候補を含む場合、現状の実装では除外して返す。 + * コメント行は呼び出し側で除く。ここが失敗するのは区切りがない、読みに空白がある、 + * 変換候補がスラッシュで終わっていない、の3つ。 + */ + static func parse(line: String, dictId: FileDict.ID) -> Result { + let words = line.split(separator: " /", maxSplits: 1) + if words.count != 2 { + return .failure(.missingSeparator) + } + if words[0].contains(" ") { + return .failure(.spaceInYomi) + } + let yomi = String(words[0]).replacing("う゛", with: "ゔ") + guard let candidates = parseWords(words[1], dictId: dictId) else { + return .failure(.unterminatedCandidates) + } // TODO: いまは空の変換候補をスキップしているが扱えるようにしたい - self.candidates = candidates.filter { !$0.word.isEmpty } + return .success(Entry(yomi: yomi, candidates: candidates.filter { !$0.word.isEmpty })) } init(yomi: String, candidates: [Word]) { diff --git a/macSKK/FileDict.swift b/macSKK/FileDict.swift index eee37d46..b4e5f112 100644 --- a/macSKK/FileDict.swift +++ b/macSKK/FileDict.swift @@ -160,7 +160,7 @@ enum FileDictType: Equatable { logger.log("辞書 \(self.id, privacy: .public) から \(self.dict.entries.count) エントリ読み込みました") NotificationCenter.default.post(name: notificationNameDictLoad, object: DictLoadEvent(id: self.id, - status: .loaded(success: dict.entryCount, failure: dict.failedEntryCount), + status: .loaded(success: dict.entryCount, failures: dict.readFailures), trigger: .load)) case .failure(let error): logger.error("辞書 \(self.id, privacy: .public) の読み込みでエラーが発生しました: \(error)") @@ -300,7 +300,7 @@ enum FileDictType: Equatable { dict.add(yomi: yomi, word: word) NotificationCenter.default.post(name: notificationNameDictLoad, object: DictLoadEvent(id: self.id, - status: .loaded(success: dict.entryCount, failure: dict.failedEntryCount), + status: .loaded(success: dict.entryCount, failures: dict.readFailures), trigger: .edit)) hasUnsavedChanges = true } @@ -310,7 +310,7 @@ enum FileDictType: Equatable { hasUnsavedChanges = true NotificationCenter.default.post(name: notificationNameDictLoad, object: DictLoadEvent(id: self.id, - status: .loaded(success: dict.entryCount, failure: dict.failedEntryCount), + status: .loaded(success: dict.entryCount, failures: dict.readFailures), trigger: .edit)) return true } diff --git a/macSKK/MemoryDict.swift b/macSKK/MemoryDict.swift index 9d5f7369..d91675ce 100644 --- a/macSKK/MemoryDict.swift +++ b/macSKK/MemoryDict.swift @@ -15,10 +15,14 @@ struct MemoryDict: DictProtocol, Sendable { * 辞書のエントリ一覧。キーは読み、値は変換候補 (優先度の高い順) */ private(set) var entries: [String: [Word]] + /** + * 読み込みに失敗した行。コメント行、空行は除く。 + */ + private(set) var readFailures: [DictReadFailure] /** * 読み込みに失敗した行数。コメント行、空行は除いた行数。 */ - private(set) var failedEntryCount: Int + var failedEntryCount: Int { readFailures.count } /** * 重複を含まない送りなしの読みの配列。 * 読み込み専用の場合は辞書順、そうでないときは最近変換したものが後に登場する。 @@ -40,7 +44,7 @@ struct MemoryDict: DictProtocol, Sendable { var okuriNashiYomis: [String] = [] var okuriAriYomis: [String] = [] var lineNumber = 0 - var failedEntryCount = 0 + var readFailures: [DictReadFailure] = [] // readonlyのときはokuriAriYomisがソート済みかどうかを判定する var okuriNashiSorted = readonly @@ -49,7 +53,8 @@ struct MemoryDict: DictProtocol, Sendable { if line.isEmpty || line.hasPrefix(";") { return } - if let entry = Entry(line: line, dictId: dictId) { + switch Entry.parse(line: line, dictId: dictId) { + case .success(let entry): // 空文字列への変換候補をもつ場合、entry.candidatesは空になっているのでスキップする if !entry.candidates.isEmpty { if let candidates = dict[entry.yomi] { @@ -66,13 +71,13 @@ struct MemoryDict: DictProtocol, Sendable { okuriNashiYomis.append(entry.yomi) } } - } else { - failedEntryCount += 1 - logger.warning("辞書 \(dictId, privacy: .public) の読み込みで \(lineNumber)行目を正常に読み込めなかったためこの行をスキップします") + case .failure(let reason): + readFailures.append(DictReadFailure(lineNumber: lineNumber, line: line, reason: reason)) + logger.warning("辞書 \(dictId, privacy: .public) の読み込みで \(lineNumber)行目を正常に読み込めなかったためこの行をスキップします (\(String(describing: reason), privacy: .public))") } } entries = dict - self.failedEntryCount = failedEntryCount + self.readFailures = readFailures self.okuriNashiYomis = if readonly { if okuriNashiSorted { okuriNashiYomis @@ -89,7 +94,7 @@ struct MemoryDict: DictProtocol, Sendable { self.readonly = readonly self.entries = entries self.saveToUserDict = saveToUserDict - failedEntryCount = 0 + readFailures = [] for yomi in entries.keys { if yomi.isOkuriAri { okuriAriYomis.append(yomi) @@ -105,16 +110,16 @@ struct MemoryDict: DictProtocol, Sendable { init(okuriAriEntries: [String: [Word]], okuriNashiEntries: [String: [Word]], readonly: Bool, saveToUserDict: Bool = true) { self.readonly = readonly self.entries = okuriAriEntries.merging(okuriNashiEntries) { current, _ in current } - failedEntryCount = 0 + readFailures = [] okuriAriYomis = Array(okuriAriEntries.keys) okuriNashiYomis = Array(okuriNashiEntries.keys) self.saveToUserDict = saveToUserDict } - init(readonly: Bool, entries: [String: [Word]], failedEntryCount: Int, okuriNashiYomis: [String], okuriAriYomis: [String], saveToUserDict: Bool) { + init(readonly: Bool, entries: [String: [Word]], readFailures: [DictReadFailure], okuriNashiYomis: [String], okuriAriYomis: [String], saveToUserDict: Bool) { self.readonly = readonly self.entries = entries - self.failedEntryCount = failedEntryCount + self.readFailures = readFailures self.okuriNashiYomis = okuriNashiYomis self.okuriAriYomis = okuriAriYomis self.saveToUserDict = saveToUserDict @@ -126,7 +131,7 @@ struct MemoryDict: DictProtocol, Sendable { MemoryDict( readonly: readonly, entries: entries, - failedEntryCount: failedEntryCount, + readFailures: readFailures, okuriNashiYomis: okuriNashiYomis, okuriAriYomis: okuriAriYomis, saveToUserDict: saveToUserDict diff --git a/macSKK/Settings/DictionariesView.swift b/macSKK/Settings/DictionariesView.swift index b6d34df9..332de60d 100644 --- a/macSKK/Settings/DictionariesView.swift +++ b/macSKK/Settings/DictionariesView.swift @@ -7,16 +7,21 @@ struct DictionariesView: View { @ObservedObject var settingsViewModel: SettingsViewModel @State private var selectedDictSetting: DictSetting? @State var isShowingSkkservSheet: Bool = false + @State private var presentedReadFailures: [DictReadFailure] = [] + @State private var isShowingReadFailures = false var body: some View { VStack { Form { Section { - VStack(alignment: .leading, spacing: 2) { - Text(UserDict.userDictFilename) - .font(.body) - Text(loadingStatus(of: settingsViewModel.userDictLoadingStatus)) - .font(.footnote) + HStack(alignment: .top) { + VStack(alignment: .leading, spacing: 2) { + Text(UserDict.userDictFilename) + .font(.body) + Text(loadingStatus(of: settingsViewModel.userDictLoadingStatus)) + .font(.footnote) + } + readFailureButton(status: settingsViewModel.userDictLoadingStatus) } } header: { Text("SettingsNameUserDictTitle") @@ -55,6 +60,7 @@ struct DictionariesView: View { } } .toggleStyle(.switch) + readFailureButton(setting: dictSetting.wrappedValue) Button { selectedDictSetting = dictSetting.wrappedValue } label: { @@ -94,6 +100,9 @@ struct DictionariesView: View { saveToUserDict: dictSetting.saveToUserDict, ) } + .sheet(isPresented: $isShowingReadFailures) { + DictReadFailuresSheet(failures: presentedReadFailures) + } .sheet(isPresented: $isShowingSkkservSheet) { SKKServDictView(settingsViewModel: settingsViewModel, isShowSheet: $isShowingSkkservSheet, @@ -117,13 +126,34 @@ struct DictionariesView: View { } } + @ViewBuilder + private func readFailureButton(status: DictLoadStatus) -> some View { + if case .loaded(_, let failures) = status, !failures.isEmpty { + Button { + presentedReadFailures = failures + isShowingReadFailures = true + } label: { + Text("DictReadFailureShow") + } + .buttonStyle(.borderless) + .controlSize(.small) + } + } + + @ViewBuilder + private func readFailureButton(setting: DictSetting) -> some View { + if setting.enabled, let status = settingsViewModel.dictLoadingStatuses[setting.id] { + readFailureButton(status: status) + } + } + private func loadingStatus(of status: DictLoadStatus) -> String { switch status { - case .loaded(success: let entryCount, failure: let failureCount): - if failureCount == 0 { + case .loaded(success: let entryCount, failures: let failures): + if failures.isEmpty { return String(localized: "LoadingStatusLoaded \(entryCount)") } else { - return String(localized: "LoadingStatusLoaded \(entryCount) WithError \(failureCount)") + return String(localized: "LoadingStatusLoaded \(entryCount) WithError \(failures.count)") } case .loading: return String(localized: "LoadingStatusLoading") @@ -135,6 +165,43 @@ struct DictionariesView: View { } } +private struct DictReadFailuresSheet: View { + let failures: [DictReadFailure] + @Environment(\.dismiss) private var dismiss + + var body: some View { + VStack { + Text("DictReadFailureTitle") + .font(.headline) + .padding(.top) + List(failures, id: \.lineNumber) { failure in + VStack(alignment: .leading, spacing: 2) { + Text("DictReadFailureLine \(failure.lineNumber)") + .font(.headline) + Text(failure.reason.localizedDescription) + .font(.subheadline) + Text(failure.line) + .font(.body.monospaced()) + .textSelection(.enabled) + } + .padding(.vertical, 2) + } + HStack { + Spacer() + Button { + dismiss() + } label: { + Text("Done") + .padding([.leading, .trailing]) + } + .keyboardShortcut(.defaultAction) + .padding([.trailing, .bottom, .top]) + } + } + .frame(width: 480, height: 320) + } +} + struct DictionariesView_Previews: PreviewProvider { enum DictionariesViewPreviewError: Error { case dummy @@ -148,8 +215,13 @@ struct DictionariesView_Previews: PreviewProvider { DictSetting(filename: "SKK-JISYO.error", enabled: true, type: .traditional(.utf8), saveToUserDict: true), ] let settings = try! SettingsViewModel(dictSettings: dictSettings) + settings.userDictLoadingStatus = .loaded(success: 10, failures: [ + DictReadFailure(lineNumber: 4, line: "い /胃", reason: .unterminatedCandidates), + ]) settings.dictLoadingStatuses = [ - "SKK-JISYO.L": .loaded(success: 123456, failure: 789), + "SKK-JISYO.L": .loaded(success: 123456, failures: [ + DictReadFailure(lineNumber: 12, line: "い/胃/", reason: .missingSeparator), + ]), "SKK-JISYO.sample.utf-8": .disabled, "SKK-JISYO.dummy": .loading, "SKK-JISYO.error": .fail(DictionariesViewPreviewError.dummy) diff --git a/macSKK/Settings/SettingsViewModel.swift b/macSKK/Settings/SettingsViewModel.swift index 58cac7ca..26542c51 100644 --- a/macSKK/Settings/SettingsViewModel.swift +++ b/macSKK/Settings/SettingsViewModel.swift @@ -231,7 +231,7 @@ final class SettingsViewModel: ObservableObject { init( dictionariesDirectoryUrl: URL, - keyValueStore: any KeyValueStore? = SettingsSync.defaultStore, + keyValueStore: (any KeyValueStore)? = SettingsSync.defaultStore, notifyRemoteSettingsApplied: @escaping (Set) -> Void = UNNotifier.sendNotificationForSettingsSynced ) throws { self.dictionariesDirectoryUrl = dictionariesDirectoryUrl @@ -830,8 +830,8 @@ final class SettingsViewModel: ObservableObject { if loadEvent.trigger == .load { if case .fail(let error) = loadEvent.status { UNNotifier.sendNotificationForUserDict(readError: error) - } else if case .loaded(_, let failureCount) = loadEvent.status, failureCount > 0 { - UNNotifier.sendNotificationForUserDict(failureEntryCount: failureCount) + } else if case .loaded(_, let failures) = loadEvent.status, failures.count > 0 { + UNNotifier.sendNotificationForUserDict(failureEntryCount: failures.count) } } } else { diff --git a/macSKK/en.lproj/Localizable.strings b/macSKK/en.lproj/Localizable.strings index 30c1a11b..3ca23e81 100644 --- a/macSKK/en.lproj/Localizable.strings +++ b/macSKK/en.lproj/Localizable.strings @@ -38,6 +38,12 @@ "LoadingStatusError %@" = "Error: %@"; "LoadingStatusDisabled" = "Disabled"; "LoadingStatusUnknown" = "Unknown"; +"DictReadFailureShow" = "Show unread lines"; +"DictReadFailureTitle" = "Unread lines"; +"DictReadFailureLine %lld" = "Line %lld"; +"DictReadFailureReasonMissingSeparator" = "No separator between the reading and candidates"; +"DictReadFailureReasonSpaceInYomi" = "The reading contains a space"; +"DictReadFailureReasonUnterminatedCandidates" = "Candidates are not terminated with a slash"; "SKKServDictTitle" = "SKKServ Dictionary Setting"; "SKKServDictTesting" = "Testing to connect to skkserv…"; "SKKServDictReferTestTitle" = "SKKServ Dictionary Referring Test"; diff --git a/macSKK/ja.lproj/Localizable.strings b/macSKK/ja.lproj/Localizable.strings index 9ed59606..0c4619be 100644 --- a/macSKK/ja.lproj/Localizable.strings +++ b/macSKK/ja.lproj/Localizable.strings @@ -38,6 +38,12 @@ "LoadingStatusError %@" = "エラー: %@"; "LoadingStatusDisabled" = "無効"; "LoadingStatusUnknown" = "不明"; +"DictReadFailureShow" = "読み込めなかった行を表示"; +"DictReadFailureTitle" = "読み込めなかった行"; +"DictReadFailureLine %lld" = "%lld行目"; +"DictReadFailureReasonMissingSeparator" = "読みと変換候補の間に区切りがありません"; +"DictReadFailureReasonSpaceInYomi" = "読みに空白が含まれています"; +"DictReadFailureReasonUnterminatedCandidates" = "変換候補がスラッシュで終わっていません"; "SKKServDictTitle" = "SKKServ辞書の設定"; "SKKServDictTesting" = "SKKServへの接続テスト中…"; "SKKServDictReferTestTitle" = "SKKServ辞書の参照テスト"; diff --git a/macSKKTests/EntryTests.swift b/macSKKTests/EntryTests.swift index ab424f00..b86c51f7 100644 --- a/macSKKTests/EntryTests.swift +++ b/macSKKTests/EntryTests.swift @@ -68,10 +68,35 @@ final class EntryTests: XCTestCase { XCTAssertNil(Entry(line: "", dictId: "")) XCTAssertNil(Entry(line: ";こめんと /コメント/", dictId: "")) XCTAssertNil(Entry(line: "い/胃/", dictId: ""), "読みと変換候補の間にスペースがない") + if case .failure(let reason) = Entry.parse(line: "い/胃/", dictId: "") { + XCTAssertEqual(reason, .missingSeparator) + } else { + XCTFail("読みと変換候補の間にスペースがない") + } XCTAssertNil(Entry(line: "い /胃/", dictId: ""), "読みと変換候補の間にスペースが2つある") + if case .failure(let reason) = Entry.parse(line: "い /胃/", dictId: "") { + XCTAssertEqual(reason, .spaceInYomi) + } else { + XCTFail("読みと変換候補の間にスペースが2つある") + } XCTAssertNil(Entry(line: "い /胃/意", dictId: ""), "末尾がスラッシュで終わらない") + if case .failure(let reason) = Entry.parse(line: "い /胃/意", dictId: "") { + XCTAssertEqual(reason, .unterminatedCandidates) + } else { + XCTFail("末尾がスラッシュで終わらない") + } XCTAssertNil(Entry(line: "いt /[った/行]/", dictId: ""), "送り仮名ブロックの変換候補の末尾にスラッシュがない") + if case .failure(let reason) = Entry.parse(line: "いt /[った/行]/", dictId: "") { + XCTAssertEqual(reason, .unterminatedCandidates) + } else { + XCTFail("送り仮名ブロックの変換候補の末尾にスラッシュがない") + } XCTAssertNil(Entry(line: "い いt /行/", dictId: ""), "読みが複数ある") + if case .failure(let reason) = Entry.parse(line: "い いt /行/", dictId: "") { + XCTAssertEqual(reason, .spaceInYomi) + } else { + XCTFail("読みが複数ある") + } } func testIgnoreDuplicated() { diff --git a/macSKKTests/FileDictTests.swift b/macSKKTests/FileDictTests.swift index dbfc9934..3e5819e4 100644 --- a/macSKKTests/FileDictTests.swift +++ b/macSKKTests/FileDictTests.swift @@ -27,9 +27,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, - case .loaded(let loadCount, let failureCount) = loadEvent.status else { return false } + case .loaded(let loadCount, let failures) = loadEvent.status else { return false } XCTAssertEqual(loadCount, 3) - XCTAssertEqual(failureCount, 0) + XCTAssertEqual(failures, []) XCTAssertEqual(loadEvent.trigger, .load, "ファイル読み込みの通知はすべて .load であるべき") return true } @@ -56,9 +56,42 @@ import XCTest return true } await dict.load() + XCTAssertTrue(dict.dict.readFailures.isEmpty) await fulfillment(of: [loadingExpectation, failExpectation], timeout: 1.0, enforceOrder: true) } + func testLoadBadLineSurvivesEdit() async throws { + let fileURL = FileManager.default.temporaryDirectory + .appendingPathComponent("macSKK-unread-\(UUID().uuidString).txt") + let badLine = "い/胃/" + try "あ /亜/\n\(badLine)\n".write(to: fileURL, atomically: true, encoding: .utf8) + defer { try? FileManager.default.removeItem(at: fileURL) } + + let dict = try FileDict(contentsOf: fileURL, type: .traditional(.utf8), readonly: true, saveToUserDict: true) + let dictId = dict.id + let failure = DictReadFailure(lineNumber: 2, line: badLine, reason: .missingSeparator) + let loadedExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in + guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, + case .loaded(let loadCount, let failures) = loadEvent.status, + loadEvent.trigger == .load else { return false } + XCTAssertEqual(loadCount, 1) + XCTAssertEqual(failures, [failure]) + return true + } + await dict.load() + await fulfillment(of: [loadedExpectation], timeout: 1.0) + + let editExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in + guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, + case .loaded(_, let failures) = loadEvent.status else { return false } + XCTAssertEqual(loadEvent.trigger, .edit) + XCTAssertEqual(failures, [failure]) + return true + } + dict.add(yomi: "う", word: Word("宇")) + await fulfillment(of: [editExpectation], timeout: 1.0) + } + func testLoadGzippedTraditional() async throws { let fileURL = try XCTUnwrap(Bundle(for: Self.self).url(forResource: "SKK-JISYO.test", withExtension: "utf8.gz")) let dict = try FileDict(contentsOf: fileURL, type: .traditional(.utf8), readonly: true, saveToUserDict: true) @@ -71,9 +104,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, - case .loaded(let loadCount, let failureCount) = loadEvent.status else { return false } + case .loaded(let loadCount, let failures) = loadEvent.status else { return false } XCTAssertEqual(loadCount, 1) - XCTAssertEqual(failureCount, 0) + XCTAssertEqual(failures, []) XCTAssertEqual(loadEvent.trigger, .load, "ファイル読み込みの通知はすべて .load であるべき") return true } @@ -94,9 +127,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, - case .loaded(let loadCount, let failureCount) = loadEvent.status else { return false } + case .loaded(let loadCount, let failures) = loadEvent.status else { return false } XCTAssertEqual(loadCount, 3) - XCTAssertEqual(failureCount, 0) + XCTAssertEqual(failures, []) XCTAssertEqual(loadEvent.trigger, .load, "ファイル読み込みの通知はすべて .load であるべき") return true } @@ -120,9 +153,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameDictLoad, object: nil) { notification in guard let loadEvent = notification.object as? DictLoadEvent, loadEvent.id == dictId, - case .loaded(let loadCount, let failureCount) = loadEvent.status else { return false } + case .loaded(let loadCount, let failures) = loadEvent.status else { return false } XCTAssertEqual(loadCount, 1) - XCTAssertEqual(failureCount, 0) + XCTAssertEqual(failures, []) XCTAssertEqual(loadEvent.trigger, .load, "ファイル読み込みの通知はすべて .load であるべき") return true } diff --git a/macSKKTests/MemoryDictTests.swift b/macSKKTests/MemoryDictTests.swift index 66a05a38..e157225a 100644 --- a/macSKKTests/MemoryDictTests.swift +++ b/macSKKTests/MemoryDictTests.swift @@ -79,6 +79,35 @@ class MemoryDictTests: XCTestCase { XCTAssertEqual(dict.entries["いぬ"]?.first?.annotation, Annotation(dictId: "testDict", text: "かわいい")) } + func testReadFailures() { + let source = """ + あ /亜/ + ; コメント + + から // + い/胃/ + い い /行/ + い /胃 + """ + let dict = MemoryDict(dictId: "testDict", source: source, readonly: false) + XCTAssertEqual(dict.entries["あ"]?.map { $0.word }, ["亜"]) + XCTAssertNil(dict.entries["から"]) + XCTAssertEqual(dict.failedEntryCount, 3) + let failures = [ + DictReadFailure(lineNumber: 5, line: "い/胃/", reason: .missingSeparator), + DictReadFailure(lineNumber: 6, line: "い い /行/", reason: .spaceInYomi), + DictReadFailure(lineNumber: 7, line: "い /胃", reason: .unterminatedCandidates), + ] + XCTAssertEqual(dict.readFailures, failures) + XCTAssertEqual(dict.with(saveToUserDict: false).readFailures, failures) + } + + func testEntriesHaveNoReadFailures() { + let dict = MemoryDict(entries: ["あ": [Word("亜")]], readonly: true) + XCTAssertEqual(dict.readFailures, []) + XCTAssertEqual(dict.failedEntryCount, 0) + } + func testParseEmptyCandidate() throws { // TODO: いまは空の変換候補をスキップしているが扱えるようにしたい let source = """