Merge pull request #3373 from obsidian-tasks-group/refactor-identicalTo

refactor: Provide consistent identicalTo() methods

Author: claremacrae

src/Scripting/TasksFile.ts

@@ -221,4 +221,18 @@ export class TasksFile {
             return lowerCaseSearchKey === lowerCaseKey;
         });
     }
+
+    /**
+     * Compare all the fields in another TasksFile, to detect any differences from this one.
+     *
+     * If any field is different in any way, it will return false.
+     *
+     * @param other
+     */
+    public identicalTo(other: TasksFile) {
+        if (this.path !== other.path) {
+            return false;
+        }
+        return this.rawFrontmatterIdenticalTo(other);
+    }
 }

src/Task/ListItem.ts

@@ -135,24 +135,17 @@ export class ListItem {
             return false;
         }
 
-        // Note: sectionStart changes every time a line is added or deleted before
+        // Note: taskLocation changes every time a line is added or deleted before
         //       any of the tasks in a file. This does mean that redrawing of tasks blocks
         //       happens more often than is ideal.
-        const args: Array<keyof ListItem> = [
-            'originalMarkdown',
-            'description',
-            'statusCharacter',
-            'path',
-            'lineNumber',
-            'sectionStart',
-            'sectionIndex',
-            'precedingHeader',
-        ];
+        const args: Array<keyof ListItem> = ['description', 'statusCharacter', 'indentation', 'listMarker'];
 
         for (const el of args) {
             if (this[el]?.toString() !== other[el]?.toString()) return false;
         }
 
+        if (!this.taskLocation.identicalTo(other.taskLocation)) return false;
+
         return ListItem.listsAreIdentical(this.children, other.children);
     }
 

src/Task/Task.ts

@@ -41,9 +41,6 @@ interface TaskComponents {
 export class Task extends ListItem {
     // NEW_TASK_FIELD_EDIT_REQUIRED
     public readonly status: Status;
-    public readonly description: string;
-    public readonly indentation: string;
-    public readonly listMarker: string;
 
     public readonly tags: string[];
 
@@ -128,9 +125,6 @@ export class Task extends ListItem {
         });
         // NEW_TASK_FIELD_EDIT_REQUIRED
         this.status = status;
-        this.description = description;
-        this.indentation = indentation;
-        this.listMarker = listMarker;
 
         this.tags = tags;
 
@@ -784,9 +778,6 @@ export class Task extends ListItem {
         //       any of the tasks in a file. This does mean that redrawing of tasks blocks
         //       happens more often than is ideal.
         let args: Array<keyof Task> = [
-            'description',
-            'indentation',
-            'listMarker',
             'priority',
             'blockLink',
             'scheduledDateIsInferred',

src/Task/TaskLocation.ts

@@ -90,4 +90,23 @@ export class TaskLocation {
         const { _tasksFile, ...rest } = { ...this };
         return rest;
     }
+
+    /**
+     * Compare all the fields in another TaskLocation, to detect any differences from this one.
+     *
+     * If any field is different in any way, it will return false.
+     *
+     * @param other
+     */
+    public identicalTo(other: TaskLocation) {
+        const args: Array<keyof TaskLocation> = ['lineNumber', 'sectionStart', 'sectionIndex', 'precedingHeader'];
+
+        for (const el of args) {
+            if (this[el] !== other[el]) return false;
+        }
+
+        // We do this at the end because TasksFile objects are more expensive
+        // to compare, due to their storing potentially complext Properties data.
+        return this._tasksFile.identicalTo(other._tasksFile);
+    }
 }

tests/Scripting/TasksFile.test.ts

@@ -323,3 +323,26 @@ describe('TasksFile - properties', () => {
         expect(tasksFile.property('capital_property')).toEqual('some value');
     });
 });
