Use placeholders

This ensures that we render the document in the context of any output format (allowing the notebook to provide format specific assets and outputs).

Author: dragonstyle

src/command/render/render.ts

@@ -50,6 +50,7 @@ import {
   withTimingAsync,
 } from "../../core/timing.ts";
 import { filesDirMediabagDir } from "./render-paths.ts";
+import { replaceNotebookPlaceholders } from "../../core/handlers/include-notebook.ts";
 
 export async function renderPandoc(
   file: ExecutedFile,
@@ -103,9 +104,18 @@ export async function renderPandoc(
   const mediabagDir = filesDirMediabagDir(context.target.source);
   ensureDirSync(join(dirname(context.target.source), mediabagDir));
 
+  // Process any placeholder for notebooks that have been injected
+  const markdown = await replaceNotebookPlaceholders(
+    format.pandoc.to || "html",
+    context.target.source,
+    context,
+    context.options.flags || {},
+    executeResult.markdown,
+  );
+
   // pandoc options
   const pandocOptions: PandocOptions = {
-    markdown: executeResult.markdown,
+    markdown,
     source: context.target.source,
     output: recipe.output,
     keepYaml: recipe.keepYaml,

src/core/handlers/embed.ts

@@ -14,9 +14,11 @@ import {
 } from "../lib/mapped-text.ts";
 
 import { DirectiveCell } from "../lib/break-quarto-md-types.ts";
-import { jupyterAssets } from "../jupyter/jupyter.ts";
 
-import { notebookMarkdown, parseNotebookPath } from "./include-notebook.ts";
+import {
+  notebookMarkdownPlaceholder,
+  parseNotebookPath,
+} from "./include-notebook.ts";
 
 interface EmbedHandler {
   name: string;
@@ -32,43 +34,30 @@ interface EmbedHandler {
 const kHandlers: EmbedHandler[] = [
   {
     name: "Jupyter Notebook Embed",
-    async handle(filename: string, handlerContext: LanguageCellHandlerContext) {
+    handle(filename: string, handlerContext: LanguageCellHandlerContext) {
       const markdownFragments: EitherString[] = [];
 
       // Resolve the filename into a path
       const path = handlerContext.resolvePath(filename);
 
       const notebookAddress = parseNotebookPath(path);
       if (notebookAddress) {
-        const assets = jupyterAssets(
-          handlerContext.options.context.target.source,
-          handlerContext.options.context.format.pandoc.to,
-        );
-
-        // Render the notebook markdown and inject it
-        const markdown = await notebookMarkdown(
-          notebookAddress,
-          assets,
-          handlerContext.options.context,
-          handlerContext.options.flags,
-          {
-            echo: false,
-            warning: false,
-            asis: true,
-          },
-        );
-        if (markdown) {
-          markdownFragments.push(markdown);
-        }
-        return {
+        const placeHolder = notebookMarkdownPlaceholder(path, {
+          echo: false,
+          warning: false,
+          asis: true,
+        });
+
+        markdownFragments.push(placeHolder);
+        return Promise.resolve({
           handled: true,
           markdownFragments,
-        };
+        });
       } else {
-        return {
+        return Promise.resolve({
           handled: false,
           markdownFragments: [],
-        };
+        });
       }
     },
   },

src/core/handlers/include-notebook.ts

@@ -9,7 +9,11 @@ import { resourcePath } from "../resources.ts";
 
 import { languages } from "./base.ts";
 
-import { jupyterFromFile, jupyterToMarkdown } from "../jupyter/jupyter.ts";
+import {
+  jupyterAssets,
+  jupyterFromFile,
+  jupyterToMarkdown,
+} from "../jupyter/jupyter.ts";
 
 import {
   kCellLabel,
@@ -108,24 +112,25 @@ async function getCellOutputs(
   };
   const optionsKey = options
     ? Object.keys(options).reduce((key, current) => {
-      return current + boolkey(key, options[key]);
+      if (options[key] !== undefined) {
+        return current + boolkey(key, options[key]!);
+      } else {
+        return current;
+      }
     }, "")
     : "";
   const notebookKey = `${nbAddress.path}-${optionsKey}`;
 
-  // TODO: Ensure that we're properly dealing with formats for includes
-  // (e.g. docx / pdf
-
   const lifetime = getNamedLifetime("render-file");
-  /*
   if (lifetime === undefined) {
     throw new Error("Internal Error: named lifetime render-file not found");
-  }*/
-  const nbCache = lifetime
-    ? lifetime.get("notebook-cache") as unknown as JupyterNotebookOutputCache
-    : undefined ||
-      {};
+  }
+
+  const nbCache =
+    lifetime.get("notebook-cache") as unknown as JupyterNotebookOutputCache ||
+    {};
 
+  // TODO: Cache is always missing because we never attach
   if (!nbCache[notebookKey]) {
     // Render the notebook and place it in the cache
     // Read and filter notebook
@@ -183,20 +188,98 @@ async function getCellOutputs(
     );
     nbCache[notebookKey] = { outputs: result.cellOutputs };
 
+    const cacheWithLifetime = {
+      ...nbCache,
+      cleanup: () => {
+      },
+    };
+
+    lifetime.attach(cacheWithLifetime, "notebook-cache");
     // TODO: set this back into the lifetime
   }
   return nbCache[notebookKey].outputs;
 }
 
-export interface JupyterMarkdownOptions extends Record<string, boolean> {
-  echo: boolean;
-  warning: boolean;
-  asis: boolean;
+export interface JupyterMarkdownOptions
+  extends Record<string, boolean | undefined> {
+  echo?: boolean;
+  warning?: boolean;
+  asis?: boolean;
 }
+
 const kEcho = "echo";
 const kWarning = "warning";
 const kOutput = "output";
 
+export function notebookMarkdownPlaceholder(
+  path: string,
+  options: JupyterMarkdownOptions,
+) {
+  return `<!-- 12A0366C:${path} | ${optionsToPlaceholder(options)} -->`;
+}
+
+const kPlaceholderRegex = /<!-- 12A0366C:(.*?) \| (.*?) -->/;
+export async function replaceNotebookPlaceholders(
+  to: string,
+  input: string,
+  context: RenderContext,
+  flags: RenderFlags,
+  markdown: string,
+) {
+  let match = kPlaceholderRegex.exec(markdown);
+  while (match) {
+    const nbPath = match[1];
+    const optionPlaceholder = match[2];
+    const nbOptions = optionPlaceholder
+      ? placeholderToOptions(optionPlaceholder)
+      : {};
+    const nbAddress = parseNotebookPath(nbPath);
+    if (nbAddress) {
+      const assets = jupyterAssets(
+        input,
+        to,
+      );
+
+      // Render the notebook markdown and inject it
+      const nbMarkdown = await notebookMarkdown(
+        nbAddress,
+        assets,
+        context,
+        flags,
+        nbOptions,
+      );
+
+      markdown = markdown.replaceAll(match[0], nbMarkdown);
+    }
+
+    match = kPlaceholderRegex.exec(markdown);
+  }
+  kPlaceholderRegex.lastIndex = 0;
+  return markdown;
+}
+
+function optionsToPlaceholder(options: JupyterMarkdownOptions) {
+  return Object.keys(options).map((key) => {
+    return `${key}:${String(options[key])}`;
+  }).join(",");
+}
+
+function placeholderToOptions(placeholder: string) {
+  const parts = placeholder.split(",");
+  const options: JupyterMarkdownOptions = {};
+  for (const part of parts) {
+    const kv = part.split(":");
+    if (kv.length > 1) {
+      const key = part.split(":")[0];
+      const value = part.split(":").slice(1).join(":");
+      options[key] = Boolean(value);
+    } else {
+      throw new Error("Unexpected placeholder for notebook option: " + part);
+    }
+  }
+  return options;
+}
+
 export async function notebookMarkdown(
   nbAddress: NotebookAddress,
   assets: JupyterAssets,

src/core/handlers/include.ts

@@ -18,9 +18,11 @@ import {
 import { rangedLines } from "../lib/ranged-text.ts";
 import { isBlockShortcode } from "../lib/parse-shortcode.ts";
 import { DirectiveCell } from "../lib/break-quarto-md-types.ts";
-import { jupyterAssets } from "../jupyter/jupyter.ts";
 
-import { notebookMarkdown, parseNotebookPath } from "./include-notebook.ts";
+import {
+  notebookMarkdownPlaceholder,
+  parseNotebookPath,
+} from "./include-notebook.ts";
 
 const includeHandler: LanguageHandler = {
   ...baseHandler,
@@ -48,27 +50,10 @@ const includeHandler: LanguageHandler = {
         );
       }
 
-      // Handle notebooks directly by extracting the items
-      // from the notebook
       const notebookAddress = parseNotebookPath(path);
       if (notebookAddress) {
-        // This is a notebook include, so read the notebook (including only
-        // the cells that are specified in the include and include them)
-        const assets = jupyterAssets(
-          source,
-          handlerContext.options.context.format.pandoc.to,
-        );
-
-        // Render the notebook markdown and inject it
-        const markdown = await notebookMarkdown(
-          notebookAddress,
-          assets,
-          handlerContext.options.context,
-          handlerContext.options.flags,
-        );
-        if (markdown) {
-          textFragments.push(markdown);
-        }
+        const placeHolder = notebookMarkdownPlaceholder(path, {});
+        textFragments.push(placeHolder);
       } else {
         let includeSrc;
         try {