refector into a more final form

dragonstyle · dragonstyle · commit 63fcd10efef9 · 2022-11-22T14:06:30.000-05:00
diff --git a/src/command/render/render-contexts.ts b/src/command/render/render-contexts.ts
@@ -250,6 +250,7 @@ export async function renderContexts(
         format: context.format,
         markdown: context.target.markdown,
         context,
+        flags: options.flags || {} as RenderFlags,
         stage: "pre-engine",
       };
 
diff --git a/src/command/render/render-files.ts b/src/command/render/render-files.ts
@@ -53,6 +53,7 @@ import {
   RenderExecuteOptions,
   RenderFile,
   RenderFilesResult,
+  RenderFlags,
   RenderOptions,
 } from "./types.ts";
 import { error, info, warning } from "log/mod.ts";
@@ -443,6 +444,7 @@ export async function renderFiles(
             format: recipe.format,
             markdown: mappedMarkdown!,
             context,
+            flags: options.flags || {} as RenderFlags,
             stage: "post-engine",
           };
 
diff --git a/src/core/handlers/include-notebook.ts b/src/core/handlers/include-notebook.ts
@@ -0,0 +1,168 @@
+/*
+* include-notebook.ts
+*
+* Copyright (C) 2022 by RStudio, PBC
+*
+*/
+
+import { resourcePath } from "../resources.ts";
+
+import { languages } from "./base.ts";
+
+import { jupyterFromFile, jupyterToMarkdown } from "../jupyter/jupyter.ts";
+
+import {
+  kFigDpi,
+  kFigFormat,
+  kFigPos,
+  kKeepHidden,
+} from "../../config/constants.ts";
+import {
+  isHtmlCompatible,
+  isIpynbOutput,
+  isLatexOutput,
+  isMarkdownOutput,
+  isPresentationOutput,
+} from "../../config/format.ts";
+import { resolveParams } from "../../command/render/flags.ts";
+import { RenderContext, RenderFlags } from "../../command/render/types.ts";
+import {
+  JupyterAssets,
+  JupyterCell,
+  JupyterNotebook,
+} from "../jupyter/types.ts";
+
+import { dirname, extname } from "path/mod.ts";
+
+export interface NotebookInclude {
+  path: string;
+  cellIds: string[] | undefined;
+  params: Record<string, string>;
+}
+
+const resolveCellIds = (hash: string) => {
+  if (hash.indexOf(",") > 0) {
+    return hash.split(",");
+  } else {
+    return hash;
+  }
+};
+
+// If the path is a notebook path, then process it separately.
+const kPlaceholderProtocol = "ipynb://";
+export function parseNotebookPath(path: string) {
+  if (!path.startsWith(kPlaceholderProtocol)) {
+    path = `${kPlaceholderProtocol}/${path}`;
+  }
+  const url = new URL(path);
+  const pathname = url.pathname;
+  if (extname(pathname) === ".ipynb") {
+    const hash = url.hash;
+    const cellIds = resolveCellIds(hash);
+    return {
+      path: pathname,
+      cellIds,
+    } as NotebookInclude;
+  } else {
+    return undefined;
+  }
+}
+
+export function notebookForInclude(
+  nbInclude: NotebookInclude,
+  context: RenderContext,
+) {
+  const nb = jupyterFromFile(nbInclude.path);
+  const cells: JupyterCell[] = [];
+
+  // If cellIds are present, filter the notebook to only include
+  // those cells
+  if (nbInclude.cellIds) {
+    for (const cell of nb.cells) {
+      // cellId can either by a literal cell Id, or a tag with that value
+      const hasId = cell.id ? nbInclude.cellIds.includes(cell.id) : false;
+      if (hasId) {
+        // It's an ID
+        cells.push(cell);
+      } else {
+        // Check tags
+        const hasTag = cell.metadata.tags
+          ? cell.metadata.tags.find((tag) =>
+            nbInclude.cellIds?.includes(tag)
+          ) !==
+            undefined
+          : false;
+        if (hasTag) {
+          cells.push(cell);
+        }
+      }
+    }
+    nb.cells = cells;
+  }
+
+  // Read any notebook metadata
+  const notebookMetadata = context.format.metadata["notebook"] as Record<
+    string,
+    unknown
+  >;
+
+  // Resolve any execution options from the notebook metadata
+  nb.cells = nb.cells.map((cell) => {
+    cell.metadata = {
+      "echo": false,
+      "warning": false,
+      ...notebookMetadata,
+      ...cell.metadata,
+    };
+    return cell;
+  });
+
+  return nb;
+}
+
+export async function notebookMarkdown(
+  notebook: JupyterNotebook,
+  assets: JupyterAssets,
+  context: RenderContext,
+  flags: RenderFlags,
+) {
+  const format = context.format;
+  const executeOptions = {
+    target: context.target,
+    resourceDir: resourcePath(),
+    tempDir: context.options.services.temp.createDir(),
+    dependencies: true,
+    libDir: context.libDir,
+    format: context.format,
+    projectDir: context.project?.dir,
+    cwd: flags.executeDir ||
+      dirname(Deno.realPathSync(context.target.source)),
+    params: resolveParams(flags.params, flags.paramsFile),
+    quiet: flags.quiet,
+    previewServer: context.options.previewServer,
+    handledLanguages: languages(),
+  };
+  const result = await jupyterToMarkdown(
+    notebook,
+    {
+      executeOptions,
+      language: notebook.metadata.kernelspec.language.toLowerCase(),
+      assets,
+      execute: format.execute,
+      keepHidden: format.render[kKeepHidden],
+      toHtml: isHtmlCompatible(format),
+      toLatex: isLatexOutput(format.pandoc),
+      toMarkdown: isMarkdownOutput(format.pandoc),
+      toIpynb: isIpynbOutput(format.pandoc),
+      toPresentation: isPresentationOutput(format.pandoc),
+      figFormat: format.execute[kFigFormat],
+      figDpi: format.execute[kFigDpi],
+      figPos: format.render[kFigPos],
+    },
+  );
+  if (result) {
+    return result.markdown;
+  } else {
+    return undefined;
+  }
+}
diff --git a/src/core/handlers/include.ts b/src/core/handlers/include.ts
@@ -6,7 +6,7 @@
 */
 
 import { LanguageCellHandlerContext, LanguageHandler } from "./types.ts";
