No longer index templates tagged as #template

plugs/directive/command.ts

@@ -28,7 +28,9 @@ export async function updateDirectivesOnPageCommand() {
   }
   const text = await editor.getText();
   const tree = await markdown.parseMarkdown(text);
-  const metaData = await extractFrontmatter(tree, ["$disableDirectives"]);
+  const metaData = await extractFrontmatter(tree, {
+    removeKeys: ["$disableDirectives"],
+  });
 
   if (isFederationPath(currentPage)) {
     console.info("Current page is a federation page, not updating directives.");
@@ -173,7 +175,9 @@ async function updateDirectivesForPage(
   const pageMeta = await space.getPageMeta(pageName);
   const currentText = await space.readPage(pageName);
   const tree = await markdown.parseMarkdown(currentText);
-  const metaData = await extractFrontmatter(tree, ["$disableDirectives"]);
+  const metaData = await extractFrontmatter(tree, {
+    removeKeys: ["$disableDirectives"],
+  });
 
   if (isFederationPath(pageName)) {
     console.info("Current page is a federation page, not updating directives.");

plugs/directive/query_directive.ts

@@ -1,7 +1,7 @@
 import { events } from "$sb/syscalls.ts";
 
 import { replaceTemplateVars } from "../template/template.ts";
-import { renderTemplate } from "./util.ts";
+import { renderQueryTemplate } from "./util.ts";
 import { jsonToMDTable } from "./util.ts";
 import { ParseTree, parseTreeToAST } from "$sb/lib/tree.ts";
 import { astToKvQuery } from "$sb/lib/parse-query.ts";
@@ -38,7 +38,7 @@ export async function queryDirectiveRenderer(
     // console.log("Parsed query", parsedQuery);
     const allResults = results.flat();
     if (parsedQuery.render) {
-      const rendered = await renderTemplate(
+      const rendered = await renderQueryTemplate(
         pageMeta,
         parsedQuery.render,
         allResults,

plugs/directive/template_directive.ts

@@ -8,6 +8,7 @@ import { directiveRegex } from "./directives.ts";
 import { updateDirectives } from "./command.ts";
 import { resolvePath, rewritePageRefs } from "$sb/lib/resolve.ts";
 import { PageMeta } from "$sb/types.ts";
+import { renderTemplate } from "../template/plug_api.ts";
 
 const templateRegex = /\[\[([^\]]+)\]\]\s*(.*)\s*/;
 
@@ -52,7 +53,7 @@ export async function templateDirectiveRenderer(
     templateText = await space.readPage(templatePath);
   }
   const tree = await markdown.parseMarkdown(templateText);
-  await extractFrontmatter(tree, [], true); // Remove entire frontmatter section, if any
+  await extractFrontmatter(tree, { removeFrontmatterSection: true }); // Remove entire frontmatter section, if any
 
   // Resolve paths in the template
   rewritePageRefs(tree, templatePath);
@@ -63,9 +64,7 @@ export async function templateDirectiveRenderer(
 
   // if it's a template injection (not a literal "include")
   if (directive === "use") {
-    newBody = await handlebars.renderTemplate(newBody, parsedArgs, {
-      page: pageMeta,
-    });
+    newBody = await renderTemplate(newBody, pageMeta, parsedArgs);
 
     // Recursively render directives
     const tree = await markdown.parseMarkdown(newBody);

plugs/directive/util.ts

@@ -1,6 +1,7 @@
 import { handlebars, space } from "$sb/syscalls.ts";
 import { handlebarHelpers } from "../../common/syscalls/handlebar_helpers.ts";
 import { PageMeta } from "$sb/types.ts";
+import { cleanTemplate, renderTemplate } from "../template/plug_api.ts";
 
 export function defaultJsonTransformer(_k: string, v: any) {
   if (v === undefined) {
@@ -53,13 +54,14 @@ export function jsonToMDTable(
   return lines.join("\n");
 }
 
-export async function renderTemplate(
+export async function renderQueryTemplate(
   pageMeta: PageMeta,
-  renderTemplate: string,
+  templatePage: string,
   data: any[],
   renderAll: boolean,
 ): Promise<string> {
-  let templateText = await space.readPage(renderTemplate);
+  let templateText = await space.readPage(templatePage);
+  templateText = await cleanTemplate(templateText);
   if (!renderAll) {
     templateText = `{{#each .}}\n${templateText}\n{{/each}}`;
   }

plugs/index/command.ts

@@ -2,6 +2,7 @@ import { editor, events, markdown, mq, space, system } from "$sb/syscalls.ts";
 import { sleep } from "$sb/lib/async.ts";
 import { IndexEvent } from "$sb/app_event.ts";
 import { MQMessage } from "$sb/types.ts";
+import { isTemplate } from "../template/util.ts";
 
 export async function reindexCommand() {
   await editor.flashNotification("Performing full page reindex...");
@@ -42,9 +43,16 @@ export async function processIndexQueue(messages: MQMessage[]) {
 }
 
 export async function parseIndexTextRepublish({ name, text }: IndexEvent) {
-  // console.log("Reindexing", name);
-  await events.dispatchEvent("page:index", {
-    name,
-    tree: await markdown.parseMarkdown(text),
-  });
+  if (isTemplate(text)) {
+    console.log("Indexing", name, "as template");
+    await events.dispatchEvent("page:indexTemplate", {
+      name,
+      tree: await markdown.parseMarkdown(text),
+    });
+  } else {
+    await events.dispatchEvent("page:index", {
+      name,
+      tree: await markdown.parseMarkdown(text),
+    });
+  }
 }

plugs/markdown/html_render.ts

@@ -41,9 +41,5 @@ export function renderHtml(t: Tag | null): string {
   if (t.name === Fragment) {
     return body;
   }
-  // if (t.body) {
   return `<${t.name}${attrs}>${body}</${t.name}>`;
-  // } else {
-  //   return `<${t.name}${attrs}/>`;
-  // }
 }

plugs/query/query.ts

@@ -2,7 +2,7 @@ import type { WidgetContent } from "$sb/app_event.ts";
 import { events, language, space, system } from "$sb/syscalls.ts";
 import { parseTreeToAST } from "$sb/lib/tree.ts";
 import { astToKvQuery } from "$sb/lib/parse-query.ts";
-import { jsonToMDTable, renderTemplate } from "../directive/util.ts";
+import { jsonToMDTable, renderQueryTemplate } from "../directive/util.ts";
 import { loadPageObject, replaceTemplateVars } from "../template/template.ts";
 
 export async function widget(
@@ -44,7 +44,7 @@ export async function widget(
       } else {
         if (parsedQuery.render) {
           // Configured a custom rendering template, let's use it!
-          const rendered = await renderTemplate(
+          const rendered = await renderQueryTemplate(
             pageObject,
             parsedQuery.render,
             allResults,

plugs/template/api.ts

@@ -0,0 +1,51 @@
+import { handlebars, markdown, YAML } from "$sb/syscalls.ts";
+import type { PageMeta } from "$sb/types.ts";
+import { extractFrontmatter } from "$sb/lib/frontmatter.ts";
+import { TemplateObject } from "./types.ts";
+import { renderToText } from "$sb/lib/tree.ts";
+
+/**
+ * Strips the template from its frontmatter and renders it.
+ * The assumption is that the frontmatter has already been parsed and should not appear in thhe rendered output.
+ * @param templateText the template text
+ * @param data data to be rendered by the template
+ * @param globals a set of global variables
+ * @returns
+ */
+export async function renderTemplate(
+  templateText: string,
+  pageMeta: PageMeta,
+  data: any = {},
+): Promise<string> {
+  const tree = await markdown.parseMarkdown(templateText);
+  const frontmatter: Partial<TemplateObject> = await extractFrontmatter(tree, {
+    removeFrontmatterSection: true,
+    removeTags: ["template"],
+  });
+  templateText = renderToText(tree).trimStart();
+  // console.log(`Trimmed template: |${templateText}|`);
+  // If a 'frontmatter' key was specified in the frontmatter, use that as the frontmatter
+  if (frontmatter.frontmatter) {
+    if (typeof frontmatter.frontmatter === "string") {
+      templateText = "---\n" + frontmatter.frontmatter + "---\n" + templateText;
+    } else {
+      templateText = "---\n" + (await YAML.stringify(frontmatter.frontmatter)) +
+        "---\n" + templateText;
+    }
+  }
+  return handlebars.renderTemplate(templateText, data, { page: pageMeta });
+}
+
+/**
+ * Strips a template text from its frontmatter and #template tag
+ */
+export async function cleanTemplate(
+  templateText: string,
+): Promise<string> {
+  const tree = await markdown.parseMarkdown(templateText);
+  await extractFrontmatter(tree, {
+    removeFrontmatterSection: true,
+    removeTags: ["template"],
+  });
+  return renderToText(tree).trimStart();
+}

plugs/template/index.ts

@@ -0,0 +1,7 @@
+import type { IndexTreeEvent } from "$sb/app_event.ts";
+import { system } from "$sb/syscalls.ts";
+
+export async function indexTemplate({ name, tree }: IndexTreeEvent) {
+  // Just delegate to the index plug
+  await system.invokeFunction("index.indexPage", { name, tree });
+}

plugs/template/plug_api.ts

@@ -0,0 +1,24 @@
+import type { PageMeta } from "$sb/types.ts";
+import { system } from "../../plug-api/syscalls.ts";
+
+export function renderTemplate(
+  templateText: string,
+  pageMeta: PageMeta,
+  data: any = {},
+): Promise<string> {
+  return system.invokeFunction(
+    "template.renderTemplate",
+    templateText,
+    pageMeta,
+    data,
+  );
+}
+
+export function cleanTemplate(
+  templateText: string,
+): Promise<string> {
+  return system.invokeFunction(
+    "template.cleanTemplate",
+    templateText,
+  );
+}

plugs/template/template.plug.yaml

@@ -1,5 +1,19 @@
 name: template
 functions:
+  # API
+  renderTemplate:
+    path: api.ts:renderTemplate
+  cleanTemplate:
+    path: api.ts:cleanTemplate
+
+  insertTemplateText:
+    path: template.ts:insertTemplateText
+
+
+  indexTemplate:
+    path: ./index.ts:indexTemplate
+    events:
+    - page:indexTemplate
 
   templateSlashCommand:
     path: ./template.ts:templateSlashComplete
@@ -10,8 +24,6 @@ functions:
     path: ./template.ts:insertSlashTemplate
 
   # Template commands
-  insertTemplateText:
-    path: "./template.ts:insertTemplateText"
   applyLineReplace:
     path: ./template.ts:applyLineReplace
   insertFrontMatter:

plugs/template/template.ts

@@ -4,20 +4,19 @@ import { renderToText } from "$sb/lib/tree.ts";
 import { niceDate, niceTime } from "$sb/lib/dates.ts";
 import { readSettings } from "$sb/lib/settings_page.ts";
 import { cleanPageRef } from "$sb/lib/resolve.ts";
-import { ObjectValue, PageMeta } from "$sb/types.ts";
+import { PageMeta } from "$sb/types.ts";
 import { CompleteEvent, SlashCompletion } from "$sb/app_event.ts";
 import { getObjectByRef, queryObjects } from "../index/plug_api.ts";
-
-export type TemplateObject = ObjectValue<{
-  trigger?: string; // has to start with # for now
-  scope?: string;
-  frontmatter?: Record<string, any> | string;
-}>;
+import { TemplateObject } from "./types.ts";
+import { renderTemplate } from "./api.ts";
 
 export async function templateSlashComplete(
   completeEvent: CompleteEvent,
 ): Promise<SlashCompletion[]> {
-  const allTemplates = await queryObjects<TemplateObject>("template", {});
+  const allTemplates = await queryObjects<TemplateObject>("template", {
+    // Only return templates that have a trigger
+    filter: ["!=", ["attr", "trigger"], ["null"]],
+  });
   return allTemplates.map((template) => ({
     label: template.trigger!,
     detail: "template",
@@ -31,14 +30,7 @@ export async function insertSlashTemplate(slashCompletion: SlashCompletion) {
   const pageObject = await loadPageObject(slashCompletion.pageName);
 
   let templateText = await space.readPage(slashCompletion.templatePage);
-  templateText = await replaceTemplateVars(templateText, pageObject);
-  const parseTree = await markdown.parseMarkdown(templateText);
-  const frontmatter = await extractFrontmatter(parseTree, [], true);
-  templateText = renderToText(parseTree).trim();
-  if (frontmatter.frontmatter) {
-    templateText = "---\n" + (await YAML.stringify(frontmatter.frontmatter)) +
-      "---\n" + templateText;
-  }
+  templateText = await renderTemplate(templateText, pageObject);
 
   const cursorPos = await editor.getCursor();
   const carretPos = templateText.indexOf("|^|");
@@ -76,10 +68,12 @@ export async function instantiateTemplateCommand() {
   );
 
   const parseTree = await markdown.parseMarkdown(text);
-  const additionalPageMeta = await extractFrontmatter(parseTree, [
-    "$name",
-    "$disableDirectives",
-  ]);
+  const additionalPageMeta = await extractFrontmatter(parseTree, {
+    removeKeys: [
+      "$name",
+      "$disableDirectives",
+    ],
+  });
 
   const tempPageMeta: PageMeta = {
     tags: ["page"],

plugs/template/types.ts

@@ -0,0 +1,10 @@
+import { ObjectValue } from "$sb/types.ts";
+
+export type TemplateFrontmatter = {
+  trigger?: string; // slash command name
+  scope?: string;
+  // Frontmatter can be encoded as an object (in which case we'll serialize it) or as a string
+  frontmatter?: Record<string, any> | string;
+};
+
+export type TemplateObject = ObjectValue<TemplateFrontmatter>;

plugs/template/util.test.ts

@@ -0,0 +1,76 @@
+import { assertEquals } from "../../test_deps.ts";
+import { isTemplate } from "./util.ts";
+
+Deno.test("Test template extraction", () => {
+  assertEquals(
+    isTemplate(`---
+name: bla
+tags: template
+---
+
+Sup`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`---
+tags: template, something else
+---
+`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`---
+tags: something else, template
+---
+`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`---
+tags:
+- bla
+- template
+---
+`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`#template`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`  #template This is a template`),
+    true,
+  );
+
+  assertEquals(
+    isTemplate(`---
+tags:
+- bla
+somethingElse:
+- template
+---
+`),
+    false,
+  );
+
+  assertEquals(
+    isTemplate(`---
+name: bla
+tags: aefe
+---
+
+Sup`),
+    false,
+  );
+
+  assertEquals(
+    isTemplate(`Sup`),
+    false,
+  );
+});

plugs/template/util.ts

@@ -0,0 +1,47 @@
+const frontMatterRegex = /^---\n(([^\n]|\n)*?)---\n/;
+const yamlKvRegex = /^\s*(\w+):\s*(.*)/;
+const yamlListItemRegex = /^\s*-\s+(.+)/;
+
+/**
+ * Quick and dirty way to check if a page is a template or not
+ * @param pageText
+ * @returns
+ */
+export function isTemplate(pageText: string): boolean {
+  const frontmatter = frontMatterRegex.exec(pageText);
+  // Poor man's YAML frontmatter parsing
+  if (frontmatter) {
+    pageText = pageText.slice(frontmatter[0].length);
+    const frontmatterText = frontmatter[1];
+    const lines = frontmatterText.split("\n");
+    let inTagsSection = false;
+    for (const line of lines) {
+      const yamlKv = yamlKvRegex.exec(line);
+      if (yamlKv) {
+        const [key, value] = yamlKv.slice(1);
+        // Looking for a 'tags' key
+        if (key === "tags") {
+          inTagsSection = true;
+          // 'template' there? Yay!
+          if (value.split(/,\s*/).includes("template")) {
+            return true;
+          }
+        } else {
+          inTagsSection = false;
+        }
+      }
+      const yamlListem = yamlListItemRegex.exec(line);
+      if (yamlListem && inTagsSection) {
+        // List item is 'template'? Yay!
+        if (yamlListem[1] === "template") {
+          return true;
+        }
+      }
+    }
+  }
+  // Or if the page text starts with a #template tag
+  if (/^\s*#template(\W|$)/.test(pageText)) {
+    return true;
+  }
+  return false;
+}