Implement Rv using Mise as base class

Author: rafaelfranca

vscode/src/ruby/mise.ts

@@ -10,42 +10,81 @@ import { pathToUri } from "../common";
 //
 // Learn more: https://github.com/jdx/mise
 export class Mise extends VersionManager {
+  static async detect(
+    _workspaceFolder: vscode.WorkspaceFolder,
+    _outputChannel: WorkspaceChannel,
+  ): Promise<vscode.Uri | undefined> {
+    return this.findFirst(this.getPossiblePaths());
+  }
+
+  async activate(): Promise<ActivationResult> {
+    const execUri = await this.findVersionManagerUri();
+
+    const parsedResult = await this.runEnvActivationScript(this.getExecutionCommand(execUri.fsPath));
+
+    return {
+      env: { ...process.env, ...parsedResult.env },
+      yjit: parsedResult.yjit,
+      version: parsedResult.version,
+      gemPath: parsedResult.gemPath,
+    };
+  }
+
   // Possible mise installation paths
   //
   // 1. Installation from curl | sh (per mise.jdx.dev Getting Started)
   // 2. Homebrew M series
   // 3. Installation from `apt install mise`
-  private static getPossiblePaths(): vscode.Uri[] {
+  protected static getPossiblePaths(): vscode.Uri[] {
     return [
       pathToUri(os.homedir(), ".local", "bin", "mise"),
       pathToUri("/", "opt", "homebrew", "bin", "mise"),
       pathToUri("/", "usr", "bin", "mise"),
     ];
   }
 
-  static async detect(
-    _workspaceFolder: vscode.WorkspaceFolder,
-    _outputChannel: WorkspaceChannel,
-  ): Promise<vscode.Uri | undefined> {
-    return VersionManager.findFirst(Mise.getPossiblePaths());
+  protected getVersionManagerName(): string {
+    return "Mise";
   }
 
-  async activate(): Promise<ActivationResult> {
-    const miseUri = await this.findVersionManagerUri(
-      "Mise",
-      "rubyVersionManager.miseExecutablePath",
-      Mise.getPossiblePaths(),
-      () => Mise.detect(this.workspaceFolder, this.outputChannel),
-    );
+  protected getConfigKey(): string {
+    return "rubyVersionManager.miseExecutablePath";
+  }
 
+  protected getExecutionCommand(executablePath: string): string {
     // The exec command in Mise is called `x`
-    const parsedResult = await this.runEnvActivationScript(`${miseUri.fsPath} x -- ruby`);
+    return `${executablePath} x -- ruby`;
+  }
 
-    return {
-      env: { ...process.env, ...parsedResult.env },
-      yjit: parsedResult.yjit,
-      version: parsedResult.version,
-      gemPath: parsedResult.gemPath,
-    };
+  private async findVersionManagerUri(): Promise<vscode.Uri> {
+    const constructor = this.constructor as typeof Mise;
+    const managerName = this.getVersionManagerName();
+    const configKey = this.getConfigKey();
+
+    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 constructor.detect(this.workspaceFolder, this.outputChannel);
+
+    if (detectedPath) {
+      return detectedPath;
+    }
+
+    const possiblePaths = constructor.getPossiblePaths();
+    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/ruby/rv.ts

@@ -1,14 +1,13 @@
 import * as vscode from "vscode";
 
-import { VersionManager, ActivationResult } from "./versionManager";
 import { pathToUri } from "../common";
-import { WorkspaceChannel } from "../workspaceChannel";
+import { Mise } from "./mise";
 
 // Manage your Ruby environment with rv
 //
 // Learn more: https://github.com/spinel-coop/rv
-export class Rv extends VersionManager {
-  private static getPossiblePaths(): vscode.Uri[] {
+export class Rv extends Mise {
+  protected static getPossiblePaths(): vscode.Uri[] {
     return [
       pathToUri("/", "home", "linuxbrew", ".linuxbrew", "bin", "rv"),
       pathToUri("/", "usr", "local", "bin", "rv"),
@@ -17,27 +16,15 @@ export class Rv extends VersionManager {
     ];
   }
 
-  static async detect(
-    _workspaceFolder: vscode.WorkspaceFolder,
-    _outputChannel: WorkspaceChannel,
-  ): Promise<vscode.Uri | undefined> {
-    return VersionManager.findFirst(Rv.getPossiblePaths());
+  protected getVersionManagerName(): string {
+    return "Rv";
   }
 
-  async activate(): Promise<ActivationResult> {
-    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 --`);
+  protected getConfigKey(): string {
+    return "rubyVersionManager.rvExecutablePath";
+  }
 
-    return {
-      env: { ...process.env, ...parsedResult.env },
-      yjit: parsedResult.yjit,
-      version: parsedResult.version,
-      gemPath: parsedResult.gemPath,
-    };
+  protected getExecutionCommand(executablePath: string): string {
+    return `${executablePath} ruby run --`;
   }
 }

vscode/src/ruby/versionManager.ts

@@ -150,37 +150,4 @@ 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(", ")}`,
-    );
-  }
 }