-import { baseHandler, install, languages } from "./base.ts";
+import { baseHandler, install } from "./base.ts";
 import {
   asMappedString,
   EitherString,
@@ -18,32 +18,13 @@ 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,
-  jupyterFromFile,
-  jupyterToMarkdown,
-} from "../jupyter/jupyter.ts";
+import { jupyterAssets } from "../jupyter/jupyter.ts";
 
-import { dirname, extname } from "path/mod.ts";
-import {
-  kFigDpi,
-  kFigFormat,
-  kFigPos,
-  kKeepHidden,
-} from "../../config/constants.ts";
 import {
-  isHtmlCompatible,
-  isIpynbOutput,
-  isLatexOutput,
-  isMarkdownOutput,
-  isPresentationOutput,
-} from "../../config/format.ts";
-import { resourcePath } from "../resources.ts";
-import { resolveParams } from "../../command/render/flags.ts";
-import { RenderFlags } from "../../command/render/types.ts";
-import { callbackify } from "https://deno.land/std@0.153.0/node/util.ts";
-import { translationsForLang } from "../language.ts";
-import { JupyterCell } from "../jupyter/types.ts";
+  notebookForInclude,
+  notebookMarkdown,
+  parseNotebookPath,
+} from "./include-notebook.ts";
 
 const includeHandler: LanguageHandler = {
   ...baseHandler,
@@ -71,105 +52,30 @@ const includeHandler: LanguageHandler = {
         );
       }
 
