Preparing v0.24.0

src/modules/features/ModuleInteractiveConflictResolver.ts

@@ -0,0 +1,156 @@
+import { CANCELLED, LEAVE_TO_SUBSEQUENT, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, MISSING_OR_ERROR, type DocumentID, type FilePathWithPrefix, type diff_result } from "../../lib/src/common/types.ts";
+import { ConflictResolveModal } from "./InteractiveConflictResolving/ConflictResolveModal.ts";
+import { AbstractObsidianModule, type IObsidianModule } from "../AbstractObsidianModule.ts";
+import { displayRev, getPath, getPathWithoutPrefix } from "../../common/utils.ts";
+import { fireAndForget } from "octagonal-wheels/promises";
+
+export class ModuleInteractiveConflictResolver extends AbstractObsidianModule implements IObsidianModule {
+
+    $everyOnloadStart(): Promise<boolean> {
+        this.addCommand({
+            id: "livesync-conflictcheck",
+            name: "Pick a file to resolve conflict",
+            callback: async () => {
+                await this.pickFileForResolve();
+            },
+        })
+        this.addCommand({
+            id: "livesync-all-conflictcheck",
+            name: "Resolve all conflicted files",
+            callback: async () => {
+                await this.allConflictCheck();
+            },
+        })
+        return Promise.resolve(true);
+    }
+
+    async $anyResolveConflictByUI(filename: FilePathWithPrefix, conflictCheckResult: diff_result): Promise<boolean> {
+        this._log("Merge:open conflict dialog", LOG_LEVEL_VERBOSE);
+        const dialog = new ConflictResolveModal(this.app, filename, conflictCheckResult);
+        dialog.open();
+        const selected = await dialog.waitForResult();
+        if (selected === CANCELLED) {
+            // Cancelled by UI, or another conflict.
+            this._log(`Merge: Cancelled ${filename}`, LOG_LEVEL_INFO);
+            return false;
+        }
+        const testDoc = await this.localDatabase.getDBEntry(filename, { conflicts: true }, false, true, true);
+        if (testDoc === false) {
+            this._log(`Merge: Could not read ${filename} from the local database`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        if (!testDoc._conflicts) {
+            this._log(`Merge: Nothing to do ${filename}`, LOG_LEVEL_VERBOSE);
+            return false;
+        }
+        const toDelete = selected;
+        // const toKeep = conflictCheckResult.left.rev != toDelete ? conflictCheckResult.left.rev : conflictCheckResult.right.rev;
+        if (toDelete === LEAVE_TO_SUBSEQUENT) {
+            // Concatenate both conflicted revisions.
+            // Create a new file by concatenating both conflicted revisions.
+            const p = conflictCheckResult.diff.map((e) => e[1]).join("");
+            const delRev = testDoc._conflicts[0];
+            if (!await this.core.databaseFileAccess.storeContent(filename, p)) {
+                this._log(`Concatenated content cannot be stored:${filename}`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+            // 2. As usual, delete the conflicted revision and if there are no conflicts, write the resolved content to the storage.
+            if (await this.core.$$resolveConflictByDeletingRev(filename, delRev, "UI Concatenated") == MISSING_OR_ERROR) {
+                this._log(`Concatenated saved, but cannot delete conflicted revisions: ${filename}, (${displayRev(delRev)})`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+        } else if (typeof toDelete === "string") {
+            // Select one of the conflicted revision to delete.
+            if (await this.core.$$resolveConflictByDeletingRev(filename, toDelete, "UI Selected") == MISSING_OR_ERROR) {
+                this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+                return false;
+            }
+        } else {
+            this._log(`Merge: Something went wrong: ${filename}, (${toDelete})`, LOG_LEVEL_NOTICE);
+            return false;
+        }
+        // In here, some merge has been processed.
+        // So we have to run replication if configured.
+        // TODO: Make this is as a event request
+        if (this.settings.syncAfterMerge && !this.plugin.suspended) {
+            await this.core.$$waitForReplicationOnce();
+        }
+        // And, check it again.
+        await this.core.$$queueConflictCheck(filename);
+        return false;
+    }
+    async allConflictCheck() {
+        while (await this.pickFileForResolve());
+    }
+
+
+    async pickFileForResolve() {
+        const notes: { id: DocumentID, path: FilePathWithPrefix, dispPath: string, mtime: number }[] = [];
+        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
+            if (!("_conflicts" in doc)) continue;
+            notes.push({ id: doc._id, path: getPath(doc), dispPath: getPathWithoutPrefix(doc), mtime: doc.mtime });
+        }
+        notes.sort((a, b) => b.mtime - a.mtime);
+        const notesList = notes.map(e => e.dispPath);
+        if (notesList.length == 0) {
+            this._log("There are no conflicted documents", LOG_LEVEL_NOTICE);
+            return false;
+        }
+        const target = await this.plugin.confirm.askSelectString("File to resolve conflict", notesList);
+        if (target) {
+            const targetItem = notes.find(e => e.dispPath == target)!;
+            await this.core.$$queueConflictCheck(targetItem.path);
+            await this.core.$$waitForAllConflictProcessed();
+            return true;
+        }
+        return false;
+    }
+
+    // async resolveConflictByNewerEntry(path: FilePathWithPrefix) {
+    //     const id = await this.plugin.$$path2id(path);
+    //     const doc = await this.localDatabase.getRaw<AnyEntry>(id, { conflicts: true });
+    //     // If there is no conflict, return with false.
+    //     if (!("_conflicts" in doc) || doc._conflicts === undefined) return false;
+    //     if (doc._conflicts.length == 0) return false;
+    //     this._log(`Hidden file conflicted:${getPath(doc)}`);
+    //     const conflicts = doc._conflicts.sort((a, b) => Number(a.split("-")[0]) - Number(b.split("-")[0]));
+    //     const revA = doc._rev;
+    //     const revB = conflicts[0];
+    //     const revBDoc = await this.localDatabase.getRaw<EntryDoc>(id, { rev: revB });
+    //     // determine which revision should been deleted.
+    //     // simply check modified time
+    //     const mtimeA = ("mtime" in doc && doc.mtime) || 0;
+    //     const mtimeB = ("mtime" in revBDoc && revBDoc.mtime) || 0;
+    //     const delRev = mtimeA < mtimeB ? revA : revB;
+    //     // delete older one.
+    //     await this.localDatabase.removeRevision(id, delRev);
+    //     this._log(`Older one has been deleted:${getPath(doc)}`);
+    //     return true;
+    // }
+
+    async $allScanStat(): Promise<boolean> {
+        const notes: { path: string, mtime: number }[] = [];
+        this._log(`Checking conflicted files`, LOG_LEVEL_VERBOSE);
+        for await (const doc of this.localDatabase.findAllDocs({ conflicts: true })) {
+            if (!("_conflicts" in doc)) continue;
+            notes.push({ path: getPath(doc), mtime: doc.mtime });
+        }
+        if (notes.length > 0) {
+            this.plugin.confirm.askInPopup(`conflicting-detected-on-safety`, `Some files have been left conflicted! Press {HERE} to resolve them, or you can do it later by "Pick a file to resolve conflict`, (anchor) => {
+                anchor.text = "HERE";
+                anchor.addEventListener("click", () => {
+                    fireAndForget(() => this.allConflictCheck())
+                });
+            }
+            );
+            this._log(`Some files have been left conflicted! Please resolve them by "Pick a file to resolve conflict". The list is written in the log.`, LOG_LEVEL_VERBOSE);
+            for (const note of notes) {
+                this._log(`Conflicted: ${note.path}`);
+            }
+        } else {
+            this._log(`There are no conflicted files`, LOG_LEVEL_VERBOSE);
+        }
+        return true;
+    }
+
+}