generate copy without wikilinks

packages/foam-vscode/package.json

@@ -346,6 +346,10 @@
         "command": "foam-vscode.open-resource",
         "title": "Foam: Open Resource"
       },
+      {
+        "command": "foam-vscode.generate-standalone-note",
+        "title": "Foam: generate standalone copy without wikilinks"
+      },
       {
         "command": "foam-vscode.views.orphans.group-by:folder",
         "title": "Group By Folder",

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/generate-mdlinks.test.ts

@@ -0,0 +1,55 @@
+import { generateMarkdownLinks } from './generate-mdlinks';
+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 = await generateMarkdownLinks(note, _workspace);
+    const expected: string[] = [
+      '[first-document](first-document.md "First Document")',
+      '[second-document](second-document.md "Second Document")',
+      '[#one section](<#one section> "File with different link formats")',
+      '[another name](<#one section> "File with different link formats")',
+      '[an alias](first-document.md "First Document")',
+    ];
+    expect(actual.length).toEqual(expected.length);
+    const _ = actual.map((textReplace, index) => {
+      expect(textReplace.to).toEqual(expected[index]);
+    });
+  });
+});

packages/foam-vscode/src/core/janitor/generate-mdlinks.ts

@@ -0,0 +1,107 @@
+import { NoteLinkDefinition, Resource } from '../model/note';
+import { FoamWorkspace } from '../model/workspace';
+import { createMarkdownReferences } from '../services/markdown-provider';
+
+export interface TextReplace {
+  from: string;
+  to: string;
+}
+
+/**
+ * parse wikilink's rawText
+ * possible inpout:
+ *  1. [[\<filename\>#\<section\>|\<label\>]]
+ *  2. [[#\<section\>|\<label\>]]
+ *  3. [[\<filename\>#\<section\>]]
+ *  4. [[\<filename\>|\<label\>]]
+ */
+class WikilinkRawText {
+  private lable_m: string = '';
+  private filename_m: string = '';
+  private section_m: string = '';
+
+  public readFromText(definition: NoteLinkDefinition): WikilinkRawText {
+    const struct_rawText_regex =
+      /(?:(?<filename>[^\]|#]+)?(?:#(?<section>[^\]|]+))?)?(?:\|(?<label>[^\]]+))?/;
+    const match_result = definition.label.match(struct_rawText_regex);
+    if (match_result) {
+      this.filename_m = match_result[1];
+      this.section_m = match_result[2];
+      this.lable_m = match_result[3];
+    }
+    return this;
+  }
+
+  public getLable(): string {
+    if (this.lable_m) {
+      return this.lable_m;
+    }
+    // return `${this.getFilename()}${this.section_m ? '#' : ''}${this.getSection()}`;
+    return '';
+  }
+  public getFilename(): string {
+    if (this.filename_m) {
+      return this.filename_m;
+    }
+    return '';
+  }
+  public getSection(): string {
+    if (this.section_m) {
+      return this.section_m;
+    }
+    return '';
+  }
+  public toMarkdownLink(
+    definition: NoteLinkDefinition,
+    toNote: Resource
+  ): string {
+    const struct_rawText_regex =
+      /(?:(?<filename>[^\]|#]+)?(?:#(?<section>[^\]|]+))?)?(?:\|(?<label>[^\]]+))?/;
+    const match_result = definition.label.match(struct_rawText_regex);
+    this.filename_m = match_result[1];
+    this.section_m = match_result[2];
+    this.lable_m = match_result[3];
+
+    let url = `${
+      definition.url !== toNote.uri.getBasename() ? definition.url : ''
+    }${this.section_m ? `#${this.getSection()}` : ''}`;
+    if (url.indexOf(' ') > 0) {
+      url = `<${url}>`;
+    }
+    url = `(${url}${definition.title ? ` "${definition.title}"` : ''})`;
+
+    let label = this.lable_m;
+    let filename =
+      this.getFilename() !== toNote.uri.getName() ? this.getFilename() : '';
+    let section = this.getSection();
+    if (!label) {
+      label = `${filename}${this.section_m ? `#${section}` : ''}`;
+    }
+
+    return `[${label}]${url}`;
+  }
+}
+
+export const generateMarkdownLinks = async (
+  note: Resource,
+  workspace: FoamWorkspace
+): Promise<TextReplace[]> => {
+  if (!note) {
+    return [] as TextReplace[];
+  }
+
+  const newWikilinkDefinitions = createMarkdownReferences(
+    workspace,
+    note,
+    true
+  );
+  const wikilinkRawTextParser = new WikilinkRawText();
+  const toReplaceArray = newWikilinkDefinitions.map(definition => {
+    return {
+      from: `[[${definition.label}]]`,
+      to: wikilinkRawTextParser.toMarkdownLink(definition, note),
+    };
+  });
+
+  return toReplaceArray;
+};

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

@@ -1,2 +1,3 @@
 export { generateLinkReferences } from './generate-link-references';
 export { generateHeading } from './generate-headings';
+export { generateMarkdownLinks } from './generate-mdlinks';

packages/foam-vscode/src/features/commands/generate-standalone-note.ts

@@ -0,0 +1,73 @@
+import { commands, ExtensionContext, window } from 'vscode';
+import { isMdEditor } from '../../utils';
+import { Foam } from '../../core/model/foam';
+import { FoamWorkspace } from '../../core/model/workspace';
+import { fromVsCodeUri } from '../../utils/vsc-utils';
+import { getEditorEOL } from '../../services/editor';
+import { ResourceParser } from '../../core/model/note';
+import { IMatcher } from '../../core/services/datastore';
+import { generateMarkdownLinks } from '../../core/janitor';
+const vscode = require('vscode'); /* cannot import workspace from above statement and not sure what happened */
+
+export default async function activate(
+  context: ExtensionContext,
+  foamPromise: Promise<Foam>
+) {
+  const foam = await foamPromise;
+
+  context.subscriptions.push(
+    commands.registerCommand('foam-vscode.generate-standalone-note', () => {
+      return generateStandaloneNote(
+        foam.workspace,
+        foam.services.parser,
+        foam.services.matcher
+      );
+    })
+  );
+}
+
+/**
+ * based on generate-link-references,
+ * copy the current note,
+ * replace wikilinks in it,
+ * save it at the same directory,
+ * call update-wikilinks to remove link references if neccessary
+ */
+async function generateStandaloneNote(
+  fWorkspace: FoamWorkspace,
+  fParser: ResourceParser,
+  fMatcher: IMatcher
+) {
+  const editor = window.activeTextEditor;
+  const doc = editor.document;
+
+  if (!isMdEditor(editor) || !fMatcher.isMatch(fromVsCodeUri(doc.uri))) {
+    return;
+  }
+
+  // const setting = getWikilinkDefinitionSetting();
+  const eol = getEditorEOL();
+  let text = doc.getText();
+
+  const resource = fParser.parse(fromVsCodeUri(doc.uri), text);
+  const textReplaceArr = await generateMarkdownLinks(resource, fWorkspace);
+  function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  textReplaceArr.forEach(({ from, to }) => {
+    text = text.replace(new RegExp(escapeRegExp(from), 'g'), to);
+  });
+
+  const basePath = doc.uri.path.split('/').slice(0, -1).join('/');
+
+  const fileUri = vscode.Uri.file(
+    `${
+      basePath ? basePath + '/' : ''
+    }${resource.uri.getName()}.standalone${resource.uri.getExtension()}`
+  );
+  const encoder = new TextEncoder();
+  await vscode.workspace.fs.writeFile(fileUri, encoder.encode(text));
+  await window.showTextDocument(fileUri);
+  await commands.executeCommand('foam-vscode.update-wikilink-definitions');
+}

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 './generate-standalone-note';

packages/foam-vscode/test-data/__scaffold__/file-with-different-link-formats.md

@@ -0,0 +1,21 @@
+# File with different link formats
+
+markdown link [home page](https://foambubble.github.io/)
+
+wikilink to file [[first-document]].
+
+markdown format link to local [file](first-document.md)
+
+embeded wikilink to file ![[second-document]].
+
+wikilink to placeholder [[non-exist-file]]
+
+in-note anchor [[file-with-different-link-formats#one section]]
+
+alias to anchor [[file-with-different-link-formats#one section|another name]]
+
+alias [[first-document|an alias]]
+
+dupilcated wikilink to file [[first-document]]
+
+# one section