Rename placeholder on note creation so it can update it if necessary (#…

…1344)

* Introduced Location
* Passing a reference to the source link to the create-note command

Also
* Added withTiming fn for performance logging
* Added extra test to check incoming wikilink with sections
* Tweaked creation of vscode URI to also support raw objects

packages/foam-vscode/src/core/model/foam.ts

@@ -5,7 +5,7 @@ import { FoamGraph } from './graph';
 import { ResourceParser } from './note';
 import { ResourceProvider } from './provider';
 import { FoamTags } from './tags';
-import { Logger } from '../utils/log';
+import { Logger, withTiming, withTimingAsync } from '../utils/log';
 
 export interface Services {
   dataStore: IDataStore;
@@ -28,24 +28,25 @@ export const bootstrap = async (
   initialProviders: ResourceProvider[],
   defaultExtension: string = '.md'
 ) => {
-  const tsStart = Date.now();
-
-  const workspace = await FoamWorkspace.fromProviders(
-    initialProviders,
-    dataStore,
-    defaultExtension
+  const workspace = await withTimingAsync(
+    () =>
+      FoamWorkspace.fromProviders(
+        initialProviders,
+        dataStore,
+        defaultExtension
+      ),
+    ms => Logger.info(`Workspace loaded in ${ms}ms`)
   );
 
-  const tsWsDone = Date.now();
-  Logger.info(`Workspace loaded in ${tsWsDone - tsStart}ms`);
-
-  const graph = FoamGraph.fromWorkspace(workspace, true);
-  const tsGraphDone = Date.now();
-  Logger.info(`Graph loaded in ${tsGraphDone - tsWsDone}ms`);
+  const graph = withTiming(
+    () => FoamGraph.fromWorkspace(workspace, true),
+    ms => Logger.info(`Graph loaded in ${ms}ms`)
+  );
 
-  const tags = FoamTags.fromWorkspace(workspace, true);
-  const tsTagsEnd = Date.now();
-  Logger.info(`Tags loaded in ${tsTagsEnd - tsGraphDone}ms`);
+  const tags = withTiming(
+    () => FoamTags.fromWorkspace(workspace, true),
+    ms => Logger.info(`Tags loaded in ${ms}ms`)
+  );
 
   watcher?.onDidChange(async uri => {
     if (matcher.isMatch(uri)) {

packages/foam-vscode/src/core/model/graph.test.ts

@@ -139,6 +139,21 @@ describe('Graph', () => {
     ).toEqual(['/path/another/page-c.md', '/somewhere/page-b.md']);
   });
 
+  it('should create inbound connections when targeting a section', () => {
+    const noteA = createTestNote({
+      uri: '/path/to/page-a.md',
+      links: [{ slug: 'page-b#section 2' }],
+    });
+    const noteB = createTestNote({
+      uri: '/somewhere/page-b.md',
+      text: '## Section 1\n\n## Section 2',
+    });
+    const ws = createTestWorkspace().set(noteA).set(noteB);
+    const graph = FoamGraph.fromWorkspace(ws);
+
+    expect(graph.getBacklinks(noteB.uri).length).toEqual(1);
+  });
+
   it('should support attachments', () => {
     const noteA = createTestNote({
       uri: '/path/to/page-a.md',

packages/foam-vscode/src/core/model/graph.ts

@@ -3,7 +3,7 @@ import { ResourceLink } from './note';
 import { URI } from './uri';
 import { FoamWorkspace } from './workspace';
 import { IDisposable } from '../common/lifecycle';
-import { Logger } from '../utils/log';
+import { Logger, withTiming } from '../utils/log';
 import { Emitter } from '../common/event';
 
 export type Connection = {
@@ -100,31 +100,32 @@ export class FoamGraph implements IDisposable {
   }
 
   public update() {
-    const start = Date.now();
-    this.backlinks.clear();
-    this.links.clear();
-    this.placeholders.clear();
-
-    for (const resource of this.workspace.resources()) {
-      for (const link of resource.links) {
-        try {
-          const targetUri = this.workspace.resolveLink(resource, link);
-          this.connect(resource.uri, targetUri, link);
-        } catch (e) {
-          Logger.error(
-            `Error while resolving link ${
-              link.rawText
-            } in ${resource.uri.toFsPath()}, skipping.`,
-            link,
-            e
-          );
+    withTiming(
+      () => {
+        this.backlinks.clear();
+        this.links.clear();
+        this.placeholders.clear();
+
+        for (const resource of this.workspace.resources()) {
+          for (const link of resource.links) {
+            try {
+              const targetUri = this.workspace.resolveLink(resource, link);
+              this.connect(resource.uri, targetUri, link);
+            } catch (e) {
+              Logger.error(
+                `Error while resolving link ${
+                  link.rawText
+                } in ${resource.uri.toFsPath()}, skipping.`,
+                link,
+                e
+              );
+            }
+          }
+          this.onDidUpdateEmitter.fire();
         }
-      }
-    }
-
-    const end = Date.now();
-    Logger.debug(`Graph updated in ${end - start}ms`);
-    this.onDidUpdateEmitter.fire();
+      },
+      ms => Logger.debug(`Graph updated in ${ms}ms`)
+    );
   }
 
   private connect(source: URI, target: URI, link: ResourceLink) {

packages/foam-vscode/src/core/model/location.ts

@@ -0,0 +1,35 @@
+import { Range } from './range';
+import { URI } from './uri';
+import { ResourceLink } from './note';
+
+/**
+ * Represents a location inside a resource, such as a line
+ * inside a text file.
+ */
+export interface Location<T> {
+  /**
+   * The resource identifier of this location.
+   */
+  uri: URI;
+  /**
+   * The document range of this locations.
+   */
+  range: Range;
+  /**
+   * The data associated to this location.
+   */
+  data: T;
+}
+
+export abstract class Location<T> {
+  static create<T>(uri: URI, range: Range, data: T): Location<T> {
+    return { uri, range, data };
+  }
+
+  static forObjectWithRange<T extends { range: Range }>(
+    uri: URI,
+    obj: T
+  ): Location<T> {
+    return Location.create(uri, obj.range, obj);
+  }
+}

packages/foam-vscode/src/core/utils/log.ts

@@ -89,3 +89,25 @@ export class Logger {
     Logger.defaultLogger = logger;
   }
 }
+
+export const withTiming = <T>(
+  fn: () => T,
+  onDidComplete: (elapsed: number) => void
+): T => {
+  const tsStart = Date.now();
+  const res = fn();
+  const tsEnd = Date.now();
+  onDidComplete(tsEnd - tsStart);
+  return res;
+};
+
+export const withTimingAsync = async <T>(
+  fn: () => Promise<T>,
+  onDidComplete: (elapsed: number) => void
+): Promise<T> => {
+  const tsStart = Date.now();
+  const res = await fn();
+  const tsEnd = Date.now();
+  onDidComplete(tsEnd - tsStart);
+  return res;
+};

packages/foam-vscode/src/extension.ts

@@ -73,7 +73,9 @@ export async function activate(context: ExtensionContext) {
     );
 
     // Load the features
-    const resPromises = features.map(feature => feature(context, foamPromise));
+    const featuresPromises = features.map(feature =>
+      feature(context, foamPromise)
+    );
 
     const foam = await foamPromise;
     Logger.info(`Loaded ${foam.workspace.list().length} resources`);
@@ -102,14 +104,15 @@ export async function activate(context: ExtensionContext) {
       })
     );
 
-    const res = (await Promise.all(resPromises)).filter(r => r != null);
+    const feats = (await Promise.all(featuresPromises)).filter(r => r != null);
 
     return {
       extendMarkdownIt: (md: markdownit) => {
-        return res.reduce((acc: markdownit, r: any) => {
+        return feats.reduce((acc: markdownit, r: any) => {
           return r.extendMarkdownIt ? r.extendMarkdownIt(acc) : acc;
         }, md);
       },
+      foam,
     };
   } catch (e) {
     Logger.error('An error occurred while bootstrapping Foam', e);

packages/foam-vscode/src/features/commands/create-note.spec.ts

@@ -10,7 +10,12 @@ import {
   showInEditor,
 } from '../../test/test-utils-vscode';
 import { fromVsCodeUri } from '../../utils/vsc-utils';
-import { CREATE_NOTE_COMMAND } from './create-note';
+import { CREATE_NOTE_COMMAND, createNote } from './create-note';
+import { Location } from '../../core/model/location';
+import { Range } from '../../core/model/range';
+import { ResourceLink } from '../../core/model/note';
+import { MarkdownResourceProvider } from '../../core/services/markdown-provider';
+import { createMarkdownParser } from '../../core/services/markdown-parser';
 
 describe('create-note command', () => {
   afterEach(() => {
@@ -194,8 +199,14 @@ describe('factories', () => {
   describe('forPlaceholder', () => {
     it('adds the .md extension to notes created for placeholders', async () => {
       await closeEditors();
+      const link: ResourceLink = {
+        type: 'wikilink',
+        rawText: '[[my-placeholder]]',
+        range: Range.create(0, 0, 0, 0),
+        isEmbed: false,
+      };
       const command = CREATE_NOTE_COMMAND.forPlaceholder(
-        'my-placeholder',
+        Location.forObjectWithRange(URI.file(''), link),
         '.md'
       );
       await commands.executeCommand(command.name, command.params);
@@ -204,5 +215,41 @@ describe('factories', () => {
       expect(doc.uri.path).toMatch(/my-placeholder.md$/);
       expect(doc.getText()).toMatch(/^# my-placeholder/);
     });
+
+    it('replaces the original placeholder based on the new note identifier (#1327)', async () => {
+      await closeEditors();
+      const templateA = await createFile(
+        `---
+foam_template:
+  name: 'Example Template'
+  description: 'An example for reproducing a bug'
+  filepath: '$FOAM_SLUG-world.md'
+---`,
+        ['.foam', 'templates', 'template-a.md']
+      );
+
+      const noteA = await createFile(`this is my [[hello]]`);
+
+      const parser = createMarkdownParser();
+      const res = parser.parse(noteA.uri, noteA.content);
+
+      const command = CREATE_NOTE_COMMAND.forPlaceholder(
+        Location.forObjectWithRange(noteA.uri, res.links[0]),
+        '.md',
+        {
+          templatePath: templateA.uri.path,
+        }
+      );
+      const results: Awaited<ReturnType<typeof createNote>> =
+        await commands.executeCommand(command.name, command.params);
+      expect(results.didCreateFile).toBeTruthy();
+      expect(results.uri.path.endsWith('hello-world.md')).toBeTruthy();
+
+      const newNoteDoc = window.activeTextEditor.document;
+      expect(newNoteDoc.uri.path).toMatch(/hello-world.md$/);
+
+      const { doc } = await showInEditor(noteA.uri);
+      expect(doc.getText()).toEqual(`this is my [[hello-world]]`);
+    });
   });
 });