Merge pull request #3527 from obsidian-tasks-group/fix-relative-links

feat: Add `Link.markdown` for reliable rendering of links

Author: claremacrae

resources/sample_vaults/Tasks-Demo/How To/Access links.md

@@ -50,24 +50,6 @@ limit groups 1
 ```tasks
 # Task line has a link
 filter by function task.outlinks.length > 0
-group by function task.outlinks.map(link => link.originalMarkdown).sort().join(' · ')
-limit groups 1
-```
-
-### Group by task outlinks - task outlinks that give broken group headings
-
-- Hovering over these links **in the task lines** works because of [#3357](https://github.com/obsidian-tasks-group/obsidian-tasks/pull/3357).
-- Hovering over these links **in the group headings** gives things like **Unable to find “Basic Internal Links” in Access links**
-
-```tasks
-# Task line has a link
-filter by function task.outlinks.length > 0
-
-# Task's link goes to a heading in the same file
-description includes [[#
-
-filename includes internal_heading_links
-
-group by function task.outlinks.map(link => link.originalMarkdown).sort().join(' · ')
+group by function task.outlinks.map(link => link.markdown).sort().join(' · ')
 limit groups 1
 ```

src/Scripting/TasksFile.ts

@@ -61,14 +61,14 @@ export class TasksFile {
      * Return an array of {@link Link} in the file's properties/frontmatter.
      */
     get outlinksInProperties(): Link[] {
-        return this.cachedMetadata.frontmatterLinks?.map((link) => new Link(link, this.filenameWithoutExtension)) ?? [];
+        return this.cachedMetadata.frontmatterLinks?.map((link) => new Link(link, this.path)) ?? [];
     }
 
     /**
      * Return an array of {@link Link} in the body of the file.
      */
     get outlinksInBody(): Link[] {
-        return this.cachedMetadata?.links?.map((link) => new Link(link, this.filenameWithoutExtension)) ?? [];
+        return this.cachedMetadata?.links?.map((link) => new Link(link, this.path)) ?? [];
     }
 
     /**

src/Task/Link.ts

@@ -2,43 +2,44 @@ import type { Reference } from 'obsidian';
 
 export class Link {
     private readonly rawLink: Reference;
-    private readonly filenameContainingLink: string;
+    private readonly pathContainingLink: string;
 
     /**
      * @param {Reference} rawLink - The raw link from Obsidian cache.
-     * @param {string} filenameContainingLink - The name of the file where this link is located.
+     * @param {string} pathContainingLink - The path of the file where this link is located.
      */
-    constructor(rawLink: Reference, filenameContainingLink: string) {
+    constructor(rawLink: Reference, pathContainingLink: string) {
         this.rawLink = rawLink;
-        this.filenameContainingLink = filenameContainingLink;
+        this.pathContainingLink = pathContainingLink;
     }
 
+    /**
+     * Return the original Markdown.
+     *
+     * See also {@link markdown}
+     */
     public get originalMarkdown(): string {
         return this.rawLink.original;
     }
 
-    public get destination(): string {
-        return this.rawLink.link;
-    }
-
     /**
-     * Returns the filename of the link destination without the path or alias
-     * Removes the .md extension if present leaves other extensions intact.
-     * No accommodation for empty links.
-     * @returns {string}
+     * This is like {@link originalMarkdown}, but will also work for heading-only links
+     * when viewed in files other than the one containing the original link.
+     *
+     * See also {@link originalMarkdown}
      */
-    public get destinationFilename(): string {
-        // Handle internal links (starting with '#')
-        if (this.destination.startsWith('#')) {
-            return this.filenameContainingLink;
+    public get markdown(): string {
+        if (!this.destination.startsWith('#')) {
+            // The link already has a file name, so just return it
+            return this.originalMarkdown;
         }
 
-        // Extract filename from path (handles both path and optional hash fragment)
-        const pathPart = this.destination.split('#', 1)[0];
-        const destFilename = pathPart.substring(pathPart.lastIndexOf('/') + 1);
+        // We will need to construct a new link, containing the filename (later, the full path)
+        return `[[${this.pathContainingLink}${this.destination}|${this.displayText}]]`;
+    }
 
-        // Remove.md extension if present
-        return destFilename.endsWith('.md') ? destFilename.slice(0, -3) : destFilename;
+    public get destination(): string {
+        return this.rawLink.link;
     }
 
     public get displayText(): string | undefined {

src/Task/ListItem.ts

@@ -210,7 +210,7 @@ export class ListItem {
     public get outlinks(): Link[] {
         return this.rawLinksInFileBody
             .filter((link) => link.position.start.line === this.lineNumber)
-            .map((link) => new Link(link, this.file.filenameWithoutExtension));
+            .map((link) => new Link(link, this.file.path));
     }
 
     /**

tests/Task/Link.test.ts

@@ -1,5 +1,4 @@
 import { Link } from '../../src/Task/Link';
-import { TasksFile } from '../../src/Scripting/TasksFile';
 
 import links_everywhere from '../Obsidian/__test_data__/links_everywhere.json';
 import internal_heading_links from '../Obsidian/__test_data__/internal_heading_links.json';
@@ -13,7 +12,7 @@ import type { SimulatedFile } from '../Obsidian/SimulatedFile';
 
 function getLink(data: any, index: number) {
     const rawLink = data.cachedMetadata.links[index];
-    return new Link(rawLink, new TasksFile(data.filePath).filenameWithoutExtension);
+    return new Link(rawLink, data.filePath);
 }
 
 describe('linkClass', () => {
@@ -24,10 +23,28 @@ describe('linkClass', () => {
         expect(link.originalMarkdown).toEqual('[[link_in_file_body]]');
         expect(link.destination).toEqual('link_in_file_body');
         expect(link.displayText).toEqual('link_in_file_body');
-        expect(link.destinationFilename).toEqual('link_in_file_body');
+        expect(link.markdown).toEqual(link.originalMarkdown);
     });
 
-    describe('.destinationFilename()', () => {
+    describe('return markdown to navigate to a link', () => {
+        // These links are useful
+        it('should return the filename if simple [[filename]]', () => {
+            const link = getLink(link_in_task_wikilink, 0);
+
+            expect(link.originalMarkdown).toEqual('[[link_in_task_wikilink]]');
+            expect(link.markdown).toEqual('[[link_in_task_wikilink]]');
+        });
+
+        // For more test examples, see QueryResultsRenderer.test.ts
+        it('should return a working link to [[#heading]]', () => {
+            const link = getLink(internal_heading_links, 0);
+
+            expect(link.originalMarkdown).toEqual('[[#Basic Internal Links]]');
+            expect(link.markdown).toEqual(
+                '[[Test Data/internal_heading_links.md#Basic Internal Links|Basic Internal Links]]',
+            );
+        });
+
         // ================================
         // WIKILINK TESTS
         // ================================
@@ -37,73 +54,77 @@ describe('linkClass', () => {
             const link = getLink(internal_heading_links, 0);
 
             expect(link.originalMarkdown).toEqual('[[#Basic Internal Links]]');
-            expect(link.destinationFilename).toEqual('internal_heading_links');
+            expect(link.markdown).toEqual(
+                '[[Test Data/internal_heading_links.md#Basic Internal Links|Basic Internal Links]]',
+            );
         });
 
         it('should return the filename of the containing note if the link is internal and has an alias [[#heading|display text]]', () => {
             const link = getLink(internal_heading_links, 6);
 
             expect(link.originalMarkdown).toEqual('[[#Header Links With File Reference]]');
-            expect(link.destinationFilename).toEqual('internal_heading_links');
+            expect(link.markdown).toEqual(
+                '[[Test Data/internal_heading_links.md#Header Links With File Reference|Header Links With File Reference]]',
+            );
         });
 
         // Tests checking against __link_in_task_wikilink__
         it('should return the filename if simple [[filename]]', () => {
             const link = getLink(link_in_task_wikilink, 0);
 
             expect(link.originalMarkdown).toEqual('[[link_in_task_wikilink]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path [[path/filename]]', () => {
             const link = getLink(link_in_task_wikilink, 2);
 
             expect(link.originalMarkdown).toEqual('[[Test Data/link_in_task_wikilink]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path and a heading link [[path/filename#heading]]', () => {
             const link = getLink(link_in_task_wikilink, 3);
 
             expect(link.originalMarkdown).toEqual('[[Test Data/link_in_task_wikilink#heading_link]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has an alias [[filename|alias]]', () => {
             const link = getLink(link_in_task_wikilink, 4);
 
             expect(link.originalMarkdown).toEqual('[[link_in_task_wikilink|alias]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path and an alias [[path/path/filename|alias]]', () => {
             const link = getLink(link_in_task_wikilink, 5);
 
             expect(link.originalMarkdown).toEqual('[[Test Data/link_in_task_wikilink|alias]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // # is a valid character in a filename or a path but Obsidian does not support it in links
         it('should return the filename if path contains a # [[pa#th/path/filename]]', () => {
             const link = getLink(link_in_task_wikilink, 6);
 
             expect(link.originalMarkdown).toEqual('[[pa#th/path/link_in_task_wikilink]]');
-            expect(link.destinationFilename).toEqual('pa');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // When grouping a Wikilink link expect [[file.md]] to be grouped with [[file]].
         it('should return a filename with no file extension if suffixed with .md [[link_in_task_wikilink.md]]', () => {
             const link = getLink(link_in_task_wikilink, 7);
 
             expect(link.originalMarkdown).toEqual('[[link_in_task_wikilink.md]]');
-            expect(link.destinationFilename).toEqual('link_in_task_wikilink');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return a filename with corresponding file extension if not markdown [[a_pdf_file.pdf]]', () => {
             const link = getLink(link_in_task_wikilink, 8);
 
             expect(link.originalMarkdown).toEqual('[[a_pdf_file.pdf]]');
-            expect(link.destinationFilename).toEqual('a_pdf_file.pdf');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // Empty Wikilink Tests
@@ -113,21 +134,21 @@ describe('linkClass', () => {
             const link = getLink(link_in_task_wikilink, 9);
 
             expect(link.originalMarkdown).toEqual('[[|]]');
-            expect(link.destinationFilename).toEqual('|');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should provide no special functionality for [[|alias]]; returns "|alias".)', () => {
             const link = getLink(link_in_task_wikilink, 10);
 
             expect(link.originalMarkdown).toEqual('[[|alias]]');
-            expect(link.destinationFilename).toEqual('|alias');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should provide no special functionality for [[|#alias]]; returns "|".)', () => {
             const link = getLink(link_in_task_wikilink, 11);
 
             expect(link.originalMarkdown).toEqual('[[|#alias]]');
-            expect(link.destinationFilename).toEqual('|');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // ================================
@@ -140,14 +161,14 @@ describe('linkClass', () => {
             const link = getLink(link_in_task_markdown_link, 8);
 
             expect(link.originalMarkdown).toEqual('[heading](#heading)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual('[[Test Data/link_in_task_markdown_link.md#heading|heading]]');
         });
 
         it('should return the filename when a simple markdown link [display name](filename)', () => {
             const link = getLink(link_in_task_markdown_link, 2);
 
             expect(link.originalMarkdown).toEqual('[link_in_task_markdown_link](link_in_task_markdown_link.md)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path [link_in_task_markdown_link](path/filename.md)', () => {
@@ -156,28 +177,28 @@ describe('linkClass', () => {
             expect(link.originalMarkdown).toEqual(
                 '[link_in_task_markdown_link](Test%20Data/link_in_task_markdown_link.md)',
             );
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path and a heading link [heading_link](path/filename.md#heading)', () => {
             const link = getLink(link_in_task_markdown_link, 4);
 
             expect(link.originalMarkdown).toEqual('[heading_link](Test%20Data/link_in_task_markdown_link.md#heading)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has an alias [alias](filename.md)', () => {
             const link = getLink(link_in_task_markdown_link, 5);
 
             expect(link.originalMarkdown).toEqual('[alias](link_in_task_markdown_link.md)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return the filename if link has a path and an alias [alias](path/path/filename.md)', () => {
             const link = getLink(link_in_task_markdown_link, 6);
 
             expect(link.originalMarkdown).toEqual('[alias](Test%20Data/link_in_task_markdown_link.md)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // # is a valid character in a filename or a path but Obsidian does not support it in links
@@ -187,22 +208,22 @@ describe('linkClass', () => {
             expect(link.originalMarkdown).toEqual(
                 '[link_in_task_markdown_link](pa#th/path/link_in_task_markdown_link.md)',
             );
-            expect(link.destinationFilename).toEqual('pa');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // When grouping a Wikilink link expect [[file.md]] to be grouped with [[file]].
         it('should return a filename when no .md extension if the .md exists in markdown link [alias](filename)', () => {
             const link = getLink(link_in_task_markdown_link, 9);
 
             expect(link.originalMarkdown).toEqual('[link_in_task_markdown_link](link_in_task_markdown_link)');
-            expect(link.destinationFilename).toEqual('link_in_task_markdown_link');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should return a filename with corresponding file extension if not markdown [a_pdf_file](a_pdf_file.pdf)', () => {
             const link = getLink(link_in_task_markdown_link, 10);
 
             expect(link.originalMarkdown).toEqual('[a_pdf_file](a_pdf_file.pdf)');
-            expect(link.destinationFilename).toEqual('a_pdf_file.pdf');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         it('should handle spaces in the path, filename, and heading link [heading link](path/filename with spaces.md#heading link)', () => {
@@ -211,7 +232,7 @@ describe('linkClass', () => {
             expect(link.originalMarkdown).toEqual(
                 '[spaces everywhere](Manual%20Testing/Smoke%20Testing%20the%20Tasks%20Plugin#How%20the%20tests%20work)',
             );
-            expect(link.destinationFilename).toEqual('Smoke Testing the Tasks Plugin');
+            expect(link.markdown).toEqual(link.originalMarkdown);
         });
 
         // Empty Markdown Link Tests
@@ -236,7 +257,7 @@ describe('visualise links', () => {
         output += `## ${file.filePath}\n\n`;
         outlinks.forEach((link) => {
             output += createRow('link.originalMarkdown', link.originalMarkdown);
-            output += createRow('link.destinationFilename', link.destinationFilename);
+            output += createRow('link.markdown', link.markdown);
             output += createRow('link.destination', link.destination);
             output += createRow('link.displayText', link.displayText);
             output += '\n';