Add support for scopes in hh autocomplete (#4593)

Author: ChristopherDedominici

.changeset/giant-books-tie.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Added support for scopes in hh autocomplete.

packages/hardhat-core/src/internal/cli/autocomplete.ts

@@ -2,7 +2,7 @@ import findup from "find-up";
 import * as fs from "fs-extra";
 import * as path from "path";
 
-import { HardhatRuntimeEnvironment } from "../../types";
+import { HardhatRuntimeEnvironment, TaskDefinition } from "../../types";
 import { HARDHAT_PARAM_DEFINITIONS } from "../core/params/hardhat-params";
 import { getCacheDir } from "../util/global-dir";
 import { createNonCryptographicHashBasedIdentifier } from "../util/hash";
@@ -22,19 +22,30 @@ interface CompletionEnv {
   point: number;
 }
 
+interface Task {
+  name: string;
+  description: string;
+  isSubtask: boolean;
+  paramDefinitions: {
+    [paramName: string]: {
+      name: string;
+      description: string;
+      isFlag: boolean;
+    };
+  };
+}
+
 interface CompletionData {
   networks: string[];
   tasks: {
-    [taskName: string]: {
+    [taskName: string]: Task;
+  };
+  scopes: {
+    [scopeName: string]: {
       name: string;
       description: string;
-      isSubtask: boolean;
-      paramDefinitions: {
-        [paramName: string]: {
-          name: string;
-          description: string;
-          isFlag: boolean;
-        };
+      tasks: {
+        [taskName: string]: Task;
       };
     };
   };
@@ -63,12 +74,12 @@ export async function complete({
     return [];
   }
 
-  const { networks, tasks } = completionData;
+  const { networks, tasks, scopes } = completionData;
 
   const words = line.split(/\s+/).filter((x) => x.length > 0);
 
   const wordsBeforeCursor = line.slice(0, point).split(/\s+/);
-  // examples:
+  // 'prev' and 'last' variables examples:
   // `hh compile --network|` => prev: "compile" last: "--network"
   // `hh compile --network |` => prev: "--network" last: ""
   // `hh compile --network ha|` => prev: "--network" last: "ha"
@@ -83,28 +94,58 @@ export async function complete({
     }))
     .filter((x) => !words.includes(x.name));
 
-  // check if the user entered a task
-  let task: string | undefined;
+  // Get the task or scope if the user has entered one
+  let taskName: string | undefined;
+  let scopeName: string | undefined;
+
   let index = 1;
   while (index < words.length) {
-    if (isGlobalFlag(words[index])) {
+    const word = words[index];
+
+    if (isGlobalFlag(word)) {
       index += 1;
-    } else if (isGlobalParam(words[index])) {
+    } else if (isGlobalParam(word)) {
       index += 2;
-    } else if (words[index].startsWith("--")) {
+    } else if (word.startsWith("--")) {
       index += 1;
     } else {
-      task = words[index];
-      break;
+      // Possible scenarios:
+      // - no task or scope: `hh `
+      // - only a task: `hh task `
+      // - only a scope: `hh scope `
+      // - both a scope and a task (the task always follow the scope): `hh scope task `
+      // Between a scope and a task there could be other words, e.g.: `hh scope --flag task `
+      if (scopeName === undefined) {
+        if (tasks[word] !== undefined) {
+          taskName = word;
+          break;
+        } else if (scopes[word] !== undefined) {
+          scopeName = word;
+        }
+      } else {
+        taskName = word;
+        break;
+      }
+
+      index += 1;
     }
   }
 
-  // if a task was found but it's equal to the last word, it means
-  // that the cursor is after the task, we ignore the task in this
-  // case because if you have a task `foo` and `foobar` and the
-  // line is: `hh foo|`, we want tasks to be suggested
-  if (task === last) {
-    task = undefined;
+  // If a task or a scope is found and it is equal to the last word,
+  // this indicates that the cursor is positioned after the task or scope.
+  // In this case, we ignore the task or scope. For instance, if you have a task or a scope named 'foo' and 'foobar',
+  // and the line is 'hh foo|', we want to suggest the value for 'foo' and 'foobar'.
+  // Possible scenarios:
+  // - no task or scope: `hh ` -> task and scope already undefined
+  // - only a task: `hh task ` -> task set to undefined, scope already undefined
+  // - only a scope: `hh scope ` -> scope set to undefined, task already undefined
+  // - both a scope and a task (the task always follow the scope): `hh scope task ` -> task set to undefined, scope stays defined
+  if (taskName === last || scopeName === last) {
+    if (taskName !== undefined && scopeName !== undefined) {
+      [taskName, scopeName] = [undefined, scopeName];
+    } else {
+      [taskName, scopeName] = [undefined, undefined];
+    }
   }
 
   if (prev === "--network") {
@@ -114,6 +155,16 @@ export async function complete({
     }));
   }
 
+  const scopeDefinition =
+    scopeName === undefined ? undefined : scopes[scopeName];
+
+  const taskDefinition =
+    taskName === undefined
+      ? undefined
+      : scopeDefinition === undefined
+      ? tasks[taskName]
+      : scopeDefinition.tasks[taskName];
+
   // if the previous word is a param, then a value is expected
   // we don't complete anything here
   if (prev.startsWith("-")) {
@@ -125,39 +176,60 @@ export async function complete({
     }
 
     const isTaskParam =
-      task !== undefined &&
-      tasks[task]?.paramDefinitions[paramName]?.isFlag === false;
+      taskDefinition?.paramDefinitions[paramName]?.isFlag === false;
 
     if (isTaskParam) {
       return HARDHAT_COMPLETE_FILES;
     }
   }
 
-  // if there's no task, we complete either tasks or params
-  if (task === undefined || tasks[task] === undefined) {
+  // If there's no task or scope, we complete either tasks and scopes or params
+  if (taskDefinition === undefined && scopeDefinition === undefined) {
+    if (last.startsWith("-")) {
+      return coreParams.filter((param) => startsWithLast(param.name));
+    }
+
     const taskSuggestions = Object.values(tasks)
       .filter((x) => !x.isSubtask)
       .map((x) => ({
         name: x.name,
         description: x.description,
       }));
-    if (last.startsWith("-")) {
-      return coreParams.filter((param) => startsWithLast(param.name));
-    }
-    return taskSuggestions.filter((x) => startsWithLast(x.name));
+
+    const scopeSuggestions = Object.values(scopes).map((x) => ({
+      name: x.name,
+      description: x.description,
+    }));
+
+    return taskSuggestions
+      .concat(scopeSuggestions)
+      .filter((x) => startsWithLast(x.name));
+  }
+
+  // If there's a scope but not a task, we complete with the scopes'tasks
+  if (taskDefinition === undefined && scopeDefinition !== undefined) {
+    return Object.values(scopes[scopeName!].tasks)
+      .filter((x) => !x.isSubtask)
+      .map((x) => ({
+        name: x.name,
+        description: x.description,
+      }))
+      .filter((x) => startsWithLast(x.name));
   }
 
   if (!last.startsWith("-")) {
     return HARDHAT_COMPLETE_FILES;
   }
 
-  // if there's a task and the last word starts with -, we complete its params and the global params
-  const taskParams = Object.values(tasks[task].paramDefinitions)
-    .map((param) => ({
-      name: ArgumentsParser.paramNameToCLA(param.name),
-      description: param.description,
-    }))
-    .filter((x) => !words.includes(x.name));
+  const taskParams =
+    taskDefinition === undefined
+      ? []
+      : Object.values(taskDefinition.paramDefinitions)
+          .map((param) => ({
+            name: ArgumentsParser.paramNameToCLA(param.name),
+            description: param.description,
+          }))
+          .filter((x) => !words.includes(x.name));
 
   return [...taskParams, ...coreParams].filter((suggestion) =>
     startsWithLast(suggestion.name)
@@ -195,27 +267,43 @@ async function getCompletionData(): Promise<CompletionData | undefined> {
 
   // we extract the tasks data explicitly to make sure everything
   // is serializable and to avoid saving unnecessary things from the HRE
-  const tasks: CompletionData["tasks"] = mapValues(hre.tasks, (task) => ({
-    name: task.name,
-    description: task.description ?? "",
-    isSubtask: task.isSubtask,
-    paramDefinitions: mapValues(task.paramDefinitions, (paramDefinition) => ({
-      name: paramDefinition.name,
-      description: paramDefinition.description ?? "",
-      isFlag: paramDefinition.isFlag,
-    })),
+  const tasks: CompletionData["tasks"] = mapValues(hre.tasks, (task) =>
+    getTaskFromTaskDefinition(task)
+  );
+
+  const scopes: CompletionData["scopes"] = mapValues(hre.scopes, (scope) => ({
+    name: scope.name,
+    description: scope.description ?? "",
+    tasks: mapValues(scope.tasks, (task) => getTaskFromTaskDefinition(task)),
   }));
 
   const completionData: CompletionData = {
     networks,
     tasks,
+    scopes,
   };
 
   await saveCachedCompletionData(projectId, completionData, mtimes);
 
   return completionData;
 }
 
+function getTaskFromTaskDefinition(taskDef: TaskDefinition): Task {
+  return {
+    name: taskDef.name,
+    description: taskDef.description ?? "",
+    isSubtask: taskDef.isSubtask,
+    paramDefinitions: mapValues(
+      taskDef.paramDefinitions,
+      (paramDefinition) => ({
+        name: paramDefinition.name,
+        description: paramDefinition.description ?? "",
+        isFlag: paramDefinition.isFlag,
+      })
+    ),
+  };
+}
+
 function getProjectId(): string | undefined {
   const packageJsonPath = findup.sync("package.json");
 

packages/hardhat-core/test/fixture-projects/autocomplete/custom-scopes/hardhat.config.js

@@ -0,0 +1,18 @@
+const scope1 = scope("scope1");
+scope1.task("task1", "task1 description").setAction(async () => {});
+scope1
+  .task("task2", "task2 description")
+  .setAction(async () => {})
+  .addFlag("flag1", "flag1 description")
+  .addFlag("flag2")
+  .addFlag("tmpflag");
+
+const scope2 = scope("scope-2", "scope-2 description");
+
+const scope3 = scope("scope-3", "scope-3 description");
+scope3.task("scope-3", "task description").setAction(async () => {});
+scope3.task("compile").setAction(async () => {});
+
+module.exports = {
+  solidity: "0.7.3",
+};

packages/hardhat-core/test/fixture-projects/autocomplete/custom-scopes/package.json

@@ -0,0 +1,3 @@
+{
+  "name": "custom-scopes"
+}

packages/hardhat-core/test/fixture-projects/autocomplete/overriden-task/hardhat.config.js packages/hardhat-core/test/fixture-projects/autocomplete/overridden-task/hardhat.config.js

@@ -0,0 +1,3 @@
+{
+  "name": "overridden-task"
+}

packages/hardhat-core/test/fixture-projects/autocomplete/overridden-task/package.json

@@ -66,6 +66,11 @@ const coreTasks = [
     description: "Runs mocha tests",
     name: "test",
   },
+  // 'vars' is a scope
+  {
+    description: "Manage your configuration variables",
+    name: "vars",
+  },
 ];
 
 const verboseParam = {
@@ -151,6 +156,17 @@ describe("autocomplete", function () {
       expect(suggestions).to.have.deep.members(coreTasks);
     });
 
+    it("should suggest all tasks' names that starts with the correct letters", async () => {
+      const suggestions = await complete("hh t");
+
+      expect(suggestions).same.deep.members([
+        {
+          name: "test",
+          description: "Runs mocha tests",
+        },
+      ]);
+    });
+
     it("should suggest all core params after a -", async () => {
       const suggestions = await complete("hh -");
 
@@ -347,6 +363,14 @@ describe("autocomplete", function () {
 
       expect(suggestions).to.equal(HARDHAT_COMPLETE_FILES);
     });
+
+    it("should not confuse arguments as scopes", async () => {
+      // "flatten" should not be identified as scope and "contracts/foo.sol" should
+      // not be identified as task
+      const suggestions = await complete("hh flatten contracts/foo.sol");
+
+      expect(suggestions).to.equal(HARDHAT_COMPLETE_FILES);
+    });
   });
 
   describe("custom tasks", () => {
@@ -402,14 +426,14 @@ describe("autocomplete", function () {
     });
   });
 
-  describe("overriden task", () => {
-    useFixtureProject("autocomplete/overriden-task");
+  describe("overridden task", () => {
+    useFixtureProject("autocomplete/overridden-task");
 
     after(() => {
       resetHardhatContext();
     });
 
-    it("should work when a task is overriden", async () => {
+    it("should work when a task is overridden", async () => {
       const suggestions = await complete("hh ");
       expect(suggestions).to.have.deep.members(coreTasks);
     });
@@ -420,4 +444,196 @@ describe("autocomplete", function () {
       expect(suggestions).to.have.deep.members(coreTasks);
     });
   });
+
+  describe("scopes", () => {
+    describe("autocomplete the scope'tasks", () => {
+      useFixtureProject("autocomplete/basic-project");
+
+      it("should suggest the tasks assigned to a scope", async () => {
+        const suggestions = await complete("hh vars ");
+
+        expect(suggestions).same.deep.members([
+          {
+            description: "Set the value of a configuration variable",
+            name: "set",
+          },
+          {
+            description: "Get the value of a configuration variable",
+            name: "get",
+          },
+          {
+            description: "List all the configuration variables",
+            name: "list",
+          },
+          {
+            description: "Delete a configuration variable",
+            name: "delete",
+          },
+          {
+            description:
+              "Show the path of the file where all the configuration variables are stored",
+            name: "path",
+          },
+          {
+            description:
+              "Show how to setup the configuration variables used by this project",
+            name: "setup",
+          },
+        ]);
+      });
+    });
+
+    describe("custom scopes", () => {
+      useFixtureProject("autocomplete/custom-scopes");
+
+      after(() => {
+        resetHardhatContext();
+      });
+
+      it("should include custom scopes", async () => {
+        const suggestions = await complete("hh ");
+
+        expect(suggestions).to.have.deep.members([
+          ...coreTasks,
+          {
+            name: "scope1",
+            description: "",
+          },
+          {
+            name: "scope-2",
+            description: "scope-2 description",
+          },
+          {
+            name: "scope-3",
+            description: "scope-3 description",
+          },
+        ]);
+      });
+
+      it("should complete scopes after a - in the middle of the scope name", async () => {
+        const suggestions = await complete("hh scope-");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "scope-2",
+            description: "scope-2 description",
+          },
+          {
+            name: "scope-3",
+            description: "scope-3 description",
+          },
+        ]);
+      });
+
+      it("should autocomplete with the scope's tasks", async () => {
+        const suggestions = await complete("hh scope1 ");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "task1",
+            description: "task1 description",
+          },
+          {
+            name: "task2",
+            description: "task2 description",
+          },
+        ]);
+      });
+
+      it("should not autocomplete with the scope's tasks, because there are no tasks assigned", async () => {
+        const suggestions = await complete("hh scope-2 ");
+
+        expect(suggestions).to.have.deep.members([]);
+      });
+
+      it("should autocomplete with the scope's task's flags and the core parameters", async () => {
+        const suggestions = await complete("hh scope1 task2 --flag --");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "--flag1",
+            description: "flag1 description",
+          },
+          {
+            name: "--flag2",
+            description: "",
+          },
+          {
+            name: "--tmpflag",
+            description: "",
+          },
+          ...coreParams,
+        ]);
+      });
+
+      it("should autocomplete with the matching flags", async () => {
+        const suggestions = await complete("hh scope1 task2 --fla");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "--flag1",
+            description: "flag1 description",
+          },
+          {
+            name: "--flag2",
+            description: "",
+          },
+          {
+            description: "Generate a flamegraph of your Hardhat tasks",
+            name: "--flamegraph",
+          },
+        ]);
+      });
+
+      it("should autocomplete with the matching flags that haven't been used yet", async () => {
+        const suggestions = await complete(
+          "hh scope1 --flamegraph task2 --fla"
+        );
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "--flag1",
+            description: "flag1 description",
+          },
+          {
+            name: "--flag2",
+            description: "",
+          },
+        ]);
+      });
+
+      it("should autocomplete with a scope's task that has the same name as the scope itself", async () => {
+        const suggestions = await complete("hh scope-3 s");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "scope-3",
+            description: "task description",
+          },
+        ]);
+      });
+
+      it("should autocomplete with a scope's task that has the same name as a stand alone task", async () => {
+        const suggestions = await complete("hh scope-3 c");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "compile",
+            description: "",
+          },
+        ]);
+      });
+
+      it("should autocomplete with a scope's task that with the task being declared after a flag", async () => {
+        const suggestions = await complete("hh scope-3 --verbose c");
+
+        expect(suggestions).to.have.deep.members([
+          {
+            name: "compile",
+            description: "",
+          },
+        ]);
+      });
+    });
+  });
 });