generate copy without wikilinks

packages/foam-vscode/package.json

@@ -346,6 +346,22 @@
         "command": "foam-vscode.open-resource",
         "title": "Foam: Open Resource"
       },
+      {
+        "command": "foam-vscode.convert-wikilink-to-markdownlink-inplace",
+        "title": "Foam: convert wikilinks to markdown link format in place"
+      },
+      {
+        "command": "foam-vscode.convert-markdownlink-to-wikilink-inplace",
+        "title": "Foam: convert markdown links to wikilinks format in place"
+      },
+      {
+        "command": "foam-vscode.convert-wikilink-to-markdownlink-incopy",
+        "title": "Foam: convert wikilinks to markdown link format in copy"
+      },
+      {
+        "command": "foam-vscode.convert-markdownlink-to-wikilink-incopy",
+        "title": "Foam: convert markdown links to wikilinks format in copy"
+      },
       {
         "command": "foam-vscode.views.orphans.group-by:folder",
         "title": "Group By Folder",

packages/foam-vscode/src/core/janitor/convert-links-format.test.ts

@@ -0,0 +1,71 @@
+import { convertLinkFormat } from '.';
+import { TEST_DATA_DIR } from '../../test/test-utils';
+import { MarkdownResourceProvider } from '../services/markdown-provider';
+import { Resource } from '../model/note';
+import { FoamWorkspace } from '../model/workspace';
+import { Logger } from '../utils/log';
+import fs from 'fs';
+import { URI } from '../model/uri';
+import { createMarkdownParser } from '../services/markdown-parser';
+import { FileDataStore } from '../../test/test-datastore';
+
+Logger.setLevel('error');
+
+describe('generateStdMdLink', () => {
+  let _workspace: FoamWorkspace;
+  // TODO slug must be reserved for actual slugs, not file names
+  const findBySlug = (slug: string): Resource => {
+    return _workspace
+      .list()
+      .find(res => res.uri.getName() === slug) as Resource;
+  };
+
+  beforeAll(async () => {
+    /** Use fs for reading files in units where vscode.workspace is unavailable */
+    const readFile = async (uri: URI) =>
+      (await fs.promises.readFile(uri.toFsPath())).toString();
+    const dataStore = new FileDataStore(
+      readFile,
+      TEST_DATA_DIR.joinPath('__scaffold__').toFsPath()
+    );
+    const parser = createMarkdownParser();
+    const mdProvider = new MarkdownResourceProvider(dataStore, parser);
+    _workspace = await FoamWorkspace.fromProviders([mdProvider], dataStore);
+  });
+
+  it('initialised test graph correctly', () => {
+    expect(_workspace.list().length).toEqual(11);
+  });
+
+  it('can generate markdown links correctly', async () => {
+    const note = findBySlug('file-with-different-link-formats');
+    const actual = note.links
+      .filter(link => link.type === 'wikilink')
+      .map(link => convertLinkFormat(link, 'link', _workspace, note));
+    const expected: string[] = [
+      '[first-document](first-document.md)',
+      '[second-document](second-document.md)',
+      '[[non-exist-file]]',
+      '[#one section](<#one section>)',
+      '[another name](<#one section>)',
+      '[an alias](first-document.md)',
+      '[first-document](first-document.md)',
+    ];
+    expect(actual.length).toEqual(expected.length);
+    const _ = actual.map((LinkReplace, index) => {
+      expect(LinkReplace.newText).toEqual(expected[index]);
+    });
+  });
+
+  it('can generate wikilinks correctly', async () => {
+    const note = findBySlug('file-with-different-link-formats');
+    const actual = note.links
+      .filter(link => link.type === 'link')
+      .map(link => convertLinkFormat(link, 'wikilink', _workspace, note));
+    const expected: string[] = ['[[first-document|file]]'];
+    expect(actual.length).toEqual(expected.length);
+    const _ = actual.map((LinkReplace, index) => {
+      expect(LinkReplace.newText).toEqual(expected[index]);
+    });
+  });
+});

packages/foam-vscode/src/core/janitor/convert-links-format.ts

@@ -0,0 +1,103 @@
+import { Resource, ResourceLink } from '../model/note';
+import { URI } from '../model/uri';
+import { Range } from '../model/range';
+import { FoamWorkspace } from '../model/workspace';
+import { isNone } from '../utils';
+import { MarkdownLink } from '../services/markdown-link';
+
+export interface LinkReplace {
+  newText: string;
+  range: Range /* old range */;
+}
+
+/**
+ * convert a link based on its workspace and the note containing it.
+ * According to targetFormat parameter to decide output format. If link.type === targetFormat, then it simply copy
+ * the rawText into LinkReplace. Therefore, it's recommanded to filter before conversion.
+ * If targetFormat isn't supported, or the target resource pointed by link cannot be found, the function will throw
+ * exception.
+ * @param link
+ * @param targetFormat
+ * @param workspace
+ * @param note
+ * @returns LinkReplace { newText: string; range: Range; }
+ */
+export function convertLinkFormat(
+  link: ResourceLink,
+  targetFormat: string,
+  workspace: FoamWorkspace,
+  note: Resource | URI
+): LinkReplace {
+  const resource = note instanceof URI ? workspace.find(note) : note;
+  const targetUri = workspace.resolveLink(resource, link);
+  /* If it's already the target format or a placeholder, no transformation happens */
+  if (link.type === targetFormat || targetUri.scheme === 'placeholder') {
+    return {
+      newText: link.rawText,
+      range: link.range,
+    };
+  }
+
+  let { target, section, alias } = MarkdownLink.analyzeLink(link);
+  let sectionDivider = section ? '#' : '';
+  let aliasDivider = alias ? '|' : '';
+  let embed = link.isEmbed ? '!' : '';
+
+  if (isNone(targetUri)) {
+    throw new Error(
+      `Unexpected state: link to: "${link.rawText}" is not resolvable`
+    );
+  }
+
+  const targetRes = workspace.find(targetUri);
+  let relativeUri = targetRes.uri.relativeTo(resource.uri.getDirectory());
+
+  if (targetFormat === 'wikilink') {
+    /* remove extension if possible, then get the basename to prevent from filename conflict */
+    if (relativeUri.path.endsWith(workspace.defaultExtension)) {
+      relativeUri = relativeUri.changeExtension('*', '');
+    }
+    target = relativeUri.getBasename();
+
+    return {
+      newText: `${embed}[[${target}${sectionDivider}${section}${aliasDivider}${alias}]]`,
+      range: link.range,
+    };
+  }
+
+  if (targetFormat === 'link') {
+    /* if alias is empty, construct one as target#section */
+    if (alias === '') {
+      /* in page anchor have no filename */
+      if (relativeUri.getBasename() === resource.uri.getBasename()) {
+        target = '';
+      }
+      alias = `${target}${sectionDivider}${section}`;
+    }
+
+    /* construct url */
+    let url = relativeUri.path;
+    /* in page anchor have no filename */
+    if (relativeUri.getBasename() === resource.uri.getBasename()) {
+      url = '';
+    }
+    if (sectionDivider === '#') {
+      url = `${url}${sectionDivider}${section}`;
+    }
+    if (url.indexOf(' ') > 0) {
+      url = `<${url}>`;
+    }
+
+    /* if it's originally an embeded note, the markdown link shouldn't be embeded */
+    if (embed && targetRes.type === 'note') {
+      embed = '';
+    }
+    return {
+      newText: `${embed}[${alias}](${url})`,
+      range: link.range,
+    };
+  }
+  throw new Error(
+    `Unexpected state: targetFormat: ${targetFormat} is not supported`
+  );
+}

packages/foam-vscode/src/core/janitor/generate-link-references.test.ts

@@ -36,7 +36,7 @@ describe('generateLinkReferences', () => {
   });
 
   it('initialised test graph correctly', () => {
-    expect(_workspace.list().length).toEqual(10);
+    expect(_workspace.list().length).toEqual(11);
   });
 
   it('should add link references to a file that does not have them', async () => {

packages/foam-vscode/src/core/janitor/index.ts

@@ -1,2 +1,3 @@
 export { generateLinkReferences } from './generate-link-references';
 export { generateHeading } from './generate-headings';
+export { convertLinkFormat } from './convert-links-format';

packages/foam-vscode/src/features/commands/convert-links-format-in-note.ts

@@ -0,0 +1,179 @@
+import { commands, ExtensionContext, window } from 'vscode';
+import { isMdEditor } from '../../utils';
+import { Foam } from '../../core/model/foam';
+import { FoamWorkspace } from '../../core/model/workspace';
+import { fromVsCodeUri, toVsCodeRange } from '../../utils/vsc-utils';
+import { ResourceParser } from '../../core/model/note';
+import { IMatcher } from '../../core/services/datastore';
+import { convertLinkFormat } from '../../core/janitor';
+const vscode = require('vscode'); /* cannot import workspace from above statement and not sure what happened */
+
+enum ConvertOption {
+  Wikilink2MDlink,
+  MDlink2Wikilink,
+}
+
+interface IConfig {
+  from: string;
+  to: string;
+}
+
+const Config: { [key in ConvertOption]: IConfig } = {
+  [ConvertOption.Wikilink2MDlink]: {
+    from: 'wikilink',
+    to: 'link',
+  },
+  [ConvertOption.MDlink2Wikilink]: {
+    from: 'link',
+    to: 'wikilink',
+  },
+};
+
+export default async function activate(
+  context: ExtensionContext,
+  foamPromise: Promise<Foam>
+) {
+  const foam = await foamPromise;
+
+  /* 
+  commands:
+  foam-vscode.convert-wikilink-to-markdownlink-inplace
+  foam-vscode.convert-markdownlink-to-wikilink-inplace
+  foam-vscode.convert-wikilink-to-markdownlink-in-copy
+  foam-vscode.convert-markdownlink-to-wikilink-in-copy
+   */
+  context.subscriptions.push(
+    commands.registerCommand(
+      'foam-vscode.convert-wikilink-to-markdownlink-inplace',
+      () => {
+        return convertLinkInPlace(
+          foam.workspace,
+          foam.services.parser,
+          foam.services.matcher,
+          Config[ConvertOption.Wikilink2MDlink]
+        );
+      }
+    ),
+    commands.registerCommand(
+      'foam-vscode.convert-markdownlink-to-wikilink-inplace',
+      () => {
+        return convertLinkInPlace(
+          foam.workspace,
+          foam.services.parser,
+          foam.services.matcher,
+          Config[ConvertOption.MDlink2Wikilink]
+        );
+      }
+    ),
+    commands.registerCommand(
+      'foam-vscode.convert-wikilink-to-markdownlink-incopy',
+      () => {
+        return convertLinkInCopy(
+          foam.workspace,
+          foam.services.parser,
+          foam.services.matcher,
+          Config[ConvertOption.Wikilink2MDlink]
+        );
+      }
+    ),
+    commands.registerCommand(
+      'foam-vscode.convert-markdownlink-to-wikilink-incopy',
+      () => {
+        return convertLinkInCopy(
+          foam.workspace,
+          foam.services.parser,
+          foam.services.matcher,
+          Config[ConvertOption.MDlink2Wikilink]
+        );
+      }
+    )
+  );
+}
+
+/**
+ * convert links based on its workspace and the note containing it.
+ * Changes happen in-place
+ * @param fWorkspace
+ * @param fParser
+ * @param fMatcher
+ * @param convertOption
+ * @returns void
+ */
+async function convertLinkInPlace(
+  fWorkspace: FoamWorkspace,
+  fParser: ResourceParser,
+  fMatcher: IMatcher,
+  convertOption: IConfig
+) {
+  const editor = window.activeTextEditor;
+  const doc = editor.document;
+
+  if (!isMdEditor(editor) || !fMatcher.isMatch(fromVsCodeUri(doc.uri))) {
+    return;
+  }
+  // const eol = getEditorEOL();
+  let text = doc.getText();
+
+  const resource = fParser.parse(fromVsCodeUri(doc.uri), text);
+
+  const textReplaceArr = resource.links
+    .filter(link => link.type === convertOption.from)
+    .map(link =>
+      convertLinkFormat(link, convertOption.to, fWorkspace, resource)
+    )
+    /* transform .range property into vscode range */
+    .map(linkReplace => ({
+      ...linkReplace,
+      range: toVsCodeRange(linkReplace.range),
+    }));
+
+  /* reorder the array such that the later range comes first */
+  textReplaceArr.sort((a, b) => b.range.start.compareTo(a.range.start));
+
+  await editor.edit(editorBuilder => {
+    textReplaceArr.forEach(edit => {
+      editorBuilder.replace(edit.range, edit.newText);
+    });
+  });
+}
+
+/**
+ * convert links based on its workspace and the note containing it.
+ * Changes happen in a copy
+ * 1. prepare a copy file, and makt it the activeTextEditor
+ * 2. call to convertLinkInPlace
+ * @param fWorkspace
+ * @param fParser
+ * @param fMatcher
+ * @param convertOption
+ * @returns void
+ */
+async function convertLinkInCopy(
+  fWorkspace: FoamWorkspace,
+  fParser: ResourceParser,
+  fMatcher: IMatcher,
+  convertOption: IConfig
+) {
+  const editor = window.activeTextEditor;
+  const doc = editor.document;
+
+  if (!isMdEditor(editor) || !fMatcher.isMatch(fromVsCodeUri(doc.uri))) {
+    return;
+  }
+  // const eol = getEditorEOL();
+  let text = doc.getText();
+
+  const resource = fParser.parse(fromVsCodeUri(doc.uri), text);
+  const basePath = doc.uri.path.split('/').slice(0, -1).join('/');
+
+  const fileUri = vscode.Uri.file(
+    `${
+      basePath ? basePath + '/' : ''
+    }${resource.uri.getName()}.copy${resource.uri.getExtension()}`
+  );
+  const encoder = new TextEncoder();
+  await vscode.workspace.fs.writeFile(fileUri, encoder.encode(text));
+  await window.showTextDocument(fileUri);
+
+  await convertLinkInPlace(fWorkspace, fParser, fMatcher, convertOption);
+}

packages/foam-vscode/src/features/commands/index.ts

@@ -10,3 +10,4 @@ export { default as openResource } from './open-resource';
 export { default as updateGraphCommand } from './update-graph';
 export { default as updateWikilinksCommand } from './update-wikilinks';
 export { default as createNote } from './create-note';
+export { default as generateStandaloneNote } from './convert-links-format-in-note';