Support opened files without workspaces

Fixes #132

Author: celonymire

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 4.0.4
+
+### Added
+
+- Support for opened files without active workspaces
+
 # 4.0.3
 
 ### Changed

src/extension/competitiveCompanion.ts

@@ -8,6 +8,7 @@ import * as v from "valibot";
 import { ProblemSchema, type Testcase } from "../shared/schemas";
 import type JudgeViewProvider from "./providers/JudgeViewProvider";
 import { getLogger } from "./utils/logging";
+import { getFileWorkspace } from "./utils/vscode";
 
 type Problem = v.InferOutput<typeof ProblemSchema>;
 
@@ -49,13 +50,13 @@ let prevBatchId: string | undefined;
  */
 async function promptForTargetFile(
   problem: Problem,
-  workspaceRoot: string,
-  files: vscode.Uri[],
+  files: string[],
+  workspace?: string,
   currentFileRelativePath?: string
 ): Promise<string> {
   const options: vscode.QuickPickItem[] = files.map((file) => ({
-    label: path.parse(file.fsPath).base,
-    description: path.relative(workspaceRoot, file.fsPath),
+    label: path.parse(file).base,
+    description: path.relative(workspace ?? "", file),
   }));
 
   const pick = vscode.window.createQuickPick();
@@ -126,7 +127,7 @@ async function promptForTargetFile(
  */
 async function processProblem(problem: Problem, judge: JudgeViewProvider): Promise<void> {
   const activeFile = vscode.window.activeTextEditor?.document.fileName;
-  const workspaceRoot = vscode.workspace.workspaceFolders?.at(0)?.uri.fsPath ?? "";
+  const workspace = await getFileWorkspace(activeFile);
   const config = vscode.workspace.getConfiguration("fastolympiccoding");
   const openSelectedFiles = config.get<boolean>("openSelectedFiles")!;
   const askForWhichFile = config.get<boolean>("askForWhichFile")!;
@@ -138,29 +139,51 @@ async function processProblem(problem: Problem, judge: JudgeViewProvider): Promi
   if (prevBatchId === problem.batch.id) {
     currentFileRelativePath = prevSelection;
   } else {
-    currentFileRelativePath = activeFile ? path.relative(workspaceRoot, activeFile) : undefined;
+    currentFileRelativePath =
+      workspace && activeFile ? path.relative(workspace, activeFile) : undefined;
   }
   let relativePath = isSingleProblem && currentFileRelativePath ? currentFileRelativePath : "";
 
   if (needsPrompt) {
     // Gather files before prompting to include newly created files from previous problems
     const include = config.get<string>("includePattern")!;
     const exclude = config.get<string>("excludePattern")!;
-    const updatedFiles = await vscode.workspace.findFiles(include, exclude);
-    relativePath = await promptForTargetFile(
-      problem,
-      workspaceRoot,
-      updatedFiles,
-      currentFileRelativePath
-    );
+
+    let files: string[];
+    if (vscode.workspace.workspaceFolders) {
+      files = await vscode.workspace
+        .findFiles(include, exclude)
+        .then((uris) => uris.map((uri) => uri.fsPath));
+    } else if (activeFile) {
+      files = [activeFile];
+    } else {
+      const choice = await vscode.window.showWarningMessage(
+        `No active workspace nor file opened to infer files to put testcases for "${problem.name}".`,
+        "Select A File",
+        "Dismiss"
+      );
+      if (choice === "Dismiss") {
+        return;
+      }
+
+      const result = await vscode.window.showOpenDialog({
+        canSelectFiles: true,
+        canSelectFolders: false,
+        canSelectMany: false,
+        title: `Select a file to put testcases for "${problem.name}"`,
+      });
+      files = result ? [result[0].fsPath] : [];
+    }
+
+    relativePath = await promptForTargetFile(problem, files, workspace, currentFileRelativePath);
   }
 
   if (relativePath === "") {
     vscode.window.showWarningMessage(`No file to write testcases for "${problem.name}"`);
     return;
   }
 
-  const absolutePath = path.join(workspaceRoot, relativePath);
+  const absolutePath = path.resolve(path.join(workspace ?? "", relativePath));
   try {
     await fs.writeFile(absolutePath, "", { flag: "a" }); // Create file if it doesn't exist
   } catch (error) {

src/extension/runSettingsCommands.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as vscode from "vscode";
 
-import { deepMerge } from "./utils/vscode";
+import { deepMerge, getFileWorkspace } from "./utils/vscode";
 
 const gdbAttachDebugConfig = {
   debugCommand: [
@@ -388,30 +388,14 @@ export function registerRunSettingsCommands(context: vscode.ExtensionContext): v
   context.subscriptions.push(
     vscode.commands.registerCommand(
       "fastolympiccoding.createRunSettings",
-      async (options?: { extension?: string; workspaceFolder?: vscode.WorkspaceFolder }) => {
-        const workspaceFolders = vscode.workspace.workspaceFolders;
-        if (!workspaceFolders || workspaceFolders.length === 0) {
-          void vscode.window.showErrorMessage("No workspace folder is open");
+      async (options?: { extension?: string; workspaceFolder?: string }) => {
+        const runSettingsFolder = options?.workspaceFolder ?? (await getFileWorkspace());
+        if (!runSettingsFolder) {
           return;
         }
 
-        let workspaceFolder: vscode.WorkspaceFolder;
-        if (options?.workspaceFolder) {
-          workspaceFolder = options.workspaceFolder;
-        } else if (workspaceFolders.length === 1) {
-          workspaceFolder = workspaceFolders[0];
-        } else {
-          const picked = await vscode.window.showWorkspaceFolderPick({
-            placeHolder: "Select workspace folder for run settings",
-          });
-          if (!picked) {
-            return;
-          }
-          workspaceFolder = picked;
-        }
-
-        const runSettingsPath = path.join(workspaceFolder.uri.fsPath, "runSettings.json");
-        const dotVscodeDir = path.join(workspaceFolder.uri.fsPath, ".vscode");
+        const runSettingsPath = path.join(runSettingsFolder, "runSettings.json");
+        const dotVscodeDir = path.join(runSettingsFolder, ".vscode");
         const launchJsonPath = path.join(dotVscodeDir, "launch.json");
 
         const fileExists = await fs
@@ -574,28 +558,14 @@ export function registerRunSettingsCommands(context: vscode.ExtensionContext): v
   );
 
   context.subscriptions.push(
-    vscode.commands.registerCommand("fastolympiccoding.openRunSettings", () => {
+    vscode.commands.registerCommand("fastolympiccoding.openRunSettings", async () => {
       void (async () => {
-        const workspaceFolders = vscode.workspace.workspaceFolders;
-        if (!workspaceFolders || workspaceFolders.length === 0) {
-          void vscode.window.showErrorMessage("No workspace folder is open");
+        const runSettingsFolder = await getFileWorkspace();
+        if (!runSettingsFolder) {
           return;
         }
 
-        let workspaceFolder: vscode.WorkspaceFolder;
-        if (workspaceFolders.length === 1) {
-          workspaceFolder = workspaceFolders[0];
-        } else {
-          const picked = await vscode.window.showWorkspaceFolderPick({
-            placeHolder: "Select workspace folder",
-          });
-          if (!picked) {
-            return;
-          }
-          workspaceFolder = picked;
-        }
-
-        const runSettingsPath = path.join(workspaceFolder.uri.fsPath, "runSettings.json");
+        const runSettingsPath = path.join(runSettingsFolder, "runSettings.json");
         try {
           await fs.access(runSettingsPath);
           const doc = await vscode.workspace.openTextDocument(runSettingsPath);

src/extension/utils/vscode.ts

@@ -569,6 +569,29 @@ function loadRunSettingsFromDirectory(directory: string): Record<string, unknown
   }
 }
 
+/**
+ * Returns VSCode workspace folder if it exists otherwise returns the directory of the file
+ */
+export async function getFileWorkspace(file?: string): Promise<string | undefined> {
+  let runSettingsFolder: string | undefined = undefined;
+  if (vscode.workspace.workspaceFolders?.length === 1) {
+    runSettingsFolder = vscode.workspace.workspaceFolders[0].uri.fsPath;
+  } else if (file) {
+    runSettingsFolder = path.dirname(file);
+  } else if (vscode.window.activeTextEditor) {
+    runSettingsFolder = path.dirname(vscode.window.activeTextEditor.document.fileName);
+  } else {
+    const picked = await vscode.window.showWorkspaceFolderPick({
+      placeHolder: "Select workspace folder for run settings",
+    });
+    if (!picked) {
+      return;
+    }
+    runSettingsFolder = picked.uri.fsPath;
+  }
+  return runSettingsFolder;
+}
+
 /**
  * Traverses from the file directory up to the workspace root,
  * loading and merging runSettings.json files along the way.
@@ -585,24 +608,18 @@ export function getFileRunSettings(
     return null;
   }
 
-  const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(file));
-  if (!workspaceFolder) {
-    logger.error(`No workspace folder found for file ${file}`);
-    vscode.window.showErrorMessage(`No workspace folder found for file ${file}`);
-    return null;
-  }
-
-  const workspaceRoot = workspaceFolder.uri.fsPath;
   let currentDir = path.dirname(file);
+  const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(file));
+  const rootDir = workspaceFolder?.uri.fsPath ?? currentDir;
 
   // Iterate from file folder back down to workspace root
   const settingsStack: Record<string, unknown>[] = [];
-  while (currentDir.startsWith(workspaceRoot)) {
+  while (currentDir.startsWith(rootDir)) {
     const dirSettings = loadRunSettingsFromDirectory(currentDir);
     if (dirSettings) {
       settingsStack.push(dirSettings);
     }
-    if (currentDir === workspaceRoot) {
+    if (currentDir === rootDir) {
       break;
     }
     const parentDir = path.dirname(currentDir);