Enhanced Tree view

package.json

@@ -193,6 +193,12 @@
             {
                 "title": "LeetCode",
                 "properties": {
+                    "leetcode.hideSolved": {
+                        "type": "boolean",
+                        "default": false,
+                        "scope": "application",
+                        "description": "Hide solved problems."
+                    },
                     "leetcode.showLocked": {
                         "type": "boolean",
                         "default": false,
@@ -264,6 +270,7 @@
     },
     "dependencies": {
         "fs-extra": "^6.0.1",
-        "leetcode-cli": "2.6.1"
+        "leetcode-cli": "2.6.1",
+        "require-from-string": "^2.0.2"
     }
 }

src/commands/list.ts

@@ -7,15 +7,20 @@ import { leetCodeManager } from "../leetCodeManager";
 import { ProblemState, UserStatus } from "../shared";
 import { DialogType, promptForOpenOutputChannel } from "../utils/uiUtils";
 
-export interface IProblem {
-    favorite: boolean;
-    locked: boolean;
-    state: ProblemState;
-    id: string;
-    name: string;
-    difficulty: string;
-    passRate: string;
-}
+// tslint:disable-next-line:typedef
+export const IProblemDefault = {
+    favorite: false,
+    locked: false,
+    state: ProblemState.Unknown,
+    id: "",
+    name: "",
+    difficulty: "",
+    passRate: "",
+    companies: [] as string[],
+    tags: [] as string[],
+};
+
+export type IProblem = typeof IProblemDefault;
 
 export async function listProblems(): Promise<IProblem[]> {
     try {
@@ -28,17 +33,21 @@ export async function listProblems(): Promise<IProblem[]> {
         const problems: IProblem[] = [];
         const lines: string[] = result.split("\n");
         const reg: RegExp = /^(.)\s(.{1,2})\s(.)\s\[\s*(\d*)\s*\]\s*(.*)\s*(Easy|Medium|Hard)\s*\((\s*\d+\.\d+ %)\)/;
+        const { companies, tags } = await leetCodeExecutor.getCompaniesAndTags();
         for (const line of lines) {
             const match: RegExpMatchArray | null = line.match(reg);
             if (match && match.length === 8) {
+                const id: string = match[4].trim();
                 problems.push({
+                    id,
                     favorite: match[1].trim().length > 0,
                     locked: match[2].trim().length > 0,
                     state: parseProblemState(match[3]),
-                    id: match[4].trim(),
                     name: match[5].trim(),
                     difficulty: match[6].trim(),
                     passRate: match[7].trim(),
+                    companies: companies[id] || ["Unknown"],
+                    tags: tags[id] || ["Unknown"],
                 });
             }
         }

src/leetCodeExecutor.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import * as cp from "child_process";
+import * as fs from "fs";
 import * as path from "path";
 import * as vscode from "vscode";
 import { Endpoint } from "./shared";
@@ -10,28 +11,31 @@ import { DialogOptions, openUrl } from "./utils/uiUtils";
 import * as wsl from "./utils/wslUtils";
 
 class LeetCodeExecutor {
-    private leetCodeBinaryPath: string;
-    private leetCodeBinaryPathInWsl: string;
+    private leetCodeRootPath: string;
+    private leetCodeRootPathInWsl: string;
 
     constructor() {
-        this.leetCodeBinaryPath = path.join(__dirname, "..", "..", "node_modules", "leetcode-cli", "bin", "leetcode");
-        this.leetCodeBinaryPathInWsl = "";
+        this.leetCodeRootPath = path.join(__dirname, "..", "..", "node_modules", "leetcode-cli");
+        this.leetCodeRootPathInWsl = "";
     }
 
-    public async getLeetCodeBinaryPath(): Promise<string> {
+    public async getLeetCodeRootPath(): Promise<string> { // not wrapped by ""
         if (wsl.useWsl()) {
-            if (!this.leetCodeBinaryPathInWsl) {
-                this.leetCodeBinaryPathInWsl = `${await wsl.toWslPath(this.leetCodeBinaryPath)}`;
+            if (!this.leetCodeRootPathInWsl) {
+                this.leetCodeRootPathInWsl = `${await wsl.toWslPath(this.leetCodeRootPath)}`;
             }
-            return `"${this.leetCodeBinaryPathInWsl}"`;
+            return `${this.leetCodeRootPathInWsl}`;
         }
-        return `"${this.leetCodeBinaryPath}"`;
+        return `${this.leetCodeRootPath}`;
+    }
+
+    public async getLeetCodeBinaryPath(): Promise<string> { // wrapped by ""
+        return `"${path.join(await this.getLeetCodeRootPath(), "bin", "leetcode")}"`;
     }
 
     public async meetRequirements(): Promise<boolean> {
         try {
             await this.executeCommandEx("node", ["-v"]);
-            return true;
         } catch (error) {
             const choice: vscode.MessageItem | undefined = await vscode.window.showErrorMessage(
                 "LeetCode extension needs Node.js installed in environment path",
@@ -42,6 +46,12 @@ class LeetCodeExecutor {
             }
             return false;
         }
+        try { // Check company plugin
+            await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-e", "company"]);
+        } catch (error) { // Download company plugin and activate
+            await this.executeCommandEx("node", [await this.getLeetCodeBinaryPath(), "plugin", "-i", "company"]);
+        }
+        return true;
     }
 
     public async deleteCache(): Promise<string> {
@@ -100,6 +110,19 @@ class LeetCodeExecutor {
         }
     }
 
+    public async getCompaniesAndTags(): Promise<{ companies: { [key: string]: string[] }, tags: { [key: string]: string[] } }> {
+        // preprocess the plugin source
+        const componiesTagsPath: string = path.join(await leetCodeExecutor.getLeetCodeRootPath(), "lib", "plugins", "company.js");
+        const componiesTagsSrc: string = (await fs.readFileSync(componiesTagsPath, "utf8")).replace(
+            "module.exports = plugin",
+            "module.exports = { COMPONIES, TAGS }",
+        );
+        // require plugin from modified string
+        const requireFromString: (src: string, path: string) => any = require("require-from-string");
+        const { COMPONIES, TAGS } = requireFromString(componiesTagsSrc, componiesTagsPath);
+        return { companies: COMPONIES, tags: TAGS };
+    }
+
     private async executeCommandEx(command: string, args: string[], options: cp.SpawnOptions = { shell: true }): Promise<string> {
         if (wsl.useWsl()) {
             return await executeCommand("wsl", [command].concat(args), options);