feat(vscode): provide Debug CodeLens on route handlers (#973)

Author: alestiago

extensions/vscode/README.md

@@ -24,7 +24,7 @@ Dart Frog can be installed from the [VS Code Marketplace](https://marketplace.vi
 | `Dart Frog: Start Daemon`                       | Starts the Dart Frog daemon          | Command palette                 |
 | `Dart Frog: Start Development Server`           | Starts a Dart Frog server            | Command palette and CodeLens    |
 | `Dart Frog: Debug Development Server`           | Debugs a Dart Frog server            | Command palette                 |
-| `Dart Frog: Start and Debug Development Server` | Starts and debugs a Dart Frog server | Command palette                 |
+| `Dart Frog: Start and Debug Development Server` | Starts and debugs a Dart Frog server | Command palette and CodeLens    |
 | `Dart Frog: Stop Development Server`            | Stops a Dart Frog server             | Command palette                 |
 
 ## Configuration

extensions/vscode/src/code-lens/on-request-code-lens.ts

@@ -114,3 +114,22 @@ export class RunOnRequestCodeLensProvider extends OnRequestCodeLensProvider {
     return codeLens;
   }
 }
+
+/**
+ * Shows a "Debug" CodeLens on route handlers, which allows starting and
+ * debugging a development server.
+ */
+export class DebugOnRequestCodeLensProvider extends OnRequestCodeLensProvider {
+  public resolveCodeLens?(codeLens: CodeLens): ProviderResult<CodeLens> {
+    if (!super.resolveCodeLens!(codeLens)) {
+      return undefined;
+    }
+
+    codeLens.command = {
+      title: "Debug",
+      tooltip: "Starts and debugs a development server",
+      command: "dart-frog.start-debug-dev-server",
+    };
+    return codeLens;
+  }
+}

extensions/vscode/src/extension.ts

@@ -1,4 +1,8 @@
 import * as vscode from "vscode";
+import {
+  DebugOnRequestCodeLensProvider,
+  RunOnRequestCodeLensProvider,
+} from "./code-lens";
 import {
   create,
   debugDevServer,
@@ -19,7 +23,6 @@ import {
   readLatestDartFrogCLIVersion,
   suggestInstallingDartFrogCLI,
 } from "./utils";
-import { RunOnRequestCodeLensProvider } from "./code-lens";
 
 /**
  * This method is called when the extension is activated.
@@ -42,6 +45,10 @@ export function activate(
     ensureCompatibleCLI();
   }
 
+  vscode.languages.registerCodeLensProvider(
+    "dart",
+    new DebugOnRequestCodeLensProvider()
+  );
   vscode.languages.registerCodeLensProvider(
     "dart",
     new RunOnRequestCodeLensProvider()

extensions/vscode/src/test/suite/code-lens/on-request-code-lens.test.ts

@@ -5,6 +5,42 @@ import * as assert from "assert";
 import { CodeLens, Position, workspace } from "vscode";
 import { afterEach, beforeEach } from "mocha";
 
+/**
+ * The content of a route file.
+ */
+const routeContent = `
+import 'package:dart_frog/dart_frog.dart';
+
+Response onRequest(RequestContext context) {
+  return Response(body: 'Welcome to Dart Frog!');
+}
+
+`;
+
+/**
+ * The content of a route file with a dynamic route.
+ */
+const dynamicRouteContent = `
+import 'package:dart_frog/dart_frog.dart';
+
+Response onRequest(RequestContext context, String id) {
+  return Response(body: 'Welcome to Dart Frog!');
+}
+
+`;
+
+/**
+ * The content of something that looks like a route file but isn't.
+ */
+const invalidRouteContent = `
+import 'package:dart_frog/dart_frog.dart';
+
+Response notOnRequest(RequestContext context) {
+  return Response(body: 'Welcome to Dart Frog!');
+}
+
+`;
+
 suite("RunOnRequestCodeLensProvider", () => {
   let vscodeStub: any;
   let utilsStub: any;
@@ -22,8 +58,7 @@ suite("RunOnRequestCodeLensProvider", () => {
     };
     workspaceConfiguration = sinon.stub();
     vscodeStub.workspace.getConfiguration.returns(workspaceConfiguration);
-    const getConfiguration = sinon.stub();
-    workspaceConfiguration.get = getConfiguration;
+    const getConfiguration = (workspaceConfiguration.get = sinon.stub());
     getConfiguration.withArgs("enableCodeLens", true).returns(true);
 
     utilsStub = {
@@ -134,14 +169,7 @@ suite("RunOnRequestCodeLensProvider", () => {
     });
 
     test("returns the correct CodeLenses", async () => {
-      const content = `
-import 'package:dart_frog/dart_frog.dart';
-
-Response onRequest(RequestContext context) {
-  return Response(body: 'Welcome to Dart Frog!');
-}
-
-`;
+      const content = routeContent;
       const textDocument = await workspace.openTextDocument({
         language: "text",
         content,
@@ -168,14 +196,7 @@ Response onRequest(RequestContext context) {
     });
 
     test("returns the correct CodeLenses on a dynamic route", async () => {
-      const content = `
-import 'package:dart_frog/dart_frog.dart';
-
-Response onRequest(RequestContext context, String id) {
-  return Response(body: 'Welcome to Dart Frog!');
-}
-
-`;
+      const content = dynamicRouteContent;
       const textDocument = await workspace.openTextDocument({
         language: "text",
         content,
@@ -202,15 +223,154 @@ Response onRequest(RequestContext context, String id) {
     });
 
     test("returns no CodeLenses on a non route file", async () => {
-      const content = `
-import 'package:dart_frog/dart_frog.dart';
+      const content = invalidRouteContent;
+      const textDocument = await workspace.openTextDocument({
+        language: "text",
+        content,
+      });
+      document.getText = textDocument.getText.bind(textDocument);
+      document.positionAt = textDocument.positionAt.bind(textDocument);
+      document.lineAt = textDocument.lineAt.bind(textDocument);
+      document.getWordRangeAtPosition =
+        textDocument.getWordRangeAtPosition.bind(textDocument);
 
-Response notOnRequest(RequestContext context) {
-  return Response(body: 'Welcome to Dart Frog!');
-}
+      const provider = new RunOnRequestCodeLensProvider();
+      const result = await provider.provideCodeLenses(document);
 
-`;
+      assert.strictEqual(result.length, 0);
+    });
+  });
+});
+
+suite("DebugOnRequestCodeLensProvider", () => {
+  let vscodeStub: any;
+  let utilsStub: any;
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  let DebugOnRequestCodeLensProvider: any;
+  let document: any;
+  let workspaceConfiguration: any;
+
+  beforeEach(() => {
+    vscodeStub = {
+      workspace: {
+        onDidChangeConfiguration: sinon.stub(),
+        getConfiguration: sinon.stub(),
+      },
+    };
+    workspaceConfiguration = sinon.stub();
+    vscodeStub.workspace.getConfiguration.returns(workspaceConfiguration);
+    const getConfiguration = (workspaceConfiguration.get = sinon.stub());
+    getConfiguration.withArgs("enableCodeLens", true).returns(true);
+
+    utilsStub = {
+      nearestDartFrogProject: sinon.stub(),
+    };
+    utilsStub.nearestDartFrogProject.returns("/home/dart_frog");
+
+    DebugOnRequestCodeLensProvider = proxyquire(
+      "../../../code-lens/on-request-code-lens",
+      {
+        vscode: vscodeStub,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        "../utils": utilsStub,
+      }
+    ).DebugOnRequestCodeLensProvider;
+
+    document = sinon.stub();
+    document.languageId = "dart";
+    document.uri = {
+      fsPath: "/home/dart_frog/routes/index.dart",
+    };
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  test("onDidChangeCodeLenses fires when configuration changes", () => {
+    const provider = new DebugOnRequestCodeLensProvider();
+    const onDidChangeCodeLenses = sinon.stub();
+    provider.onDidChangeCodeLenses(onDidChangeCodeLenses);
+
+    vscodeStub.workspace.onDidChangeConfiguration.callArg(0);
+
+    sinon.assert.calledOnce(onDidChangeCodeLenses);
+  });
+
+  suite("resolveCodeLens", () => {
+    test("returns the CodeLens when configuration is enabled", async () => {
+      workspaceConfiguration.get.withArgs("enableCodeLens", true).returns(true);
 
+      const provider = new DebugOnRequestCodeLensProvider();
+      const codeLens = new CodeLens(sinon.stub());
+      const result = await provider.resolveCodeLens(codeLens, sinon.stub());
+
+      assert.strictEqual(result, codeLens);
+      sinon.assert.match(result.command, {
+        title: "Debug",
+        tooltip: "Starts and debugs a development server",
+        command: "dart-frog.start-debug-dev-server",
+      });
+    });
+
+    test("returns undefined when configuration is disabled", async () => {
+      workspaceConfiguration.get
+        .withArgs("enableCodeLens", true)
+        .returns(false);
+
+      const provider = new DebugOnRequestCodeLensProvider();
+      const codeLens = new CodeLens(sinon.stub());
+      const result = await provider.resolveCodeLens(codeLens, sinon.stub());
+
+      assert.strictEqual(result, undefined);
+    });
+  });
+
+  suite("providesCodeLenses", () => {
+    suite("returns undefined if the document is not", () => {
+      test("a Dart file", () => {
+        document.languageId = "not-dart";
+
+        const provider = new DebugOnRequestCodeLensProvider();
+        const result = provider.provideCodeLenses(document);
+
+        assert.strictEqual(result, undefined);
+      });
+
+      test("in a Dart Frog project", () => {
+        utilsStub.nearestDartFrogProject.returns(undefined);
+
+        const provider = new DebugOnRequestCodeLensProvider();
+        const result = provider.provideCodeLenses(document);
+
+        assert.strictEqual(result, undefined);
+      });
+
+      test("in the routes folder", () => {
+        document.uri = {
+          fsPath: "/home/dart_frog/not-routes/route.dart",
+        };
+
+        const provider = new DebugOnRequestCodeLensProvider();
+        const result = provider.provideCodeLenses(document);
+
+        assert.strictEqual(result, undefined);
+      });
+
+      test("codeLens configuration is disabled", () => {
+        workspaceConfiguration.get
+          .withArgs("enableCodeLens", true)
+          .returns(false);
+
+        const provider = new DebugOnRequestCodeLensProvider();
+        const result = provider.provideCodeLenses(document);
+
+        assert.strictEqual(result, undefined);
+      });
+    });
+
+    test("returns the correct CodeLenses", async () => {
+      const content = routeContent;
       const textDocument = await workspace.openTextDocument({
         language: "text",
         content,
@@ -221,7 +381,61 @@ Response notOnRequest(RequestContext context) {
       document.getWordRangeAtPosition =
         textDocument.getWordRangeAtPosition.bind(textDocument);
 
-      const provider = new RunOnRequestCodeLensProvider();
+      const provider = new DebugOnRequestCodeLensProvider();
+      const result = await provider.provideCodeLenses(document);
+
+      assert.strictEqual(result.length, 1);
+
+      const codeLens = result[0];
+
+      const range = document.getWordRangeAtPosition(
+        new Position(3, 0),
+        /Response onRequest\(RequestContext context\) {/
+      )!;
+
+      sinon.assert.match(codeLens, new CodeLens(range));
+    });
+
+    test("returns the correct CodeLenses on a dynamic route", async () => {
+      const content = dynamicRouteContent;
+      const textDocument = await workspace.openTextDocument({
+        language: "text",
+        content,
+      });
+      document.getText = textDocument.getText.bind(textDocument);
+      document.positionAt = textDocument.positionAt.bind(textDocument);
+      document.lineAt = textDocument.lineAt.bind(textDocument);
+      document.getWordRangeAtPosition =
+        textDocument.getWordRangeAtPosition.bind(textDocument);
+
+      const provider = new DebugOnRequestCodeLensProvider();
+      const result = await provider.provideCodeLenses(document);
+
+      assert.strictEqual(result.length, 1);
+
+      const codeLens = result[0];
+
+      const range = document.getWordRangeAtPosition(
+        new Position(3, 0),
+        /Response onRequest\(RequestContext context, String id\) {/
+      )!;
+
+      sinon.assert.match(codeLens, new CodeLens(range));
+    });
+
+    test("returns no CodeLenses on a non route file", async () => {
+      const content = invalidRouteContent;
+      const textDocument = await workspace.openTextDocument({
+        language: "text",
+        content,
+      });
+      document.getText = textDocument.getText.bind(textDocument);
+      document.positionAt = textDocument.positionAt.bind(textDocument);
+      document.lineAt = textDocument.lineAt.bind(textDocument);
+      document.getWordRangeAtPosition =
+        textDocument.getWordRangeAtPosition.bind(textDocument);
+
+      const provider = new DebugOnRequestCodeLensProvider();
       const result = await provider.provideCodeLenses(document);
 
       assert.strictEqual(result.length, 0);