Add pandoc path lookup and optional setting

Author: fflores97

apps/vscode/package.json

@@ -1107,6 +1107,13 @@
           "default": true,
           "markdownDescription": "When using a venv or conda environment, prefer Quarto CLI installed with pip in that environment. This will override Quarto CLI in the `PATH`, but not an explicitly configured `#quarto.path#`."
         },
+        "quarto.pandocPath": {
+          "order": 12,
+          "scope": "window",
+          "type": "string",
+          "default": "",
+          "markdownDescription": "A path to the `pandoc` executable. By default, the extension looks for pandoc in the `PATH`, but if set, will use the path specified instead."
+        },
         "quarto.render.renderOnSave": {
           "order": 12,
           "scope": "window",

apps/vscode/src/main.ts

@@ -61,7 +61,8 @@ export async function activate(context: vscode.ExtensionContext) {
     workspaceFolder,
     // Look for quarto in the app root; this is where Positron installs it
     [path.join(vscode.env.appRoot, 'quarto', 'bin')],
-    vscode.window.showWarningMessage
+    vscode.window.showWarningMessage,
+    vscode.workspace.getConfiguration("quarto").get("pandoc")
   );
   if (quartoContext.available) {
 

packages/quarto-core/src/context.ts

@@ -35,7 +35,7 @@ export interface QuartoContext {
 
 /**
  * Initialize a Quarto context.
- * 
+ *
  * @param quartoPath A path to a user-specified Quarto executable. If
  *  supplied, this will be used in preference to other methods of detecting
  *  Quarto.
@@ -44,14 +44,15 @@ export interface QuartoContext {
  * @param additionalSearchPaths Additional paths to search for Quarto. These will only be used if
  *  Quarto is not found in the default locations or the system path.
  * @param showWarning A function to call to show a warning message.
- * 
+ *
  * @returns A Quarto context.
  */
 export function initQuartoContext(
   quartoPath?: string,
   workspaceFolder?: string,
   additionalSearchPaths?: string[],
-  showWarning?: (msg: string) => void
+  showWarning?: (msg: string) => void,
+  pandocPath?: string
 ): QuartoContext {
   // default warning to log
   showWarning = showWarning || console.log;
@@ -80,20 +81,30 @@ export function initQuartoContext(
     // use cmd suffix for older versions of quarto on windows
     const windows = os.platform() == "win32";
     const useCmd = windows && semver.lte(quartoInstall.version, "1.1.162");
-    let pandocPath = path.join(quartoInstall!.binPath, "tools", "pandoc");
-    // more recent versions of quarto use architecture-specific tools dir,
-    // if the pandocPath is not found then look in the requisite dir for this arch
-    if (!windows && !fs.existsSync(pandocPath)) {
-      pandocPath = path.join(
-        path.dirname(pandocPath), 
-        isArm_64() ? "aarch64" : "x86_64", 
-        path.basename(pandocPath)
-      );
+
+    // Look for pandoc in settings
+    let pandocInstall: PandocInstallation | undefined;
+    if (pandocPath) {
+      if (!path.isAbsolute(pandocPath) && workspaceFolder) {
+        pandocPath = path.join(workspaceFolder, pandocPath);
+      }
+      pandocInstall = detectUserSpecifiedPandoc(pandocPath, showWarning);
+    }
+
+    // next look on the path
+    if (!pandocInstall) {
+      pandocInstall = detectPandoc("pandoc");
     }
+
+    // if still not found, scan for versions of quarto in known locations
+    if (!pandocInstall) {
+      pandocInstall = scanForPandoc(quartoInstall, additionalSearchPaths);
+    }
+
     return {
       available: true,
       ...quartoInstall,
-      pandocPath,
+      pandocPath: pandocInstall?.binPath || "",
       workspaceDir: workspaceFolder,
       useCmd,
       runQuarto: (options: ExecFileSyncOptions, ...args: string[]) =>
@@ -104,7 +115,7 @@ export function initQuartoContext(
         ),
       runPandoc: (options: ExecFileSyncOptions, ...args: string[]) =>
         execProgram(
-          pandocPath,
+          pandocInstall?.binPath || "",
           args,
           options
         ),
@@ -114,7 +125,7 @@ export function initQuartoContext(
   }
 }
 
-export function quartoContextUnavailable() : QuartoContext {
+export function quartoContextUnavailable(): QuartoContext {
   return {
     available: false,
     version: "",
@@ -179,8 +190,8 @@ function detectUserSpecifiedQuarto(
   if (!fs.statSync(quartoPath).isFile()) {
     showWarning(
       "Specified quarto executable is a directory not a file: '" +
-        quartoPath +
-        "'"
+      quartoPath +
+      "'"
     );
     return undefined;
   }
@@ -191,9 +202,9 @@ function detectUserSpecifiedQuarto(
 
 /**
  * Scan for Quarto in known locations.
- * 
+ *
  * @param additionalSearchPaths Additional paths to search for Quarto (optional)
- * 
+ *
  * @returns A Quarto installation if found, otherwise undefined
  */
 function scanForQuarto(additionalSearchPaths?: string[]): QuartoInstallation | undefined {
@@ -231,3 +242,119 @@ function scanForQuarto(additionalSearchPaths?: string[]): QuartoInstallation | u
 
   return undefined;
 }
+
+type PandocInstallation = {
+  version: string;
+  binPath: string;
+};
+
+function detectPandoc(pandocPath: string): PandocInstallation | undefined {
+  // detect version and paths (fall back to .cmd on windows if necessary)
+  const windows = os.platform() == "win32";
+  let version: string | undefined;
+  const readPandocInfo = (bin: string) => {
+    version = execProgram(bin, ["--version"]).substring(7, 10).trim();
+  };
+  try {
+    readPandocInfo(pandocPath);
+  } catch (e) {
+    if (windows) {
+      try {
+        readPandocInfo(pandocPath + ".cmd");
+      } catch (e) { /* */ }
+    }
+  }
+  // return version if we have it
+  if (version) {
+    return {
+      version,
+      binPath: pandocPath,
+    };
+  } else {
+    return undefined;
+  }
+}
+
+function detectUserSpecifiedPandoc(
+  pandocPath: string,
+  showWarning: (msg: string) => void
+): PandocInstallation | undefined {
+  // validate that it exists
+  if (!fs.existsSync(pandocPath)) {
+    showWarning(
+      "Unable to find specified pandoc executable: '" + pandocPath + "'"
+    );
+    return undefined;
+  }
+
+  // validate that it is a file
+  if (!fs.statSync(pandocPath).isFile()) {
+    showWarning(
+      "Specified pandoc executable is a directory not a file: '" +
+      pandocPath +
+      "'"
+    );
+    return undefined;
+  }
+
+  // detect
+  return detectPandoc(pandocPath);
+}
+
+/**
+ * Scan for Pandoc in known locations.
+ *
+ * @param quartoInstall QuartoInstall instance to use for search first
+ * @param additionalSearchPaths Additional paths to search for Quarto (optional)
+ *
+ * @returns A Quarto installation if found, otherwise undefined
+ */
+function scanForPandoc(quartoInstall: QuartoInstallation, additionalSearchPaths?: string[]): PandocInstallation | undefined {
+  const scanPaths: string[] = [];
+  const windows = os.platform() === "win32"
+
+  let pandocPath = path.join(quartoInstall!.binPath, "tools", "pandoc");
+  // more recent versions of quarto use architecture-specific tools dir,
+  // if the pandocPath is not found then look in the requisite dir for this arch
+  if (!windows && !fs.existsSync(pandocPath)) {
+    pandocPath = path.join(
+      path.dirname(pandocPath),
+      isArm_64() ? "aarch64" : "x86_64",
+      path.basename(pandocPath)
+    );
+  }
+  scanPaths.push(pandocPath)
+
+  if (windows) {
+    // scanPaths.push("C:\\Program Files\\Quarto\\bin");
+    // const localAppData = process.env["LOCALAPPDATA"];
+    // if (localAppData) {
+    //   scanPaths.push(path.join(localAppData, "Programs", "Quarto", "bin"));
+    // }
+    // scanPaths.push("C:\\Program Files\\RStudio\\bin\\quarto\\bin");
+  } else if (os.platform() === "darwin") {
+    // scanPaths.push("/Applications/quarto/bin/");
+    // const home = process.env.HOME;
+    // if (home) {
+    //   scanPaths.push(path.join(home, "Applications", "quarto", "bin"));
+    // }
+    // scanPaths.push("/Applications/RStudio.app/Contents/MacOS/quarto/bin");
+  } else if (os.platform() === "linux") {
+    // scanPaths.push("/opt/quarto/bin");
+    // scanPaths.push("/usr/lib/rstudio/bin/quarto/bin");
+    // scanPaths.push("/usr/lib/rstudio-server/bin/quarto/bin");
+  }
+
+  if (additionalSearchPaths) {
+    scanPaths.push(...additionalSearchPaths);
+  }
+
+  for (const scanPath of scanPaths.filter(fs.existsSync)) {
+    const install = detectPandoc(path.join(scanPath, "pandoc"));
+    if (install) {
+      return install;
+    }
+  }
+
+  return undefined
+}