Make the Rv version manager confirm with the new detection mechanism

Author: rafaelfranca

vscode/src/ruby.ts

@@ -319,18 +319,6 @@ export class Ruby implements RubyInterface {
   }
 
   private async discoverVersionManager() {
-    const managersWithToolExists = [ManagerIdentifier.Rv];
-
-    for (const tool of managersWithToolExists) {
-      const exists = await VersionManager.toolExists(tool, this.workspaceFolder, this.outputChannel);
-
-      if (exists) {
-        this.versionManager = tool;
-        return;
-      }
-    }
-
-    // Check all managers for detection
     const entries = Object.entries(VERSION_MANAGERS) as [ManagerIdentifier, ManagerClass][];
 
     for (const [identifier, ManagerClass] of entries) {

vscode/src/ruby/mise.ts

@@ -31,7 +31,12 @@ export class Mise extends VersionManager {
   }
 
   async activate(): Promise<ActivationResult> {
-    const miseUri = await this.findMiseUri();
+    const miseUri = await this.findVersionManagerUri(
+      "Mise",
+      "rubyVersionManager.miseExecutablePath",
+      Mise.getPossiblePaths(),
+      () => Mise.detect(this.workspaceFolder, this.outputChannel),
+    );
 
     // The exec command in Mise is called `x`
     const parsedResult = await this.runEnvActivationScript(`${miseUri.fsPath} x -- ruby`);
@@ -43,32 +48,4 @@ export class Mise extends VersionManager {
       gemPath: parsedResult.gemPath,
     };
   }
-
-  async findMiseUri(): Promise<vscode.Uri> {
-    const config = vscode.workspace.getConfiguration("rubyLsp");
-    const misePath = config.get<string | undefined>("rubyVersionManager.miseExecutablePath");
-
-    if (misePath) {
-      const configuredPath = vscode.Uri.file(misePath);
-
-      try {
-        await vscode.workspace.fs.stat(configuredPath);
-        return configuredPath;
-      } catch (_error: any) {
-        throw new Error(`Mise executable configured as ${configuredPath.fsPath}, but that file doesn't exist`);
-      }
-    }
-
-    const detectedPath = await Mise.detect(this.workspaceFolder, this.outputChannel);
-
-    if (detectedPath) {
-      return detectedPath;
-    }
-
-    const possiblePaths = Mise.getPossiblePaths();
-    throw new Error(
-      `The Ruby LSP version manager is configured to be Mise, but could not find Mise installation. Searched in
-        ${possiblePaths.join(", ")}`,
-    );
-  }
 }

vscode/src/ruby/rv.ts

@@ -1,14 +1,37 @@
 import * as vscode from "vscode";
 
 import { VersionManager, ActivationResult } from "./versionManager";
+import { pathToUri } from "../common";
+import { WorkspaceChannel } from "../workspaceChannel";
 
 // Manage your Ruby environment with rv
 //
 // Learn more: https://github.com/spinel-coop/rv
 export class Rv extends VersionManager {
+  private static getPossiblePaths(): vscode.Uri[] {
+    return [
+      pathToUri("/", "home", "linuxbrew", ".linuxbrew", "bin", "rv"),
+      pathToUri("/", "usr", "local", "bin", "rv"),
+      pathToUri("/", "opt", "homebrew", "bin", "rv"),
+      pathToUri("/", "usr", "bin", "rv"),
+    ];
+  }
+
+  static async detect(
+    _workspaceFolder: vscode.WorkspaceFolder,
+    _outputChannel: WorkspaceChannel,
+  ): Promise<vscode.Uri | undefined> {
+    return VersionManager.findFirst(Rv.getPossiblePaths());
+  }
+
   async activate(): Promise<ActivationResult> {
-    const rvExec = await this.findRv();
-    const parsedResult = await this.runEnvActivationScript(`${rvExec} ruby run --`);
+    const rvExec = await this.findVersionManagerUri(
+      "Rv",
+      "rubyVersionManager.rvExecutablePath",
+      Rv.getPossiblePaths(),
+      () => Rv.detect(this.workspaceFolder, this.outputChannel),
+    );
+    const parsedResult = await this.runEnvActivationScript(`${rvExec.fsPath} ruby run --`);
 
     return {
       env: { ...process.env, ...parsedResult.env },
@@ -17,30 +40,4 @@ export class Rv extends VersionManager {
       gemPath: parsedResult.gemPath,
     };
   }
-
-  private async findRv(): Promise<string> {
-    const config = vscode.workspace.getConfiguration("rubyLsp");
-    const configuredRvPath = config.get<string | undefined>("rubyVersionManager.rvExecutablePath");
-
-    if (configuredRvPath) {
-      return this.ensureRvExistsAt(configuredRvPath);
-    } else {
-      const possiblePaths = [
-        vscode.Uri.joinPath(vscode.Uri.file("/"), "home", "linuxbrew", ".linuxbrew", "bin"),
-        vscode.Uri.joinPath(vscode.Uri.file("/"), "usr", "local", "bin"),
-        vscode.Uri.joinPath(vscode.Uri.file("/"), "opt", "homebrew", "bin"),
-        vscode.Uri.joinPath(vscode.Uri.file("/"), "usr", "bin"),
-      ];
-      return this.findExec(possiblePaths, "rv");
-    }
-  }
-
-  private async ensureRvExistsAt(path: string): Promise<string> {
-    try {
-      await vscode.workspace.fs.stat(vscode.Uri.file(path));
-      return path;
-    } catch (_error: any) {
-      throw new Error(`The Ruby LSP version manager is configured to be rv, but ${path} does not exist`);
-    }
-  }
 }

vscode/src/ruby/versionManager.ts

@@ -150,4 +150,37 @@ export abstract class VersionManager {
 
     return execName;
   }
+
+  // Common helper to find a version manager executable with configuration support
+  protected async findVersionManagerUri(
+    managerName: string,
+    configKey: string,
+    possiblePaths: vscode.Uri[],
+    detectFn: () => Promise<vscode.Uri | undefined>,
+  ): Promise<vscode.Uri> {
+    const config = vscode.workspace.getConfiguration("rubyLsp");
+    const configuredPath = config.get<string | undefined>(configKey);
+
+    if (configuredPath) {
+      const uri = vscode.Uri.file(configuredPath);
+
+      try {
+        await vscode.workspace.fs.stat(uri);
+        return uri;
+      } catch (_error: any) {
+        throw new Error(`${managerName} executable configured as ${uri.fsPath}, but that file doesn't exist`);
+      }
+    }
+
+    const detectedPath = await detectFn();
+
+    if (detectedPath) {
+      return detectedPath;
+    }
+
+    throw new Error(
+      `The Ruby LSP version manager is configured to be ${managerName}, but could not find ${managerName} installation. Searched in
+        ${possiblePaths.map((p) => p.fsPath).join(", ")}`,
+    );
+  }
 }

vscode/src/test/suite/ruby/mise.test.ts

@@ -52,7 +52,7 @@ suite("Mise", () => {
       stderr: `${ACTIVATION_SEPARATOR}${envStub}${ACTIVATION_SEPARATOR}`,
     });
     const findStub = sandbox
-      .stub(mise, "findMiseUri")
+      .stub(mise, "findVersionManagerUri" as any)
       .resolves(common.pathToUri(os.homedir(), ".local", "bin", "mise"));
 
     const { env, version, yjit } = await mise.activate();

vscode/src/test/suite/ruby/rv.test.ts

@@ -53,13 +53,14 @@ suite("Rv", () => {
       stderr: `${ACTIVATION_SEPARATOR}${envStub}${ACTIVATION_SEPARATOR}`,
     });
 
-    // Stub findRv to return the executable path
-    sandbox.stub(rv, "findRv" as any).resolves("rv");
+    // Stub findVersionManagerUri to return the executable path as a Uri
+    const rvPath = vscode.Uri.file("rv");
+    sandbox.stub(rv, "findVersionManagerUri" as any).resolves(rvPath);
 
     const { env, version, yjit } = await rv.activate();
 
     assert.ok(
-      execStub.calledOnceWithExactly(`rv ruby run -- -EUTF-8:UTF-8 '${activationPath.fsPath}'`, {
+      execStub.calledOnceWithExactly(`${rvPath.fsPath} ruby run -- -EUTF-8:UTF-8 '${activationPath.fsPath}'`, {
         cwd: workspacePath,
         shell: vscode.env.shell,
 
@@ -94,8 +95,8 @@ suite("Rv", () => {
     const rvPath = path.join(workspacePath, "rv");
     fs.writeFileSync(rvPath, "fakeRvBinary");
 
-    // Stub findRv to return the configured executable path
-    sandbox.stub(rv, "findRv" as any).resolves(rvPath);
+    // Stub findVersionManagerUri to return the configured executable path as a Uri
+    sandbox.stub(rv, "findVersionManagerUri" as any).resolves(vscode.Uri.file(rvPath));
 
     const configStub = sinon.stub(vscode.workspace, "getConfiguration").returns({
       get: (name: string) => {