Merge branch 'main' into feature/site-nesting

Author: Al Manning

news/changelog-1.3.md

@@ -37,6 +37,8 @@
 - Previously, if the `pdf-engine` was set to `latexmk`, we would bypass many features of Quarto and use Pandoc to produce the PDF output. Starting in in Quarto 1.3, all Quarto features will be enabled for the `latexmk` engine and `latexmk` will be used to run the PDF generation loop.
 - Fix author processing in default PDFs for complex author names (#3483)
 - Remove excessive vertical space between theorem type blocks ([#3776](https://github.com/quarto-dev/quarto-cli/issues/3776)).
+- Fix temporary `.tex` filenames in the presence of multiple variants ([#3762](https://github.com/quarto-dev/quarto-cli/issues/3762)).
+  - Note that this fix changes the filenames used for PDF files with variants. In quarto 1.3, the automatic output names for PDF files include format variants and modifiers.
 
 ## Beamer Format
 

src/command/render/output-tex.ts

@@ -20,6 +20,7 @@ import { kStdOut, replacePandocOutputArg } from "./flags.ts";
 import { OutputRecipe } from "./types.ts";
 import { pdfEngine } from "../../config/pdf.ts";
 import { execProcess } from "../../core/process.ts";
+import { parseFormatString } from "../../core/pandoc/pandoc-formats.ts";
 
 export interface PdfGenerator {
   generate: (
@@ -44,7 +45,18 @@ export function texToPdfOutputRecipe(
 
   // there are many characters that give tex trouble in filenames, create
   // a target stem that replaces them with the '-' character
-  const texStem = texSafeFilename(inputStem);
+
+  // include variants in the tex stem if they are present to avoid
+  // overwriting files
+  let fixupInputName = "";
+  if (format.identifier["target-format"]) {
+    const formatDesc = parseFormatString(format.identifier["target-format"]);
+    fixupInputName = `${formatDesc.variants.join("")}${
+      formatDesc.modifiers.join("")
+    }`;
+  }
+
+  const texStem = texSafeFilename(`${inputStem}${fixupInputName}`);
 
   // cacluate output and args for pandoc (this is an intermediate file
   // which we will then compile to a pdf and rename to .tex)

src/core/lib/text.ts

@@ -196,6 +196,14 @@ export function resolveCaseConventionRegex(
 
   // no conventions were specified, we sniff all keys to disallow near-misses
   const disallowedNearMisses: string[] = [];
+  const keySet = new Set(keys);
+
+  const addNearMiss = (value: string) => {
+    if (!keySet.has(value)) {
+      disallowedNearMisses.push(value);
+    }
+  };
+
   const foundConventions: Set<CaseConvention> = new Set();
   for (const key of keys) {
     const found = detectCaseConvention(key);
@@ -204,19 +212,16 @@ export function resolveCaseConventionRegex(
     }
     switch (found) {
       case "capitalizationCase":
-        disallowedNearMisses.push(toUnderscoreCase(key), toDashCase(key));
+        addNearMiss(toUnderscoreCase(key));
+        addNearMiss(toDashCase(key));
         break;
       case "dash-case":
-        disallowedNearMisses.push(
-          toUnderscoreCase(key),
-          toCapitalizationCase(key),
-        );
+        addNearMiss(toUnderscoreCase(key));
+        addNearMiss(toCapitalizationCase(key));
         break;
       case "underscore_case":
-        disallowedNearMisses.push(
-          toDashCase(key),
-          toCapitalizationCase(key),
-        );
+        addNearMiss(toDashCase(key));
+        addNearMiss(toCapitalizationCase(key));
         break;
     }
   }

src/core/lib/yaml-intelligence/annotated-yaml.ts

@@ -652,3 +652,70 @@ export function locateAnnotation(
   }
   return annotation;
 }
+
+// this supports AnnotatedParse results built
+// from deno yaml as well as tree-sitter.
+export function navigate(
+  path: (number | string)[],
+  annotation: AnnotatedParse | undefined,
+  returnKey = false, // if true, then return the *key* entry as the final result rather than the *value* entry.
+  pathIndex = 0,
+): AnnotatedParse | undefined {
+  // this looks a little strange, but it's easier to catch the error
+  // here than in the different cases below
+  if (annotation === undefined) {
+    throw new Error("Can't navigate an undefined annotation");
+  }
+  if (pathIndex >= path.length) {
+    return annotation;
+  }
+  if (annotation.kind === "mapping" || annotation.kind === "block_mapping") {
+    const { components } = annotation;
+    const searchKey = path[pathIndex];
+    // this loop is inverted to provide better error messages in the
+    // case of repeated keys. Repeated keys are an error in any case, but
+    // the parsing by the validation infrastructure reports the last
+    // entry of a given key in the mapping as the one that counts
+    // (instead of the first, which would be what we'd get if running
+    // the loop forward).
+    //
+    // In that case, the validation errors will also point to the last
+    // entry. In order for the errors to be at least consistent,
+    // we then loop backwards
+    const lastKeyIndex = ~~((components.length - 1) / 2) * 2;
+    for (let i = lastKeyIndex; i >= 0; i -= 2) {
+      const key = components[i]!.result;
+      if (key === searchKey) {
+        if (returnKey && pathIndex === path.length - 1) {
+          return navigate(path, components[i], returnKey, pathIndex + 1);
+        } else {
+          return navigate(path, components[i + 1], returnKey, pathIndex + 1);
+        }
+      }
+    }
+    return annotation;
+    // throw new Error(
+    //   `Internal error: searchKey ${searchKey} (path: ${path}) not found in mapping object`,
+    // );
+  } else if (
+    ["sequence", "block_sequence", "flow_sequence"].indexOf(annotation.kind) !==
+      -1
+  ) {
+    const searchKey = Number(path[pathIndex]);
+    if (
+      isNaN(searchKey) || searchKey < 0 ||
+      searchKey >= annotation.components.length
+    ) {
+      return annotation;
+    }
+    return navigate(
+      path,
+      annotation.components[searchKey],
+      returnKey,
+      pathIndex + 1,
+    );
+  } else {
+    return annotation;
+    // throw new Error(`Internal error: unexpected kind ${annotation.kind}`);
+  }
+}

src/core/lib/yaml-schema/common.ts

@@ -163,40 +163,56 @@ export function objectSchema(params: {
   properties = properties || {};
   patternProperties = patternProperties || {};
   // deno-lint-ignore no-explicit-any
-  const tags: Record<string, any> = {};
+  let tags: Record<string, any> = {};
   let tagsAreSet = false;
   let propertyNames: Schema | undefined = propertyNamesSchema;
 
-  const objectKeys = Object.getOwnPropertyNames(completionsParam || properties);
+  if (completionsParam) {
+    tags["completions"] = completionsParam;
+    tagsAreSet = true;
+  }
 
-  if (namingConvention !== "ignore") {
+  const createCaseConventionSchema = (
+    props: { [k: string]: Schema },
+  ): StringSchema | undefined => {
+    // 2023-01-17: we no longer support propertyNames _and_ case convention detection.
+    // if propertyNames are defined, we don't add case convention detection.
+    // this simplifies the logic and makes schema debugging easier.
+    if (namingConvention === "ignore") {
+      return undefined;
+    }
+    const objectKeys = Object.getOwnPropertyNames(
+      props,
+    );
     const { pattern, list } = resolveCaseConventionRegex(
       objectKeys,
       namingConvention,
     );
-    if (pattern !== undefined) {
-      if (propertyNames === undefined) {
-        propertyNames = {
-          "type": "string",
-          pattern,
-        };
-      } else {
-        propertyNames = allOfSchema(
-          propertyNames,
-          {
-            "type": "string",
-            pattern,
-          },
-        );
-      }
-      tags["case-convention"] = list;
-      tagsAreSet = true;
+    if (pattern === undefined) {
+      return undefined;
     }
-  }
-  if (completionsParam) {
-    tags["completions"] = completionsParam;
-    tagsAreSet = true;
-  }
+    if (propertyNames !== undefined) {
+      console.error(
+        "Warning: propertyNames and case convention detection are mutually exclusive.",
+      );
+      console.error(
+        "Add `namingConvention: 'ignore'` to your schema definition to remove this warning.",
+      );
+      return undefined;
+    }
+    const tags = {
+      "case-convention": list,
+      "error-importance": -5,
+      "case-detection": true,
+    };
+    return {
+      errorMessage: "property ${value} does not match case convention " +
+        `${objectKeys.join(",")}`,
+      "type": "string",
+      pattern,
+      tags,
+    };
+  };
 
   const hasDescription = description !== undefined;
   description = description || "be an object";
@@ -237,14 +253,48 @@ export function objectSchema(params: {
       result.description = description;
     }
 
+    const m: Map<string, [Schema, string][]> = new Map();
+    for (const base of baseSchema) {
+      for (const [k, v] of Object.entries(base.properties || {})) {
+        if (!m.has(k)) {
+          m.set(k, []);
+        }
+        // deno-lint-ignore no-explicit-any
+        m.get(k)!.push([v, (base as any).$id]);
+      }
+    }
+    const errorMsgs = new Set<string>();
+    for (const [k, l] of m) {
+      if (l.length > 1) {
+        errorMsgs.add(
+          `Internal Error: base schemas ${
+            l
+              .map((x) => x[1])
+              .join(", ")
+          } share property ${k}.`,
+        );
+      }
+    }
+    if (errorMsgs.size > 0) {
+      console.error(
+        [...errorMsgs].toSorted((a, b) => a.localeCompare(b)).join("\n"),
+      );
+      console.error("This is a bug in quarto's schemas.");
+      console.error(
+        "Note that we don't throw in order to allow build-js to finish, but the generated schemas will be invalid.",
+      );
+    }
+
     result.properties = Object.assign(
       {},
       ...(baseSchema.map((s) => s.properties)),
       properties,
     );
     result.patternProperties = Object.assign(
       {},
-      ...(baseSchema.map((s) => s.patternProperties)),
+      ...(baseSchema.map((s) => s.patternProperties).filter((s) =>
+        s !== undefined
+      )),
       patternProperties,
     );
 
@@ -279,18 +329,46 @@ export function objectSchema(params: {
     //
     // as a result, we only set propertyNames on the extended schema if both
     // all propertyNames fields are defined.
+
+    // if we subclass from something with patternProperties that came from case convention
+    // detection, ignore that.
+
+    let filtered = false;
     const propNamesArray = baseSchema.map((s) => s.propertyNames)
+      .filter((s) => {
+        if (typeof s !== "object") return true;
+        if (s.tags === undefined) return true;
+        if (s.tags["case-detection"] === true) {
+          filtered = true;
+          return false;
+        }
+        return true;
+      })
       .filter((s) => s !== undefined) as Schema[];
-    if (propertyNames) {
-      propNamesArray.push(propertyNames);
-    }
-    if (propNamesArray.length === baseSchema.length + 1) {
+    // if (propertyNames) {
+    //   propNamesArray.push(propertyNames);
+    // }
+    if (propNamesArray.length === 1) {
+      result.propertyNames = propNamesArray[0];
+    } else if (propNamesArray.length > 1) {
       result.propertyNames = anyOfSchema(...propNamesArray);
+    } else {
+      delete result.propertyNames;
     }
 
     // if either of schema or base schema is closed, the derived schema is also closed.
     result.closed = closed || baseSchema.some((s) => s.closed);
   } else {
+    const caseConventionSchema = createCaseConventionSchema(properties);
+    if (caseConventionSchema !== undefined) {
+      propertyNames = caseConventionSchema;
+      tags = {
+        ...tags,
+        ...caseConventionSchema.tags,
+      };
+      tagsAreSet = true;
+    }
+
     result = {
       ...internalId(),
       "type": "object",

src/core/lib/yaml-schema/from-yaml.ts

@@ -285,7 +285,7 @@ function convertFromObject(yaml: any): ConcreteSchema {
   const schema = yaml["object"];
   // deno-lint-ignore no-explicit-any
   const params: Record<string, any> = {};
-  if (schema.namingConvention) {
+  if (schema.namingConvention && typeof schema.namingConvention === "string") {
     switch (schema.namingConvention) {
       case "capitalizationCase":
         params.namingConvention = "capitalizationCase";
@@ -349,6 +349,7 @@ function convertFromObject(yaml: any): ConcreteSchema {
       default:
         throw new Error("Internal Error: this should have failed validation");
     }
+  } else {
     params.namingConvention = schema.namingConvention;
   }
   if (schema.properties) {

src/core/lib/yaml-validation/validator.ts

@@ -153,6 +153,14 @@ class ValidationContext {
         // As a last resort, we sort suggestions based on "quality"
         const errorTypeQuality = (e: ValidationError): number => {
           const t = e.schemaPath.slice().reverse();
+          if (typeof e.schema === "object") {
+            if (
+              e.schema.tags && e.schema.tags["error-importance"] &&
+              typeof e.schema.tags["error-importance"] === "number"
+            ) {
+              return e.schema.tags["error-importance"];
+            }
+          }
           if (e.schemaPath.indexOf("propertyNames") !== -1) {
             // suggesting invalid property names is bad if there are other errors to report
             return 10;