+
+describe('TasksFile - identicalTo', () => {
+    const path = 'a/b/c/d.md';
+    const cachedMetadata = {};
+
+    it('should detect identical objects', () => {
+        const lhs = new TasksFile(path, cachedMetadata);
+        const rhs = new TasksFile(path, cachedMetadata);
+        expect(lhs.identicalTo(rhs)).toEqual(true);
+    });
+
+    it('should check path', () => {
+        const lhs = new TasksFile(path, cachedMetadata);
+        const rhs = new TasksFile('somewhere else.md', cachedMetadata);
+        expect(lhs.identicalTo(rhs)).toEqual(false);
+    });
+
+    it('should check cachedMetadata', () => {
+        const lhs = getTasksFileFromMockData(example_kanban);
+        expect(lhs.identicalTo(getTasksFileFromMockData(example_kanban))).toEqual(true);
+        expect(lhs.identicalTo(getTasksFileFromMockData(jason_properties))).toEqual(false);
+    });
+});

tests/Task/ListItem.test.ts

@@ -247,14 +247,28 @@ describe('identicalTo', () => {
         expect(item2.identicalTo(item1)).toEqual(false);
     });
 
+    it('should recognise different indentation', () => {
+        const item1 = ListItem.fromListItemLine('- item', null, taskLocation);
+        const item2 = ListItem.fromListItemLine('    - item', null, taskLocation);
+
+        expect(item2.identicalTo(item1)).toEqual(false);
+    });
+
+    it('should recognise different listMarker', () => {
+        const item1 = ListItem.fromListItemLine('- item', null, taskLocation);
+        const item2 = ListItem.fromListItemLine('* item', null, taskLocation);
+
+        expect(item2.identicalTo(item1)).toEqual(false);
+    });
+
     it('should recognise ListItem and Task as different', () => {
         const listItem = ListItem.fromListItemLine('- [ ] description', null, taskLocation);
         const task = fromLine({ line: '- [ ] description' });
 
         expect(listItem.identicalTo(task)).toEqual(false);
     });
 
-    it('should recognise different path', () => {
+    it('should recognise different taskLocation', () => {
         const item1 = ListItem.fromListItemLine(
             '- same',
             null,

tests/Task/TaskLocation.test.ts

@@ -75,3 +75,52 @@ describe('TaskLocation', () => {
         expect(TaskLocation.fromUnknownPosition(new TasksFile('')).hasKnownPath).toBe(false);
     });
 });
+
+describe('TaskLocation - identicalTo', function () {
+    const tasksFile: TasksFile = new TasksFile('x.md');
+    const lineNumber: number = 40;
+    const sectionStart: number = 30;
+    const sectionIndex: number = 3;
+    const precedingHeader: string | null = 'heading';
+
+    const lhs = new TaskLocation(tasksFile, lineNumber, sectionStart, sectionIndex, precedingHeader);
+
+    it('should detect identical objects', () => {
+        const rhs = new TaskLocation(tasksFile, lineNumber, sectionStart, sectionIndex, precedingHeader);
+        expect(lhs.identicalTo(rhs)).toEqual(true);
+    });
+
+    it('should check tasksFile', () => {
+        const rhs = new TaskLocation(new TasksFile('y.md'), lineNumber, sectionStart, sectionIndex, precedingHeader);
+        expect(lhs.identicalTo(rhs)).toEqual(false);
+    });
+
+    it('should check lineNumber', () => {
+        const rhs = new TaskLocation(tasksFile, 0, sectionStart, sectionIndex, precedingHeader);
+        expect(lhs.identicalTo(rhs)).toEqual(false);
+    });
+
+    it('should check sectionStart', () => {
+        const rhs = new TaskLocation(tasksFile, lineNumber, 0, sectionIndex, precedingHeader);
+        expect(lhs.identicalTo(rhs)).toEqual(false);
+    });
+
+    it('should check sectionIndex', () => {
+        const rhs = new TaskLocation(tasksFile, lineNumber, sectionStart, 0, precedingHeader);
+        expect(lhs.identicalTo(rhs)).toEqual(false);
+    });
+
+    it('should check precedingHeader', () => {
+        {
+            const precedingHeader = null;
+            const rhs = new TaskLocation(tasksFile, lineNumber, sectionStart, sectionIndex, precedingHeader);
+            expect(lhs.identicalTo(rhs)).toEqual(false);
+        }
+
+        {
+            const precedingHeader = 'different header';
+            const rhs = new TaskLocation(tasksFile, lineNumber, sectionStart, sectionIndex, precedingHeader);
+            expect(lhs.identicalTo(rhs)).toEqual(false);
+        }
+    });
+});