-      // If the path is a notebook path, then process it separately.
-      const parseNotebookPath = (path: string) => {
-        if (path.includes("#")) {
-          const pathParts = path.split("#");
-          const filePath = pathParts[0];
-          const cellId = pathParts.slice(1);
-          return {
-            path: filePath,
-            cellId,
-          };
-        } else {
-          const ext = extname(path);
-          if (ext === ".ipynb") {
-            return {
-              path,
-            };
-          } else {
-            return undefined;
-          }
-        }
-      };
-
-      const notebookPath = parseNotebookPath(path);
-      if (notebookPath) {
-        const nb = jupyterFromFile(notebookPath.path);
+      // Handle notebooks directly by extracting the items
+      // from the notebook
+      const notebookInclude = parseNotebookPath(path);
+      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(
+          notebookInclude,
+          handlerContext.options.context,
+        );
         const assets = jupyterAssets(
           source,
           handlerContext.options.context.format.pandoc.to,
         );
 
-        const cells: JupyterCell[] = [];
-
-        // filter the notebook
-        if (notebookPath.cellId) {
-          for (const cell of nb.cells) {
-            const hasId = cell.id
-              ? notebookPath.cellId.includes(cell.id)
-              : false;
-            if (hasId) {
-              cells.push(cell);
-            } else {
-              const hasTag = cell.metadata.tags
-                ? cell.metadata.tags.find((tag) =>
-                  notebookPath.cellId.includes(tag)
-                ) !== undefined
-                : false;
-              if (hasTag) {
-                cells.push(cell);
-              }
-            }
-          }
-        }
-        nb.cells = cells.map((cell) => {
-          cell.metadata = {
-            ...cell.metadata,
-            "echo": false,
-          };
-          return cell;
-        });
-
-        const options = handlerContext.options;
-        const context = options.context;
-        const flags: RenderFlags = {};
-
-        const executeOptions = {
-          target: context.target,
-          resourceDir: resourcePath(),
-          tempDir: context.options.services.temp.createDir(),
-          dependencies: true,
-          libDir: context.libDir,
-          format: context.format,
-          projectDir: context.project?.dir,
-          cwd: flags.executeDir ||
-            dirname(Deno.realPathSync(context.target.source)),
-          params: resolveParams(flags.params, flags.paramsFile),
-          quiet: flags.quiet,
-          previewServer: context.options.previewServer,
-          handledLanguages: languages(),
-        };
-        const result = await jupyterToMarkdown(
+        // Render the notebook markdown and inject it
+        const markdown = await notebookMarkdown(
           nb,
-          {
-            executeOptions,
-            language: nb.metadata.kernelspec.language.toLowerCase(),
-            assets,
-            execute: options.format.execute,
-            keepHidden: options.format.render[kKeepHidden],
-            toHtml: isHtmlCompatible(options.format),
-            toLatex: isLatexOutput(options.format.pandoc),
-            toMarkdown: isMarkdownOutput(options.format.pandoc),
-            toIpynb: isIpynbOutput(options.format.pandoc),
-            toPresentation: isPresentationOutput(options.format.pandoc),
-            figFormat: options.format.execute[kFigFormat],
-            figDpi: options.format.execute[kFigDpi],
-            figPos: options.format.render[kFigPos],
-          },
+          assets,
+          handlerContext.options.context,
+          handlerContext.options.flags,
         );
-        if (result) {
-          textFragments.push(result.markdown);
+        if (markdown) {
+          textFragments.push(markdown);
         }
       } else {
         let includeSrc;
diff --git a/src/core/handlers/types.ts b/src/core/handlers/types.ts
@@ -1,4 +1,4 @@
-import { RenderContext } from "../../command/render/types.ts";
+import { RenderContext, RenderFlags } from "../../command/render/types.ts";
 import {
   kIncludeAfterBody,
   kIncludeBeforeBody,
@@ -32,6 +32,8 @@ export interface LanguageCellHandlerOptions {
 
   context: RenderContext;
 
+  flags: RenderFlags;
+
   // per-document state, so that different handlers can share state as needed.
   state?: Record<string, Record<string, unknown>>;
 }
