Simple embed support for notebooks

Author: dragonstyle

src/core/handlers/embed.ts

@@ -0,0 +1,120 @@
+/*
+* embed.ts
+*
+* Copyright (C) 2022 by RStudio, PBC
+*
+*/
+
+import { LanguageCellHandlerContext, LanguageHandler } from "./types.ts";
+import { baseHandler, install } from "./base.ts";
+import {
+  EitherString,
+  mappedConcat,
+  MappedString,
+} from "../lib/mapped-text.ts";
+
+import { DirectiveCell } from "../lib/break-quarto-md-types.ts";
+import { jupyterAssets } from "../jupyter/jupyter.ts";
+
+import {
+  notebookForAddress,
+  notebookMarkdown,
+  parseNotebookPath,
+} from "./include-notebook.ts";
+import { JupyterCell } from "../jupyter/types.ts";
+
+interface EmbedHandler {
+  name: string;
+  handle(
+    filename: string,
+    handlerContext: LanguageCellHandlerContext,
+  ): Promise<{
+    handled: boolean;
+    markdownFragments: EitherString[];
+  }>;
+}
+
+const kHandlers: EmbedHandler[] = [
+  {
+    name: "Jupyter Notebook Embed",
+    async 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 nb = notebookForAddress(
+          notebookAddress,
+          (cell: JupyterCell) => {
+            cell.metadata["echo"] = false;
+            cell.metadata["warning"] = false;
+            cell.metadata["output"] = "asis";
+            return cell;
+          },
+        );
+        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(
+          nb,
+          assets,
+          handlerContext.options.context,
+          handlerContext.options.flags,
+        );
+        if (markdown) {
+          markdownFragments.push(markdown);
+        }
+        return {
+          handled: true,
+          markdownFragments,
+        };
+      } else {
+        return {
+          handled: false,
+          markdownFragments: [],
+        };
+      }
+    },
+  },
+];
+
+const embedHandler: LanguageHandler = {
+  ...baseHandler,
+
+  languageName: "embed",
+
+  type: "directive",
+  stage: "pre-engine",
+
+  async directive(
+    handlerContext: LanguageCellHandlerContext,
+    directive: DirectiveCell,
+  ): Promise<MappedString> {
+    const textFragments: EitherString[] = [];
+
+    // The first parameter is a path to a file
+    const filename = directive.shortcode.params[0];
+    if (!filename) {
+      throw new Error("Embed directive needs filename as a parameter");
+    }
+
+    // Go through handlers until one handles the embed by returning markdown
+    for (const handler of kHandlers) {
+      const result = await handler.handle(filename, handlerContext);
+      if (result.handled) {
+        textFragments.push(...result.markdownFragments);
+        break;
+      }
+    }
+
+    // Return the markdown
+    return mappedConcat(textFragments);
+  },
+};
+
+install(embedHandler);

src/core/handlers/handlers.ts

@@ -8,3 +8,4 @@
 import "./mermaid.ts";
 import "./include.ts";
 import "./dot.ts";
+import "./embed.ts";

src/core/handlers/include-notebook.ts

@@ -33,8 +33,9 @@ import {
 } from "../jupyter/types.ts";
 
 import { dirname, extname } from "path/mod.ts";
+import { Cell } from "https://deno.land/x/[email protected]/table/cell.ts";
 
-export interface NotebookInclude {
+export interface NotebookAddress {
   path: string;
   cellIds: string[] | undefined;
   params: Record<string, string>;
@@ -59,14 +60,15 @@ export function parseNotebookPath(path: string) {
     return {
       path,
       cellIds,
-    } as NotebookInclude;
+    } as NotebookAddress;
   } else {
     return undefined;
   }
 }
 
-export function notebookForInclude(
-  nbInclude: NotebookInclude,
+export function notebookForAddress(
+  nbInclude: NotebookAddress,
+  filter?: (cell: JupyterCell) => JupyterCell,
 ) {
   try {
     const nb = jupyterFromFile(nbInclude.path);
@@ -96,6 +98,11 @@ export function notebookForInclude(
       }
       nb.cells = cells;
     }
+
+    if (filter) {
+      nb.cells = nb.cells.map(filter);
+    }
+
     return nb;
   } catch (ex) {
     throw new Error(`Failed to read included notebook ${nbInclude.path}`, ex);

src/core/handlers/include.ts

@@ -21,7 +21,7 @@ import { DirectiveCell } from "../lib/break-quarto-md-types.ts";
 import { jupyterAssets } from "../jupyter/jupyter.ts";
 
 import {
-  notebookForInclude,
+  notebookForAddress,
   notebookMarkdown,
   parseNotebookPath,
 } from "./include-notebook.ts";
@@ -58,7 +58,7 @@ const includeHandler: LanguageHandler = {
       if (notebookInclude) {
         // This is a notebook include, so read the notebook (including only
         // the cells that are specified in the include and include them)
-        const nb = notebookForInclude(
+        const nb = notebookForAddress(
           notebookInclude,
         );
         const assets = jupyterAssets(