Support showing description from text document

package.json

@@ -215,12 +215,16 @@
             ],
             "editor/context": [
                 {
-                    "command": "leetcode.testSolution",
+                    "command": "leetcode.previewProblem",
                     "group": "leetcode@1"
                 },
                 {
-                    "command": "leetcode.submitSolution",
+                    "command": "leetcode.testSolution",
                     "group": "leetcode@2"
+                },
+                {
+                    "command": "leetcode.submitSolution",
+                    "group": "leetcode@3"
                 }
             ]
         },

src/codelens/CustomCodeLensProvider.ts

@@ -25,6 +25,10 @@ export class CustomCodeLensProvider implements vscode.CodeLensProvider {
                 title: "Test",
                 command: "leetcode.testSolution",
             }),
+            new vscode.CodeLens(range, {
+                title: "Description",
+                command: "leetcode.previewProblem",
+            }),
         ];
     }
 }

src/commands/show.ts

@@ -6,20 +6,37 @@ import * as path from "path";
 import * as unescapeJS from "unescape-js";
 import * as vscode from "vscode";
 import { LeetCodeNode } from "../explorer/LeetCodeNode";
+import { leetCodeTreeDataProvider } from "../explorer/leetCodeTreeDataProvider";
 import { leetCodeChannel } from "../leetCodeChannel";
 import { leetCodeExecutor } from "../leetCodeExecutor";
 import { leetCodeManager } from "../leetCodeManager";
 import { IProblem, IQuickItemEx, languages, ProblemState } from "../shared";
 import { DialogOptions, DialogType, promptForOpenOutputChannel, promptForSignIn } from "../utils/uiUtils";
-import { selectWorkspaceFolder } from "../utils/workspaceUtils";
+import { getActiveFilePath, selectWorkspaceFolder } from "../utils/workspaceUtils";
 import * as wsl from "../utils/wslUtils";
 import { leetCodePreviewProvider } from "../webview/leetCodePreviewProvider";
 import { leetCodeSolutionProvider } from "../webview/leetCodeSolutionProvider";
 import * as list from "./list";
 
-export async function previewProblem(node: IProblem, isSideMode: boolean = false): Promise<void> {
-    const descString: string = await leetCodeExecutor.getDescription(node);
-    leetCodePreviewProvider.show(descString, node, isSideMode);
+export async function previewProblem(source: IProblem | vscode.Uri | undefined, isSideMode: boolean = false): Promise<void> {
+    try {
+        let problem: IProblem;
+        let descString: string;
+        if (source && "difficulty" in source) {
+            problem = source;
+            descString = await leetCodeExecutor.getDescription(problem.id);
+        } else {
+            const filename: string = (await getActiveFilePath(source))!;
+            const [meta, desc] = splitMetaOutput(await leetCodeExecutor.getDescription(filename));
+            problem = leetCodeTreeDataProvider.getProblem(meta.id)!;
+            descString = desc;
+            isSideMode = true;
+        }
+        leetCodePreviewProvider.show(descString, problem, isSideMode);
+    } catch (error) {
+        leetCodeChannel.appendLine(error.toString());
+        await promptForOpenOutputChannel("Failed to preview the problem. Please open the output channel for details.", DialogType.error);
+    }
 }
 
 export async function showProblem(node?: LeetCodeNode): Promise<void> {
@@ -146,6 +163,11 @@ async function parseProblemsToPicks(p: Promise<IProblem[]>): Promise<Array<IQuic
     });
 }
 
