Merge pull request #3429 from quarto-dev/feature/notebooks

Feature/notebooks

Author: dragonstyle

news/changelog-1.3.md

@@ -1,5 +1,10 @@
 ## Changes
 
+## Jupyter Notebooks
+
+- Add support for including cells from in quarto documents using `{{< include >}}`. This includes the cell (including code) as if the cell were inline in the document.
+- Add support for embedding cells in quarto documents using `{{< embed >}}`. This embeds only output from a cell, asis.
+
 ## HTML Format
 
 - Improved handling of margin references that appear within a callout. ([#3003](https://github.com/quarto-dev/quarto-cli/issues/3003))

src/command/render/latexmk/latexmk.ts

@@ -24,6 +24,8 @@ import { OutputRecipe } from "../types.ts";
 import { generatePdf } from "./pdf.ts";
 import { LatexmkOptions } from "./types.ts";
 import { texToPdfOutputRecipe } from "../output-tex.ts";
+import { join } from "path/mod.ts";
+import { dirAndStem } from "../../../core/path.ts";
 
 export function useQuartoLatexmk(
   format: Format,
@@ -57,7 +59,7 @@ export function quartoLatexmkOutputRecipe(
   // output dir
   const outputDir = format.render[kLatexOutputDir];
 
-  const pdfGenerator = (
+  const generate = (
     input: string,
     format: Format,
     pandocOptions: PandocOptions,
@@ -87,13 +89,24 @@ export function quartoLatexmkOutputRecipe(
     return generatePdf(mkOptions);
   };
 
+  const computePath = (input: string, format: Format) => {
+    const [cwd, stem] = dirAndStem(input);
+    const mkOutputdir = format.render[kLatexOutputDir];
+    return mkOutputdir
+      ? join(mkOutputdir, stem + ".pdf")
+      : join(cwd, stem + ".pdf");
+  };
+
   return texToPdfOutputRecipe(
     input,
     finalOutput,
     options,
     format,
     "latex",
-    pdfGenerator,
+    {
+      generate,
+      computePath,
+    },
     outputDir,
   );
 }

src/command/render/output-tex.ts

@@ -21,11 +21,14 @@ import { OutputRecipe } from "./types.ts";
 import { pdfEngine } from "../../config/pdf.ts";
 import { execProcess } from "../../core/process.ts";
 
-export type PdfGenerator = (
-  input: string,
-  format: Format,
-  pandocOptions: PandocOptions,
-) => Promise<string>;
+export interface PdfGenerator {
+  generate: (
+    input: string,
+    format: Format,
+    pandocOptions: PandocOptions,
+  ) => Promise<string>;
+  computePath: (input: string, format: Format) => string;
+}
 
 export function texToPdfOutputRecipe(
   input: string,
@@ -58,25 +61,14 @@ export function texToPdfOutputRecipe(
   // ouptut to the user's requested destination
   const complete = async (pandocOptions: PandocOptions) => {
     const input = join(inputDir, output);
-    const pdfOutput = await pdfGenerator(input, format, pandocOptions);
+    const pdfOutput = await pdfGenerator.generate(input, format, pandocOptions);
 
     // keep tex if requested
     const compileTex = join(inputDir, output);
     if (!format.render[kKeepTex]) {
       Deno.removeSync(compileTex);
     }
 
-    const normalizePath = (input: string, output: string) => {
-      if (isAbsolute(output)) {
-        return output;
-      } else {
-        return relative(
-          Deno.realPathSync(dirname(input)),
-          Deno.realPathSync(output),
-        );
-      }
-    };
-
     // copy (or write for stdout) compiled pdf to final output location
     if (finalOutput) {
       if (finalOutput === kStdOut) {
@@ -111,6 +103,10 @@ export function texToPdfOutputRecipe(
     }
   };
 
+  const pdfOutput = finalOutput
+    ? finalOutput === kStdOut ? undefined : normalizePath(input, finalOutput)
+    : normalizePath(input, pdfGenerator.computePath(input, format));
+
   // tweak writer if it's pdf
   const to = format.pandoc.to === "pdf" ? pdfIntermediateTo : format.pandoc.to;
 
@@ -127,6 +123,7 @@ export function texToPdfOutputRecipe(
       },
     },
     complete,
+    finalOutput: pdfOutput ? relative(inputDir, pdfOutput) : undefined,
   };
 }
 
@@ -151,7 +148,12 @@ export function contextPdfOutputRecipe(
   options: RenderOptions,
   format: Format,
 ): OutputRecipe {
-  const pdfGenerator = async (
+  const computePath = (input: string, _format: Format) => {
+    const [dir, stem] = dirAndStem(input);
+    return join(dir, stem + ".pdf");
+  };
+
+  const generate = async (
     input: string,
     format: Format,
     pandocOptions: PandocOptions,
@@ -177,8 +179,7 @@ export function contextPdfOutputRecipe(
     // run context
     const result = await execProcess({ cmd });
     if (result.success) {
-      const [dir, stem] = dirAndStem(input);
-      return join(dir, stem + ".pdf");
+      return computePath(input, format);
     } else {
       throw new Error();
     }
@@ -190,6 +191,20 @@ export function contextPdfOutputRecipe(
     options,
     format,
     "context",
-    pdfGenerator,
+    {
+      generate,
+      computePath,
+    },
   );
 }
+
+const normalizePath = (input: string, output: string) => {
+  if (isAbsolute(output)) {
+    return output;
+  } else {
+    return relative(
+      dirname(input),
+      output,
+    );
+  }
+};

src/command/render/render-contexts.ts

@@ -37,6 +37,7 @@ import {
   kExecuteDaemonRestart,
   kExecuteDebug,
   kExecuteEnabled,
+  kExtensionName,
   kHeaderIncludes,
   kIncludeAfter,
   kIncludeAfterBody,
@@ -48,6 +49,7 @@ import {
   kOutputExt,
   kOutputFile,
   kServer,
+  kTargetFormat,
   kTheme,
 } from "../../config/constants.ts";
 import { resolveLanguageMetadata } from "../../core/language.ts";
@@ -91,7 +93,7 @@ export async function resolveFormatsFromMetadata(
   input: string,
   formats: string[],
   flags?: RenderFlags,
-): Promise<Record<string, Format>> {
+): Promise<Record<string, { format: Format; active: boolean }>> {
   const includeDir = dirname(input);
 
   // Read any included metadata files and merge in and metadata from the command
@@ -139,9 +141,12 @@ export async function resolveFormatsFromMetadata(
     renderFormats.push(...toFormats);
   }
 
-  const resolved: Record<string, Format> = {};
+  // get a list of _all_ formats
+  formats = ld.uniq(formats.concat(renderFormats));
+
+  const resolved: Record<string, { format: Format; active: boolean }> = {};
 
-  renderFormats.forEach((to) => {
+  formats.forEach((to) => {
     // determine the target format
     const format = formatFromMetadata(
       baseFormat,
@@ -153,7 +158,8 @@ export async function resolveFormatsFromMetadata(
     const config = mergeFormatMetadata(baseFormat, format);
 
     // apply any metadata filter
-    const resolveFormat = defaultWriterFormat(to).resolveFormat;
+    const defaultFormat = defaultWriterFormat(to);
+    const resolveFormat = defaultFormat.resolveFormat;
     if (resolveFormat) {
       resolveFormat(config);
     }
@@ -185,7 +191,10 @@ export async function resolveFormatsFromMetadata(
       config.execute[kExecuteDebug] = flags.executeDebug;
     }
 
-    resolved[to] = config;
+    resolved[to] = {
+      format: config,
+      active: renderFormats.includes(to),
+    };
   });
 
   return resolved;
@@ -225,17 +234,18 @@ export async function renderContexts(
 
   // return contexts
   const contexts: Record<string, RenderContext> = {};
-  for (const format of Object.keys(formats)) {
+  for (const formatKey of Object.keys(formats)) {
     // set format
     const context: RenderContext = {
       target,
       options,
       engine,
-      format: formats[format],
+      format: formats[formatKey].format,
+      active: formats[formatKey].active,
       project,
       libDir: libDir!,
     };
-    contexts[format] = context;
+    contexts[formatKey] = context;
 
     // at this point we have enough to fix up the target and engine
     // in case that's needed.
@@ -250,6 +260,7 @@ export async function renderContexts(
         format: context.format,
         markdown: context.target.markdown,
         context,
+        flags: options.flags || {} as RenderFlags,
         stage: "pre-engine",
       };
 
@@ -280,7 +291,7 @@ export async function renderContexts(
 
     // if this isn't for execute then cleanup context
     if (!forExecute && engine.executeTargetSkipped) {
-      engine.executeTargetSkipped(target, formats[format]);
+      engine.executeTargetSkipped(target, formats[formatKey].format);
     }
   }
   return contexts;
@@ -379,7 +390,7 @@ async function resolveFormats(
   engine: ExecutionEngine,
   options: RenderOptions,
   project?: ProjectContext,
-): Promise<Record<string, Format>> {
+): Promise<Record<string, { format: Format; active: boolean }>> {
   // input level metadata
   const inputMetadata = target.metadata;
 
@@ -455,19 +466,33 @@ async function resolveFormats(
     options.flags,
   );
 
-  // merge the formats
-  const targetFormats = ld.uniq(
+  const activeKeys = (
+    formats: Record<string, { format: Format; active: boolean }>,
+  ) => {
+    return Object.keys(formats).filter((key) => {
+      return formats[key].active;
+    });
+  };
+
+  // A list of all the active format keys
+  const activeFormatKeys = ld.uniq(
+    activeKeys(projFormats).concat(activeKeys(directoryFormats)).concat(
+      activeKeys(inputFormats),
+    ),
+  );
+  // A list of all the format keys included
+  const allFormatKeys = ld.uniq(
     Object.keys(projFormats).concat(Object.keys(directoryFormats)).concat(
       Object.keys(inputFormats),
     ),
   );
 
   const mergedFormats: Record<string, Format> = {};
-  for (const format of targetFormats) {
+  for (const format of allFormatKeys) {
     // alias formats
-    const projFormat = projFormats[format];
-    const directoryFormat = directoryFormats[format];
-    const inputFormat = inputFormats[format];
+    const projFormat = projFormats[format].format;
+    const directoryFormat = directoryFormats[format].format;
+    const inputFormat = inputFormats[format].format;
 
     // resolve theme (project-level bootstrap theme always wins for web drived output)
     if (
@@ -512,14 +537,21 @@ async function resolveFormats(
     // do the merge of the writer format into this format
     mergedFormats[format] = mergeFormatMetadata(
       defaultWriterFormat(formatDesc.formatWithVariants),
-      extensionMetadata[formatDesc.baseFormat],
+      extensionMetadata[formatDesc.baseFormat]
+        ? extensionMetadata[formatDesc.baseFormat].format
+        : {},
       userFormat,
     );
+    // Insist that the target format reflect the correct value.
+    mergedFormats[format].identifier[kTargetFormat] = format;
+
     //deno-lint-ignore no-explicit-any
     mergedFormats[format].mergeAdditionalFormats = (...configs: any[]) => {
       return mergeFormatMetadata(
         defaultWriterFormat(formatDesc.formatWithVariants),
-        extensionMetadata[formatDesc.baseFormat],
+        extensionMetadata[formatDesc.baseFormat]
+          ? extensionMetadata[formatDesc.baseFormat].format
+          : {},
         ...configs,
         userFormat,
       );
@@ -580,7 +612,15 @@ async function resolveFormats(
     mergedFormats[formatName] = format;
   }
 
-  return mergedFormats;
+  const finalFormats: Record<string, { format: Format; active: boolean }> = {};
+  for (const key of Object.keys(mergedFormats)) {
+    const active = activeFormatKeys.includes(key);
+    finalFormats[key] = {
+      format: mergedFormats[key],
+      active,
+    };
+  }
+  return finalFormats;
 }
 
 const readExtensionFormat = async (
@@ -604,6 +644,8 @@ const readExtensionFormat = async (
     if (extensionFormat) {
       const extensionMetadata =
         (extensionFormat[formatDesc.baseFormat] || {}) as Metadata;
+      extensionMetadata[kExtensionName] = extensionMetadata[kExtensionName] ||
+        formatDesc.extension;
 
       const formats = await resolveFormatsFromMetadata(
         extensionMetadata,