Remove all activation logic from this extension

Other extension should be the ones chosing when to activate it.

Author: rafaelfranca

package.json

@@ -15,11 +15,7 @@
   "categories": [
     "Programming Languages"
   ],
-  "activationEvents": [
-    "onLanguage:ruby",
-    "workspaceContains:Gemfile",
-    "workspaceContains:gems.rb"
-  ],
+  "activationEvents": [],
   "main": "./dist/extension.js",
   "contributes": {
     "commands": [

src/extension.ts

@@ -2,12 +2,11 @@ import * as vscode from "vscode";
 import { RubyEnvironmentsApi } from "./types";
 import { RubyEnvironment } from "./rubyEnvironment";
 
-export async function activate(context: vscode.ExtensionContext): Promise<RubyEnvironmentsApi> {
+export function activate(context: vscode.ExtensionContext): RubyEnvironmentsApi {
   const outputChannel = vscode.window.createOutputChannel("Ruby Environments", { log: true });
   context.subscriptions.push(outputChannel);
 
   const rubyEnvironment = new RubyEnvironment(context, outputChannel);
-  await rubyEnvironment.activate();
   return rubyEnvironment;
 }
 

src/rubyEnvironment.ts

@@ -8,18 +8,22 @@ import { VersionManager } from "./versionManager";
  * Main class that manages the Ruby environment state and lifecycle
  */
 export class RubyEnvironment implements RubyEnvironmentsApi {
-  private versionManager: VersionManager;
+  private versionManager: VersionManager | null = null;
   private currentRubyDefinition: RubyDefinition | null = null;
+  private workspaceFolder: vscode.WorkspaceFolder | undefined;
+  private status: RubyStatus | null = null;
+
   private readonly logger: vscode.LogOutputChannel;
   private readonly context: vscode.ExtensionContext;
-  private readonly workspaceFolder: vscode.WorkspaceFolder | undefined;
-  private readonly status: RubyStatus;
   // Event emitter for Ruby environment changes
   private readonly rubyChangeEmitter = new vscode.EventEmitter<RubyChangeEvent>();
 
   constructor(context: vscode.ExtensionContext, logger: vscode.LogOutputChannel) {
     this.context = context;
     this.logger = logger;
+  }
+
+  async activate(): Promise<void> {
     this.workspaceFolder = vscode.workspace.workspaceFolders?.[0];
 
     this.logger.info("Ruby Environments extension activating...");
@@ -35,14 +39,12 @@ export class RubyEnvironment implements RubyEnvironmentsApi {
 
     // Create the status item
     this.status = new RubyStatus();
-    context.subscriptions.push(this.status);
+    this.context.subscriptions.push(this.status);
 
     // Setup watchers and commands
     this.setupConfigWatcher();
     this.registerCommands();
-  }
 
-  async activate(): Promise<void> {
     this.logger.info("Activating Ruby environment...");
     this.currentRubyDefinition = await this.versionManager.activate();
 

src/test/extension.test.ts

@@ -1,8 +1,39 @@
 import * as assert from "assert";
-import { suite, test } from "mocha";
-import { deactivate } from "../extension";
+import { suite, test, beforeEach, afterEach } from "mocha";
+import { activate, deactivate } from "../extension";
+import { FakeContext, createContext } from "./helpers";
+import { RubyEnvironmentsApi } from "../types";
 
 suite("Extension Test Suite", () => {
+  suite("activate", () => {
+    let context: FakeContext;
+
+    beforeEach(() => {
+      context = createContext();
+    });
+
+    afterEach(() => {
+      context.dispose();
+    });
+
+    test("returns an object implementing RubyEnvironmentsApi", () => {
+      const api = activate(context);
+
+      // Verify the returned object has the required API methods
+      assert.strictEqual(typeof api, "object", "activate should return an object");
+      assert.strictEqual(typeof api.activate, "function", "API should have an activate method");
+      assert.strictEqual(typeof api.getRuby, "function", "API should have a getRuby method");
+    });
+
+    test("returned API conforms to RubyEnvironmentsApi interface", () => {
+      const api = activate(context);
+
+      // Type assertion to ensure the return value conforms to the interface
+      const typedApi: RubyEnvironmentsApi = api;
+      assert.ok(typedApi, "API should conform to RubyEnvironmentsApi interface");
+    });
+  });
+
   suite("deactivate", () => {
     test("can be called without errors", () => {
       assert.doesNotThrow(() => {

src/test/rubyEnvironment.test.ts

@@ -2,23 +2,9 @@ import * as assert from "assert";
 import { suite, test, beforeEach, afterEach } from "mocha";
 import * as vscode from "vscode";
 import { RubyEnvironment } from "../rubyEnvironment";
+import { FakeContext, createContext } from "./helpers";
 
 suite("RubyEnvironment Test Suite", () => {
-  type FakeContext = vscode.ExtensionContext & { dispose: () => void };
-
-  function createContext() {
-    const subscriptions: vscode.Disposable[] = [];
-
-    return {
-      subscriptions,
-      dispose: () => {
-        subscriptions.forEach((subscription) => {
-          subscription.dispose();
-        });
-      },
-    } as unknown as FakeContext;
-  }
-
   function createMockLogger(): vscode.LogOutputChannel {
     return {
       info: () => {},
@@ -50,14 +36,27 @@ suite("RubyEnvironment Test Suite", () => {
       assert.strictEqual(typeof rubyEnvironment.getRuby, "function", "getRuby should be a function");
     });
 
-    test("registers config watcher, status item, and command subscriptions", () => {
-      new RubyEnvironment(context, mockLogger);
+    suite("activate", () => {
+      test("registers config watcher, status item, and command subscriptions", async () => {
+        const rubyEnvironment = new RubyEnvironment(context, mockLogger);
+
+        await rubyEnvironment.activate();
 
-      assert.strictEqual(
-        context.subscriptions.length,
-        3,
-        "Extension should register three subscriptions (status item, config watcher, and command)",
-      );
+        assert.strictEqual(
+          context.subscriptions.length,
+          3,
+          "Extension should register three subscriptions (status item, config watcher, and command)",
+        );
+      });
+
+      test("registers selectRubyVersion command", async () => {
+        const rubyEnvironment = new RubyEnvironment(context, mockLogger);
+
+        await rubyEnvironment.activate();
+
+        const commands = await vscode.commands.getCommands(true);
+        assert.ok(commands.includes("ruby-environments.selectRubyVersion"), "Command should be registered");
+      });
     });
 
     test("returns initial Ruby definition from configuration", () => {
@@ -68,12 +67,5 @@ suite("RubyEnvironment Test Suite", () => {
       // Since no configuration is set in tests, it should return null
       assert.strictEqual(result, null, "getRuby should return null when no configuration is set");
     });
-
-    test("registers selectRubyVersion command", async () => {
-      new RubyEnvironment(context, mockLogger);
-
-      const commands = await vscode.commands.getCommands(true);
-      assert.ok(commands.includes("ruby-environments.selectRubyVersion"), "Command should be registered");
-    });
   });
 });