Merge pull request #9258 from quarto-dev/bugfix/9255

Jupyter - support cells where typeof cell.source === "string"

news/changelog-1.5.md

@@ -65,6 +65,7 @@ All changes included in 1.5:
 - ([#8919](https://github.com/quarto-dev/quarto-cli/issues/8919)): Ensure enough backticks in `quarto convert` from `.ipynb` to `.qmd` files.
 - ([#8998](https://github.com/quarto-dev/quarto-cli/issues/8998)): Interpret slide separation markers `---` correctly when creating the `.ipynb` intermediate notebook from a `.qmd` file.
 - ([#9133](https://github.com/quarto-dev/quarto-cli/issues/9133)): Fix issue with Jupyter engine when using paths containing special characters.
+- ([#9255](https://github.com/quarto-dev/quarto-cli/issues/9255)): Support cell source fields of type `string`.
 
 ## Website Listings
 

src/command/convert/jupyter.ts

@@ -26,6 +26,10 @@ import { partitionCellOptions } from "../../core/lib/partition-cell-options.ts";
 import { Metadata } from "../../config/types.ts";
 import { jupyterKernelspec } from "../../core/jupyter/kernels.ts";
 import { fixupFrontMatter } from "../../core/jupyter/jupyter-fixups.ts";
+import {
+  jupyterCellSrcAsLines,
+  jupyterCellSrcAsStr,
+} from "../../core/jupyter/jupyter-shared.ts";
 
 export async function markdownToJupyterNotebook(
   file: string,
@@ -67,7 +71,9 @@ export async function jupyterNotebookToMarkdown(
         case "raw":
           // see if this is the front matter
           if (frontMatter === undefined) {
-            frontMatter = partitionYamlFrontMatter(cell.source.join(""))?.yaml;
+            frontMatter = partitionYamlFrontMatter(
+              jupyterCellSrcAsStr(cell),
+            )?.yaml;
             if (!frontMatter) {
               md.push(...mdFromRawCell(cellWithOptions));
             }
@@ -145,8 +151,11 @@ async function mdFromCodeCell(
   }
 
   // determine the largest number of backticks in the cell
+
   const maxBackticks = Math.max(
-    ...cell.source.map((line) => line.match(/^`+/g)?.[0].length || 0),
+    ...jupyterCellSrcAsLines(cell).map((line) =>
+      line.match(/^`+/g)?.[0].length || 0
+    ),
     2,
   );
   const backticks = "`".repeat(maxBackticks + 1);
@@ -155,7 +164,10 @@ async function mdFromCodeCell(
   const md: string[] = [backticks + "{" + language + "}\n"];
 
   // partition
-  const { yaml, source } = await partitionCellOptions(language, cell.source);
+  const { yaml, source } = await partitionCellOptions(
+    language,
+    jupyterCellSrcAsLines(cell),
+  );
   const options = yaml ? yaml as JupyterCellOptions : {};
 
   if (!includeIds) {

src/core/jupyter/jupyter-filters.ts

@@ -1,9 +1,8 @@
 /*
-* jupyter-filters.ts
-*
-* Copyright (C) 2020-2022 Posit Software, PBC
-*
-*/
+ * jupyter-filters.ts
+ *
+ * Copyright (C) 2020-2022 Posit Software, PBC
+ */
 
 import { existsSync } from "fs/exists.ts";
 import { basename, dirname, isAbsolute, join } from "../../deno_ral/path.ts";
@@ -19,6 +18,7 @@ import {
 } from "./filtered-notebook-cache.ts";
 import { fixupFrontMatter } from "./jupyter-fixups.ts";
 import { JupyterNotebook } from "./types.ts";
+import { jupyterCellSrcAsStr } from "./jupyter-shared.ts";
 
 export async function markdownFromNotebookFile(file: string, format?: Format) {
   // read file with any filters
@@ -36,7 +36,7 @@ export function markdownFromNotebookJSON(nb: JupyterNotebook) {
 
   const markdown = nb.cells.reduce((md, cell) => {
     if (["markdown", "raw"].includes(cell.cell_type)) {
-      return md + "\n" + cell.source.join("") + "\n";
+      return md + "\n" + jupyterCellSrcAsStr(cell) + "\n";
     } else {
       return md;
     }

src/core/jupyter/jupyter-fixups.ts

@@ -13,6 +13,10 @@ import { lines } from "../lib/text.ts";
 import { markdownWithExtractedHeading } from "../pandoc/pandoc-partition.ts";
 import { partitionYamlFrontMatter, readYamlFromMarkdown } from "../yaml.ts";
 import { JupyterNotebook, JupyterOutput } from "./types.ts";
+import {
+  jupyterCellSrcAsLines,
+  jupyterCellSrcAsStr,
+} from "./jupyter-shared.ts";
 
 export function fixupStreams(nb: JupyterNotebook): JupyterNotebook {
   for (const cell of nb.cells) {
@@ -155,7 +159,8 @@ export function fixupFrontMatter(nb: JupyterNotebook): JupyterNotebook {
   let partitioned: { yaml: string; markdown: string } | undefined;
   const frontMatterCellIndex = nb.cells.findIndex((cell) => {
     if (cell.cell_type === "raw" || cell.cell_type === "markdown") {
-      partitioned = partitionYamlFrontMatter(cell.source.join("")) || undefined;
+      partitioned = partitionYamlFrontMatter(jupyterCellSrcAsStr(cell)) ||
+        undefined;
       if (partitioned) {
         cell.cell_type = "raw";
         return true;
@@ -179,7 +184,7 @@ export function fixupFrontMatter(nb: JupyterNotebook): JupyterNotebook {
     if (cell.cell_type === "markdown") {
       const { lines, headingText, contentBeforeHeading } =
         markdownWithExtractedHeading(
-          nbLines(cell.source).join(""),
+          nbLines(jupyterCellSrcAsLines(cell)).join(""),
         );
       if (headingText && !contentBeforeHeading) {
         title = headingText;

src/core/jupyter/jupyter-shared.ts

@@ -12,8 +12,21 @@ import { pathWithForwardSlashes } from "../path.ts";
 
 import { pythonExecForCaps } from "./exec.ts";
 import { jupyterKernelspecs } from "./kernels.ts";
-import { JupyterCapabilities, JupyterKernelspec } from "./types.ts";
+import {
+  JupyterCapabilities,
+  JupyterCell,
+  JupyterKernelspec,
+} from "./types.ts";
 import { isEnvDir } from "./capabilities.ts";
+import { lines } from "../lib/text.ts";
+
+export const jupyterCellSrcAsStr = (cell: JupyterCell) => {
+  return typeof cell.source === "string" ? cell.source : cell.source.join("");
+};
+
+export const jupyterCellSrcAsLines = (cell: JupyterCell) => {
+  return typeof cell.source === "string" ? lines(cell.source) : cell.source;
+};
 
 export async function jupyterCapabilitiesMessage(
   caps: JupyterCapabilities,

src/core/jupyter/jupyter.ts

@@ -169,6 +169,10 @@ import {
   resolveUserExpressions,
   userExpressionsFromCell,
 } from "./jupyter-inline.ts";
+import {
+  jupyterCellSrcAsLines,
+  jupyterCellSrcAsStr,
+} from "./jupyter-shared.ts";
 
 export const kQuartoMimeType = "quarto_mimetype";
 export const kQuartoOutputOrder = "quarto_order";
@@ -349,7 +353,7 @@ export async function quartoMdToJupyter(
       }
       if (cell_type === "raw" && frontMatter) {
         // delete 'jupyter' metadata since we've already transferred it
-        const yaml = readYamlFromMarkdown(cell.source.join(""));
+        const yaml = readYamlFromMarkdown(jupyterCellSrcAsStr(cell));
         if (yaml.jupyter) {
           delete yaml.jupyter;
           // write the cell only if there is metadata to write
@@ -371,9 +375,12 @@ export async function quartoMdToJupyter(
         }
       } else if (cell_type === "code") {
         // see if there is embedded metadata we should forward into the cell metadata
+        const cellSrcLines = typeof cell.source === "string"
+          ? lines(cell.source)
+          : cell.source;
         const { yaml, source } = partitionCellOptions(
           kernelspec.language.toLowerCase(),
-          cell.source,
+          cellSrcLines,
         );
         if (yaml && !Array.isArray(yaml) && typeof yaml === "object") {
           // use label as id if necessary
@@ -412,7 +419,10 @@ export async function quartoMdToJupyter(
       }
 
       // if the source is empty then don't add it
-      cell.source = trimEmptyLines(cell.source);
+      const cellSrcLines = typeof cell.source === "string"
+        ? lines(cell.source)
+        : cell.source;
+      cell.source = trimEmptyLines(cellSrcLines);
       if (cell.source.length > 0) {
         nb.cells.push(cell);
       }
@@ -777,7 +787,9 @@ export async function jupyterToMarkdown(
           // If this is the front matter cell, don't wrap it in
           // a cell envelope, as it need to be remain discoverable
           if (frontMatter === undefined) {
-            frontMatter = partitionYamlFrontMatter(cell.source.join(""))?.yaml;
+            frontMatter = partitionYamlFrontMatter(
+              jupyterCellSrcAsStr(cell),
+            )?.yaml;
             if (frontMatter) {
               markdownOptions.preserveCellMetadata = false;
             }
@@ -858,7 +870,7 @@ export function jupyterCellWithOptions(
 ): JupyterCellWithOptions {
   const { yaml, optionsSource, source } = partitionCellOptions(
     language,
-    cell.source,
+    jupyterCellSrcAsLines(cell),
   );
 
   // read any options defined in cell metadata
@@ -1026,7 +1038,7 @@ export function mdFromRawCell(
 
   const mimeType = cell.metadata?.[kCellRawMimeType];
   if (mimeType) {
-    const rawOutput = mdRawOutput(mimeType, cell.source);
+    const rawOutput = mdRawOutput(mimeType, jupyterCellSrcAsLines(cell));
     if (rawOutput) {
       return rawCellEnvelope(cell.id, rawOutput);
     }
@@ -1402,7 +1414,7 @@ async function mdFromCodeCell(
   if (includeCode(cell, options) || options.preserveCodeCellYaml) {
     const fenced = echoFenced(cell, options);
     const ticks = "`".repeat(
-      Math.max(countTicks(cell.source) + 1, fenced ? 4 : 3),
+      Math.max(countTicks(jupyterCellSrcAsLines(cell)) + 1, fenced ? 4 : 3),
     );
 
     md.push(ticks + " {");

src/core/jupyter/types.ts

@@ -104,7 +104,7 @@ export interface JupyterCell {
   cell_type: "markdown" | "code" | "raw";
   execution_count?: null | number;
   metadata: JupyterCellMetadata;
-  source: string[];
+  source: string | string[];
   attachments?: Record<string, Record<string, string>>;
   outputs?: JupyterOutput[];
 }