+function splitMetaOutput(outputWithMeta: string): [{ id: string, lang: string }, string] {
+    const [metaJSON, output] = outputWithMeta.split(/\n([^]+)/);
+    return [JSON.parse(metaJSON), output];
+}
+
 function parseProblemDecorator(state: ProblemState, locked: boolean): string {
     switch (state) {
         case ProblemState.AC:

src/explorer/LeetCodeTreeDataProvider.ts → src/explorer/leetCodeTreeDataProvider.ts

@@ -12,7 +12,10 @@ import { Category, defaultProblem, IProblem, ProblemState } from "../shared";
 import { getWorkspaceConfiguration } from "../utils/workspaceUtils";
 import { LeetCodeNode } from "./LeetCodeNode";
 
-export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCodeNode> {
+class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCodeNode> {
+
+    private context: vscode.ExtensionContext;
+    private problemPool: Map<string, IProblem>; // maintains the ownership of all problems.
 
     private treeData: {
         Difficulty: Map<string, IProblem[]>,
@@ -25,13 +28,19 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
     // tslint:disable-next-line:member-ordering
     public readonly onDidChangeTreeData: vscode.Event<any> = this.onDidChangeTreeDataEvent.event;
 
-    constructor(private context: vscode.ExtensionContext) { }
+    public initialize(context: vscode.ExtensionContext): void {
+        this.context = context;
+    }
 
     public async refresh(): Promise<void> {
         await this.getProblemData();
         this.onDidChangeTreeDataEvent.fire();
     }
 
+    public getProblem(id: string): IProblem | undefined {
+        return this.problemPool.get(id);
+    }
+
     public getTreeItem(element: LeetCodeNode): vscode.TreeItem | Thenable<vscode.TreeItem> {
         if (element.id === "notSignIn") {
             return {
@@ -102,13 +111,16 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
 
     private async getProblemData(): Promise<void> {
         // clear cache
+        this.problemPool = new Map<string, IProblem>();
         this.treeData = {
             Difficulty: new Map<string, IProblem[]>(),
             Tag: new Map<string, IProblem[]>(),
             Company: new Map<string, IProblem[]>(),
             Favorite: [],
         };
         for (const problem of await list.listProblems()) {
+            // Add every problem to problem pool
+            this.problemPool.set(problem.id, problem);
             // Add favorite problem, no matter whether it is solved.
             if (problem.isFavorite) {
                 this.treeData[Category.Favorite].push(problem);
@@ -265,3 +277,5 @@ export class LeetCodeTreeDataProvider implements vscode.TreeDataProvider<LeetCod
         }
     }
 }
+
+export const leetCodeTreeDataProvider: LeetCodeTreeDataProvider = new LeetCodeTreeDataProvider();

src/extension.ts

@@ -11,7 +11,7 @@ import * as show from "./commands/show";
 import * as submit from "./commands/submit";
 import * as test from "./commands/test";
 import { LeetCodeNode } from "./explorer/LeetCodeNode";
-import { LeetCodeTreeDataProvider } from "./explorer/LeetCodeTreeDataProvider";
+import { leetCodeTreeDataProvider } from "./explorer/leetCodeTreeDataProvider";
 import { leetCodeChannel } from "./leetCodeChannel";
 import { leetCodeExecutor } from "./leetCodeExecutor";
 import { leetCodeManager } from "./leetCodeManager";
@@ -28,13 +28,13 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
             throw new Error("The environment doesn't meet requirements.");
         }
 
+        leetCodeTreeDataProvider.initialize(context);
+
         leetCodeManager.on("statusChanged", () => {
             leetCodeStatusBarController.updateStatusBar(leetCodeManager.getStatus(), leetCodeManager.getUser());
             leetCodeTreeDataProvider.refresh();
         });
 
-        const leetCodeTreeDataProvider: LeetCodeTreeDataProvider = new LeetCodeTreeDataProvider(context);
-
         context.subscriptions.push(
             leetCodeStatusBarController,
             leetCodeChannel,
@@ -51,7 +51,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
             vscode.commands.registerCommand("leetcode.signout", () => leetCodeManager.signOut()),
             vscode.commands.registerCommand("leetcode.selectSessions", () => session.selectSession()),
             vscode.commands.registerCommand("leetcode.createSession", () => session.createSession()),
-            vscode.commands.registerCommand("leetcode.previewProblem", (node: LeetCodeNode) => show.previewProblem(node)),
+            vscode.commands.registerCommand("leetcode.previewProblem", (source: LeetCodeNode | vscode.Uri) => show.previewProblem(source)),
             vscode.commands.registerCommand("leetcode.showProblem", (node: LeetCodeNode) => show.showProblem(node)),
             vscode.commands.registerCommand("leetcode.searchProblem", () => show.searchProblem()),
             vscode.commands.registerCommand("leetcode.showSolution", (node: LeetCodeNode) => show.showSolution(node)),

src/leetCodeExecutor.ts

@@ -108,12 +108,12 @@ class LeetCodeExecutor implements Disposable {
     }
 
     public async showSolution(problemNode: IProblem, language: string): Promise<string> {
-        const solution: string = await this.executeCommandWithProgressEx("Fetching top voted solution from discussions...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "--solution", "-l", language]);
+        const solution: string = await this.executeCommandWithProgressEx("Fetching top voted solution from discussions...", "node", [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "--solution", "-l", language]);
         return solution;
     }
 
-    public async getDescription(problemNode: IProblem): Promise<string> {
-        return await this.executeCommandWithProgressEx("Fetching problem description...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", problemNode.id, "-x"]);
+    public async getDescription(keyword: string): Promise<string> {
+        return await this.executeCommandWithProgressEx("Fetching problem description...", this.nodeExecutable, [await this.getLeetCodeBinaryPath(), "show", keyword, "-x"]);
     }
 
     public async listSessions(): Promise<string> {