Automatically open QMD files in visual/source editor if specified

apps/vscode/package.json

@@ -1036,6 +1036,16 @@
           "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.defaultEditor": {
+          "order": 11,
+          "type": "string",
+          "markdownDescription": "Default editor",
+          "enum": [
+            "source",
+            "visual"
+          ],
+          "default": "source"
+        },
         "quarto.render.renderOnSave": {
           "order": 12,
           "scope": "window",

apps/vscode/src/main.ts

@@ -29,15 +29,16 @@ import { activateStatusBar } from "./providers/statusbar";
 import { walkthroughCommands } from "./providers/walkthrough";
 import { activateLuaTypes } from "./providers/lua-types";
 import { activateCreate } from "./providers/create/create";
-import { activateEditor } from "./providers/editor/editor";
+import { activateEditor, VisualEditorProvider } from "./providers/editor/editor";
 import { activateCopyFiles } from "./providers/copyfiles";
 import { activateZotero } from "./providers/zotero/zotero";;
 import { extensionHost } from "./host";
 import { configuredQuartoPath } from "./core/quarto";
 import { activateDenoConfig } from "./providers/deno-config";
+import { determineMode, setEditorOpener } from "./providers/editor/toggle";
 
 export async function activate(context: vscode.ExtensionContext) {
- 
+
   // create extension host
   const host = extensionHost();
 
@@ -125,9 +126,44 @@ export async function activate(context: vscode.ExtensionContext) {
 
   // activate providers common to browser/node
   activateCommon(context, host, engine, commands);
+
+  // if positron
+  setEditorOpener();
+
+  vscode.workspace.onDidChangeConfiguration(async (event) => {
+    if (event.affectsConfiguration('quarto.defaultEditor')) {
+      setEditorOpener();
+    }
+  });
+
+  const documentOpenHandler = vscode.window.onDidChangeActiveTextEditor(async () => {
+    // Check if the document language is "quarto"
+
+    const document = vscode.window.activeTextEditor?.document
+    if (!document || document.languageId != 'quarto') {
+      return;
+    }
+    const config = vscode.workspace.getConfiguration('quarto').get<string>('defaultEditor');
+
+    const editorMode = await determineMode(document.getText());
+    if (editorMode && editorMode != config) {
+      const editorOpener = editorMode === 'visual' ? VisualEditorProvider.viewType : 'textEditor';
+      await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+      await vscode.commands.executeCommand("vscode.openWith",
+        document.uri,
+        editorOpener
+      );
+      return;
+    }
+  });
+
+  // Add the event handler to the context subscriptions
+  context.subscriptions.push(documentOpenHandler);
+
+  // end if positron
 }
 
 export async function deactivate() {
   return deactivateLsp();
-} 
+}
 

apps/vscode/src/providers/editor/toggle.ts

@@ -12,16 +12,88 @@
  * AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.
  *
  */
-
+import * as vscode from "vscode";
 import { commands, window, workspace, TextDocument, ViewColumn } from "vscode";
+import * as path from 'path';
+import * as quarto from "quarto-core";
+import fs from "node:fs";
+import yaml from "js-yaml";
 import { Command } from "../../core/command";
 import { isQuartoDoc, kQuartoLanguageId } from "../../core/doc";
 import { VisualEditorProvider } from "./editor";
 
 
+export async function determineMode(doc: string): Promise<string | undefined> {
+  let editorOpener = undefined;
+
+  // check if file itself has a mode
+  if (hasEditorMode(doc, "source")) {
+    editorOpener = "source";
+  }
+  else if (hasEditorMode(doc, "visual")) {
+    editorOpener = "visual";
+  }
+  // check if has a _quarto.yml or _quarto.yaml file with editor specified
+  else {
+    editorOpener = workspaceHasQuartoYaml();
+  }
+
+  return editorOpener;
+}
 
+export async function setEditorOpener() {
+  const config = vscode.workspace.getConfiguration('quarto').get<string>('defaultEditor');
+  const viewType = config === 'visual' ? VisualEditorProvider.viewType : 'textEditor';
+  vscode.workspace.getConfiguration('workbench').update('editor.defaultView', viewType, true);
+  await vscode.commands.executeCommand("workbench.action.setDefaultEditor",
+    vscode.Uri.file('filename.qmd'),
+    viewType
+  );
+}
+
+export function workspaceHasQuartoYaml() {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+
+  if (workspaceFolders && workspaceFolders.length > 0) {
+    const rootPath = workspaceFolders[0].uri.fsPath;  // Only look in the root directory of the first workspace folder
+
+    const quartoFilePathYml = path.join(rootPath, '_quarto.yml');
+    const quartoFilePathYaml = path.join(rootPath, '_quarto.yaml');
+
+    let fileContent: string | null = null;
+
+    if (fs.existsSync(quartoFilePathYml)) {
+      fileContent = fs.readFileSync(quartoFilePathYml, 'utf8');
+    } else if (fs.existsSync(quartoFilePathYaml)) {
+      fileContent = fs.readFileSync(quartoFilePathYaml, 'utf8');
+    }
 
-export function editInVisualModeCommand() : Command {
+    if (fileContent) {
+      const parsedYaml = yaml.load(fileContent) as any;
+      if (parsedYaml.editor === 'visual' || parsedYaml.editor === 'source') {
+        return parsedYaml.editor;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+export function hasEditorMode(doc: string, mode: string) {
+  if (doc) {
+    const match = doc.match(quarto.kRegExYAML);
+    if (match) {
+      const yaml = match[0];
+      return (
+        !!yaml.match(new RegExp("^editor:\\s+" + mode + "\\s*$", "gm")) ||
+        !!yaml.match(new RegExp("^[ \\t]*" + mode + ":\\s*(default)?\\s*$", "gm"))
+      );
+    }
+  }
+  return false;
+}
+
+export function editInVisualModeCommand(): Command {
   return {
     id: "quarto.editInVisualMode",
     execute() {
@@ -33,14 +105,14 @@ export function editInVisualModeCommand() : Command {
   };
 }
 
-export function editInSourceModeCommand() : Command {
+export function editInSourceModeCommand(): Command {
   return {
     id: "quarto.editInSourceMode",
     execute() {
       const activeVisual = VisualEditorProvider.activeEditor();
       if (activeVisual) {
         reopenEditorInSourceMode(activeVisual.document, '', activeVisual.viewColumn);
-      } 
+      }
     }
   };
 }
@@ -49,14 +121,14 @@ export async function reopenEditorInVisualMode(
   document: TextDocument,
   viewColumn?: ViewColumn
 ) {
- 
+
   // save then close
   await commands.executeCommand("workbench.action.files.save");
   await commands.executeCommand('workbench.action.closeActiveEditor');
 
   // open in visual mode
-  await commands.executeCommand("vscode.openWith", 
-    document.uri, 
+  await commands.executeCommand("vscode.openWith",
+    document.uri,
     VisualEditorProvider.viewType,
     {
       viewColumn
@@ -65,8 +137,8 @@ export async function reopenEditorInVisualMode(
 }
 
 export async function reopenEditorInSourceMode(
-  document: TextDocument, 
-  untitledContent?: string, 
+  document: TextDocument,
+  untitledContent?: string,
   viewColumn?: ViewColumn
 ) {
   if (!document.isUntitled) {
@@ -91,5 +163,5 @@ export async function reopenEditorInSourceMode(
       await window.showTextDocument(doc, viewColumn, false);
     }
   });
-  
+
 }

packages/quarto-core/src/document.ts

@@ -109,7 +109,7 @@ export function filePathForDoc(doc: Document) {
   return URI.parse(doc.uri).fsPath;
 }
 
-const kRegExYAML =
+export const kRegExYAML =
   /(^)(---[ \t]*[\r\n]+(?![ \t]*[\r\n]+)[\W\w]*?[\r\n]+(?:---|\.\.\.))([ \t]*)$/gm;
 
 export function isQuartoDocWithFormat(doc: Document | string, format: string) {