diff --git a/macSKK/Dict.swift b/macSKK/Dict.swift index 8c4e6355..87b6af4f 100644 --- a/macSKK/Dict.swift +++ b/macSKK/Dict.swift @@ -13,6 +13,35 @@ 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") + } + } + } +} + protocol DictProtocol { /** * 辞書を引き変換候補順に返す 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 98aa5c5a..3fed74cf 100644 --- a/macSKK/FileDict.swift +++ b/macSKK/FileDict.swift @@ -216,7 +216,7 @@ enum FileDictType: Equatable { logger.log("辞書 \(self.id, privacy: .public) から \(self.entryCount) エントリ読み込みました") NotificationCenter.default.post(name: notificationNameFileDictStatus, object: StatusEvent(id: self.id, - status: .loaded(success: entryCount, failure: failedEntryCount), + status: .loaded(success: entryCount, failures: readFailures), trigger: .load)) case .failure(let error): logger.error("辞書 \(self.id, privacy: .public) の読み込みでエラーが発生しました: \(error)") @@ -324,6 +324,11 @@ enum FileDictType: Equatable { */ var failedEntryCount: Int { return searchable.failedEntryCount } + /** + * 読み込みに失敗した行。コメント行、空行は除く。 + */ + var readFailures: [DictReadFailure] { return searchable.readFailures } + // MARK: DictProtocol @MainActor func refer(_ yomi: String, option: DictReferringOption?) -> [Word] { return searchable.refer(yomi, option: option) @@ -392,8 +397,8 @@ enum FileDictType: Equatable { extension FileDict { /// 辞書の読み込み状態 enum Status { - /// 正常に読み込み済み。引数は読み込めたエントリ数と読み込みできなかった行数 - case loaded(success: Int, failure: Int) + /// 正常に読み込み済み。引数は読み込めたエントリ数と読み込めなかった行 + case loaded(success: Int, failures: [DictReadFailure]) case loading /// 無効に設定されている case disabled diff --git a/macSKK/MemoryDict.swift b/macSKK/MemoryDict.swift index b17f5fd7..52636f27 100644 --- a/macSKK/MemoryDict.swift +++ b/macSKK/MemoryDict.swift @@ -10,9 +10,9 @@ struct MemoryDict: SearchableDict, DictProtocol, Sendable { */ private(set) var entries: [String: [Word]] /** - * 読み込みに失敗した行数。コメント行、空行は除いた行数。 + * 読み込みに失敗した行。コメント行、空行は除く。 */ - private(set) var failedEntryCount: Int + private(set) var readFailures: [DictReadFailure] /** * 重複を含まない送りなしの読みの配列。最近変換したものが後に登場する。 * @@ -31,14 +31,15 @@ struct MemoryDict: SearchableDict, DictProtocol, Sendable { var okuriNashiYomis: [String] = [] var okuriAriYomis: [String] = [] var lineNumber = 0 - var failedEntryCount = 0 + var readFailures: [DictReadFailure] = [] source.enumerateLines { line, stop in lineNumber += 1 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] { @@ -52,13 +53,13 @@ struct MemoryDict: SearchableDict, 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 = okuriNashiYomis.reversed() self.okuriAriYomis = okuriAriYomis.reversed() } @@ -66,7 +67,7 @@ struct MemoryDict: SearchableDict, DictProtocol, Sendable { init(entries: [String: [Word]], saveToUserDict: Bool = true) { self.entries = entries self.saveToUserDict = saveToUserDict - failedEntryCount = 0 + readFailures = [] for yomi in entries.keys { if yomi.isOkuriAri { okuriAriYomis.append(yomi) @@ -78,15 +79,15 @@ struct MemoryDict: SearchableDict, DictProtocol, Sendable { init(okuriAriEntries: [String: [Word]], okuriNashiEntries: [String: [Word]], saveToUserDict: Bool = true) { self.entries = okuriAriEntries.merging(okuriNashiEntries) { current, _ in current } - failedEntryCount = 0 + readFailures = [] okuriAriYomis = Array(okuriAriEntries.keys) okuriNashiYomis = Array(okuriNashiEntries.keys) self.saveToUserDict = saveToUserDict } - init(entries: [String: [Word]], failedEntryCount: Int, okuriNashiYomis: [String], okuriAriYomis: [String], saveToUserDict: Bool) { + init(entries: [String: [Word]], readFailures: [DictReadFailure], okuriNashiYomis: [String], okuriAriYomis: [String], saveToUserDict: Bool) { self.entries = entries - self.failedEntryCount = failedEntryCount + self.readFailures = readFailures self.okuriNashiYomis = okuriNashiYomis self.okuriAriYomis = okuriAriYomis self.saveToUserDict = saveToUserDict @@ -97,7 +98,7 @@ struct MemoryDict: SearchableDict, DictProtocol, Sendable { nonisolated func with(saveToUserDict: Bool) -> MemoryDict { MemoryDict( entries: entries, - failedEntryCount: failedEntryCount, + readFailures: readFailures, okuriNashiYomis: okuriNashiYomis, okuriAriYomis: okuriAriYomis, saveToUserDict: saveToUserDict diff --git a/macSKK/ReadonlyMemoryDict.swift b/macSKK/ReadonlyMemoryDict.swift index 12d09959..e2080d82 100644 --- a/macSKK/ReadonlyMemoryDict.swift +++ b/macSKK/ReadonlyMemoryDict.swift @@ -24,9 +24,9 @@ struct ReadonlyMemoryDict: SearchableDict, DictProtocol, Sendable { /// 全読みの変換候補を `keys` の順に連結したもの。読みごとの範囲は `starts` で引く private let words: [Word] /** - * 読み込みに失敗した行数。コメント行、空行は除いた行数。 + * 読み込みに失敗した行。コメント行、空行は除く。 */ - let failedEntryCount: Int + let readFailures: [DictReadFailure] /// この辞書から返した変換候補をユーザー辞書に保存するかどうか let saveToUserDict: Bool @@ -34,28 +34,29 @@ struct ReadonlyMemoryDict: SearchableDict, DictProtocol, Sendable { // 読み込み中のピークメモリを抑えるためDictionaryを経由せず登場順に溜める var entries: [(yomi: String, words: [Word])] = [] var lineNumber = 0 - var failedEntryCount = 0 + var readFailures: [DictReadFailure] = [] source.enumerateLines { line, stop in lineNumber += 1 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 { entries.append((yomi: entry.yomi, words: entry.candidates)) } - } 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))") } } - self.init(table: Self.makeTable(entries: entries), failedEntryCount: failedEntryCount, saveToUserDict: saveToUserDict) + self.init(table: Self.makeTable(entries: entries), readFailures: readFailures, saveToUserDict: saveToUserDict) } init(entries: [String: [Word]], saveToUserDict: Bool = true) { - self.init(table: Self.makeTable(entries: entries.map { (yomi: $0.key, words: $0.value) }), failedEntryCount: 0, saveToUserDict: saveToUserDict) + self.init(table: Self.makeTable(entries: entries.map { (yomi: $0.key, words: $0.value) }), readFailures: [], saveToUserDict: saveToUserDict) } /// JSON形式の辞書用。 @@ -66,17 +67,17 @@ struct ReadonlyMemoryDict: SearchableDict, DictProtocol, Sendable { init(okuriAriEntries: [String: [Word]], okuriNashiEntries: [String: [Word]], saveToUserDict: Bool = true) { let entries = okuriAriEntries.map { (yomi: $0.key, words: $0.value) } + okuriNashiEntries.filter { okuriAriEntries[$0.key] == nil }.map { (yomi: $0.key, words: $0.value) } - self.init(table: Self.makeTable(entries: entries), failedEntryCount: 0, saveToUserDict: saveToUserDict) + self.init(table: Self.makeTable(entries: entries), readFailures: [], saveToUserDict: saveToUserDict) } /// ``keys``, ``starts``, ``words`` の組。 private typealias Table = (keys: [String], starts: [UInt32], words: [Word]) - private init(table: Table, failedEntryCount: Int, saveToUserDict: Bool) { + private init(table: Table, readFailures: [DictReadFailure], saveToUserDict: Bool) { self.keys = table.keys self.starts = table.starts self.words = table.words - self.failedEntryCount = failedEntryCount + self.readFailures = readFailures self.saveToUserDict = saveToUserDict } @@ -119,7 +120,7 @@ struct ReadonlyMemoryDict: SearchableDict, DictProtocol, Sendable { nonisolated func with(saveToUserDict: Bool) -> ReadonlyMemoryDict { ReadonlyMemoryDict(table: (keys: keys, starts: starts, words: words), - failedEntryCount: failedEntryCount, + readFailures: readFailures, saveToUserDict: saveToUserDict) } diff --git a/macSKK/SearchableDict.swift b/macSKK/SearchableDict.swift index 366f0cba..8386ba8c 100644 --- a/macSKK/SearchableDict.swift +++ b/macSKK/SearchableDict.swift @@ -20,11 +20,14 @@ protocol SearchableDict: Sendable { var saveToUserDict: Bool { get } /// 辞書がもっているエントリ数 var entryCount: Int { get } - /// 読み込みに失敗した行数。コメント行、空行は除いた行数。 - var failedEntryCount: Int { get } + /// 読み込みに失敗した行。コメント行、空行は除く。 + var readFailures: [DictReadFailure] { get } } extension SearchableDict { + /// 読み込みに失敗した行数。コメント行、空行は除いた行数。 + var failedEntryCount: Int { readFailures.count } + nonisolated func refer(_ yomi: String, option: DictReferringOption?) -> [Word] { if let option { switch option { diff --git a/macSKK/Settings/DictionariesView.swift b/macSKK/Settings/DictionariesView.swift index 0ef98a31..93d175fd 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: FileDict.Status) -> 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: FileDict.Status) -> 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 ed9f52d9..b1a6fbf2 100644 --- a/macSKK/Settings/SettingsViewModel.swift +++ b/macSKK/Settings/SettingsViewModel.swift @@ -853,8 +853,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/UserDict.swift b/macSKK/UserDict.swift index 907a249a..573a1ff4 100644 --- a/macSKK/UserDict.swift +++ b/macSKK/UserDict.swift @@ -315,7 +315,7 @@ enum UserDictAddSource { @MainActor private func postEditEvent(_ dict: FileDict) { NotificationCenter.default.post(name: notificationNameFileDictStatus, object: FileDict.StatusEvent(id: dict.id, - status: .loaded(success: dict.entryCount, failure: dict.failedEntryCount), + status: .loaded(success: dict.entryCount, failures: dict.readFailures), trigger: .edit)) } diff --git a/macSKK/en.lproj/Localizable.strings b/macSKK/en.lproj/Localizable.strings index 1415b891..47a5abba 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 bd9348c6..021de931 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/CloudKit/UserDictSyncRecordTests.swift b/macSKKTests/CloudKit/UserDictSyncRecordTests.swift index 7372bf14..43d0cfe5 100644 --- a/macSKKTests/CloudKit/UserDictSyncRecordTests.swift +++ b/macSKKTests/CloudKit/UserDictSyncRecordTests.swift @@ -44,7 +44,7 @@ final class UserDictSyncRecordTests: XCTestCase { func testPlaceholderRecords() { // 読みは最近変換したものが後に、変換候補は最近変換したものが前に並ぶ let dict = MemoryDict(entries: ["あ": [Word("亜"), Word("阿")], "い": [Word("井")], "かk": [Word("書")]], - failedEntryCount: 0, + readFailures: [], okuriNashiYomis: ["い", "あ"], okuriAriYomis: ["かk"], saveToUserDict: true) @@ -69,7 +69,7 @@ final class UserDictSyncRecordTests: XCTestCase { @MainActor func testApplyingOrdersReceivedFirst() async { let dict = MemoryDict(entries: ["あ": [Word("阿"), Word("亜")], "い": [Word("伊")], "う": [Word("鵜")]], - failedEntryCount: 0, + readFailures: [], okuriNashiYomis: ["う", "い", "あ"], okuriAriYomis: [], saveToUserDict: true) @@ -86,7 +86,7 @@ final class UserDictSyncRecordTests: XCTestCase { // 他の端末で「すべて同期」したときに受け取る、仮の日時の同期情報 let ceiling = UserDictSyncRecord.placeholderDateCeiling let dict = MemoryDict(entries: ["あ": [Word("亜")], "い": [Word("伊")], "か": [Word("蚊")]], - failedEntryCount: 0, + readFailures: [], okuriNashiYomis: ["か", "い", "あ"], okuriAriYomis: [], saveToUserDict: true) 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 0c456cec..d686b868 100644 --- a/macSKKTests/FileDictTests.swift +++ b/macSKKTests/FileDictTests.swift @@ -27,9 +27,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameFileDictStatus, object: nil) { notification in guard let loadEvent = notification.object as? FileDict.StatusEvent, 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,35 @@ import XCTest return true } await dict.load() + XCTAssertTrue(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: false, saveToUserDict: true) + let dictId = dict.id + let failure = DictReadFailure(lineNumber: 2, line: badLine, reason: .missingSeparator) + let loadedExpectation = expectation(forNotification: notificationNameFileDictStatus, object: nil) { notification in + guard let loadEvent = notification.object as? FileDict.StatusEvent, 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) + + dict.add(yomi: "う", word: Word("宇")) + XCTAssertEqual(dict.readFailures, [failure]) + } + 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 +97,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameFileDictStatus, object: nil) { notification in guard let loadEvent = notification.object as? FileDict.StatusEvent, 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 +120,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameFileDictStatus, object: nil) { notification in guard let loadEvent = notification.object as? FileDict.StatusEvent, 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 +146,9 @@ import XCTest } let loadedExpectation = expectation(forNotification: notificationNameFileDictStatus, object: nil) { notification in guard let loadEvent = notification.object as? FileDict.StatusEvent, 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 a21ac7d3..aa00392a 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) + 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("亜")]]) + XCTAssertEqual(dict.readFailures, []) + XCTAssertEqual(dict.failedEntryCount, 0) + } + func testParseEmptyCandidate() throws { // TODO: いまは空の変換候補をスキップしているが扱えるようにしたい let source = """ diff --git a/macSKKTests/ReadonlyMemoryDictTests.swift b/macSKKTests/ReadonlyMemoryDictTests.swift index 1e06c3a6..501e059b 100644 --- a/macSKKTests/ReadonlyMemoryDictTests.swift +++ b/macSKKTests/ReadonlyMemoryDictTests.swift @@ -42,6 +42,11 @@ final class ReadonlyMemoryDictTests: XCTestCase { """ let dict = ReadonlyMemoryDict(dictId: "testDict", source: source) XCTAssertEqual(dict.failedEntryCount, 2) + XCTAssertEqual(dict.readFailures, [ + DictReadFailure(lineNumber: 2, line: "不正な行", reason: .missingSeparator), + DictReadFailure(lineNumber: 3, line: "い い /胃/", reason: .spaceInYomi), + ]) + XCTAssertEqual(dict.with(saveToUserDict: false).readFailures, dict.readFailures) XCTAssertEqual(dict.entryCount, 2) XCTAssertEqual(dict.okuriNashiYomis, ["あ", "う"]) }