enhance(refs): more intelligent ref copying

copy note ref copies header if selected

packages/common-server/src/testUtils.ts

@@ -107,7 +107,7 @@ export class NodeTestUtils {
     notes.map((n) => {
       const body = cleanOpts.withBody ? n.fname + " body" : "";
       // @ts-ignore
-      node2MdFile(new Note({ ...n, body }), {
+      node2MdFile(new Note({ body, ...n }), {
         root: vaultPath,
       });
     });

packages/engine-server/src/__tests__/utils.spec.ts

@@ -6,6 +6,7 @@ import {
   replaceRefWithMPEImport,
   stripLocalOnlyTags,
   extractBlock,
+  refLink2String,
 } from "../utils";
 import _ from "lodash";
 import { EngineTestUtils } from "@dendronhq/common-server/src";
@@ -53,8 +54,53 @@ describe("parseFileLink", () => {
       type: "file",
     });
   });
+
+  it("next anchor", () => {
+    expect(parseFileLink("[[foo]]#head1:#*")).toEqual({
+      anchorEnd: "*",
+      anchorStart: "head1",
+      name: "foo",
+      type: "file",
+    });
+  });
 });
 
+describe("link2String", () => {
+  test("file", () => {
+    expect(refLink2String({
+    name: "foo",
+    type: "file",
+    })).toEqual("[[foo]]")
+  });
+
+  it("one anchor", () => {
+    expect(refLink2String({
+      name: "foo",
+      anchorStart: "head1",
+      type: "file",
+    })).toEqual("[[foo]]#head1");
+  });
+
+  it("all parts", () => {
+    expect(refLink2String({
+      anchorEnd: "head2",
+      anchorStart: "head1",
+      name: "foo",
+      type: "file",
+    })).toEqual("[[foo]]#head1:#head2");
+  });
+
+  it("next anchor", () => {
+    expect(refLink2String({
+      anchorEnd: "*",
+      anchorStart: "head1",
+      name: "foo",
+      type: "file",
+    })).toEqual("[[foo]]#head1:#*");
+  });
+
+})
+
 describe("parseRef", () => {
   it("describe file ref without extension", () => {
     expect(parseDendronRef("ref: [[foo]]")).toEqual({

packages/engine-server/src/utils.ts

@@ -8,6 +8,30 @@ import path from "path";
 
 const markdownIt = _markdownIt();
 
+function normalize(text: string) {
+  return _.toLower(_.trim(text, ' #'));
+}
+
+export function refLink2String(link: DendronRefLink, opts?: {includeParen: boolean}): string {
+  const cleanOpts = _.defaults(opts, {includeParen: false});
+  // [[foo]]#head1:#*"
+  const linkParts = [`[[${link.name}]]`]
+  if (link.anchorStart) {
+    linkParts.push(`#${normalize(link.anchorStart)}`)
+  }
+  if (link.anchorStartOffset) {
+    linkParts.push(`,${link.anchorStartOffset}`)
+  }
+  if (link.anchorEnd) {
+    linkParts.push(`:#${normalize(link.anchorEnd)}`)
+  }
+  if (cleanOpts.includeParen) {
+    linkParts.splice(0, 0, "((");
+    linkParts.push("))");
+  }
+  return linkParts.join("");
+}
+
 // const testString = "<!--(([[class.mba.chapters.2]]))-->";
 function genAST(txt: string): ASTEnt[] {
   const tokens: Token[] = markdownIt.parse(txt, {});
@@ -17,6 +41,9 @@ function genAST(txt: string): ASTEnt[] {
 export type DendronRefLink = {
   label?: string;
   id?: string;
+  /**
+   * Name of file
+   */
   name?: string;
   anchorStart?: string;
   anchorEnd?: string;

packages/plugin-core/src/commands/CopyNoteRef.ts

@@ -1,10 +1,11 @@
 import { DNodeUtils } from "@dendronhq/common-all";
 import clipboardy from "@dendronhq/clipboardy";
 import _ from "lodash";
-import { TextEditor, window } from "vscode";
+import { TextEditor, window, Selection } from "vscode";
 import { VSCodeUtils } from "../utils";
 import { DendronWorkspace } from "../workspace";
 import { BasicCommand } from "./base";
+import { DendronRefLink, refLink2String } from "@dendronhq/engine-server";
 
 type CommandOpts = {};
 type CommandOutput = string;
@@ -24,14 +25,38 @@ export class CopyNoteRefCommand extends BasicCommand<
     window.showInformationMessage(`${link} copied`);
   }
 
+  isHeader(text: string, selection: Selection) {
+      return text.startsWith("#")  && (selection.start.line === selection.end.line)
+  }
+
+  async buildLink(opts: {fname: string}) {
+    const {fname} = opts;
+    const link: DendronRefLink = {
+      type: "file",
+      name: fname,
+    };
+    const { text, selection } = VSCodeUtils.getSelection();
+    let refLinkString: string = refLink2String(link);
+    if (!_.isEmpty(text)) {
+      if (this.isHeader(text, selection)) {
+        const headerText = _.trim(text)
+        link.anchorStart = headerText;
+        link.anchorEnd = "*";
+        link.anchorStartOffset = 1;
+        refLinkString = refLink2String(link);
+      } 
+    } 
+    return ["((", "ref: ", refLinkString, "))"].join("");
+  }
+
   async execute(_opts: CommandOpts) {
     const editor = VSCodeUtils.getActiveTextEditor() as TextEditor;
     const fname = DNodeUtils.uri2Fname(editor.document.uri);
     const note = _.find(DendronWorkspace.instance().engine.notes, { fname });
     if (!note) {
       throw Error(`${fname} not found in engine`);
     }
-    const link = `((ref:[[${fname}]]))`;
+    const link = await this.buildLink({fname});
     try {
       clipboardy.writeSync(link);
     } catch (err) {

packages/plugin-core/src/test/suite-integ/extension.test.ts

@@ -78,6 +78,7 @@ import {
 } from "@dendronhq/pods-core";
 import { ConfigurePodCommand } from "../../commands/ConfigurePodCommand";
 import { ImportPodCommand } from "../../commands/ImportPod";
+import { CopyNoteRefCommand } from "../../commands/CopyNoteRef";
 
 type ExportConfig = any;
 const expectedSettings = (opts?: { folders?: any; settings?: any }): any => {
@@ -1020,6 +1021,35 @@ suite("commands", function () {
     });
   });
 
+  describe.only("CopyNoteRefCommand", function () {
+    test("basic", function (done) {
+      onWSInit(async () => {
+        const uri = vscode.Uri.file(path.join(root.name, "vault", "foo.md"));
+        await vscode.window.showTextDocument(uri);
+        const link = await new CopyNoteRefCommand().run();
+        assert.equal(link, "((ref: [[foo]]))");
+        done();
+      });
+      setupDendronWorkspace(root.name, ctx, { useFixtures: true });
+    });
+
+    test("with selection", function (done) {
+      onWSInit(async () => {
+        const uri = vscode.Uri.file(path.join(root.name, "vault", "bar.md"));
+        const editor = await vscode.window.showTextDocument(uri);
+        editor.selection = new vscode.Selection(8, 0, 8, 12);
+        const link = await new CopyNoteRefCommand().run();
+        assert.equal(link, "((ref: [[bar]]#foo,1:#*))");
+        done();
+      });
+      setupDendronWorkspace(root.name, ctx, { useFixtures: false, useCb: async (vault) => {
+        NodeTestUtils.createNotes(vault, [
+          { fname: "bar", body: "## Foo\nfoo text\n## Header\n Header text" },
+        ]);
+      }});
+    });
+  });
+
   describe("GoUp", function () {
     test("basic", function (done) {
       onWSInit(async () => {