Merge pull request #2845 from akshita31/vscode_clipboard

Help users file issues using the clipboard

Author: akshita31

package-lock.json

@@ -801,7 +801,7 @@
       },
       {
         "command": "csharp.reportIssue",
-        "title": "Start authoring a new issue on GitHub",
+        "title": "Report an issue",
         "category": "CSharp"
       },
       {

package.json

@@ -20,7 +20,7 @@ export default async function reportIssue(vscode: vscode, eventStream: EventStre
     let extensions = getInstalledExtensions(vscode);
     let csharpExtVersion = getCsharpExtensionVersion(vscode);
 
-    const body = encodeURIComponent(`## Issue Description ##
+    const body =`## Issue Description ##
 ## Steps to Reproduce ##
 
 ## Expected Behavior ##
@@ -46,11 +46,12 @@ ${dotnetInfo}</details>
 <details><summary>Visual Studio Code Extensions</summary>
 ${generateExtensionTable(extensions)}
 </details>
-`);
-
-    const encodedBody = encodeURIComponent(body);
+`;
+    
     const queryStringPrefix: string = "?";
-    const fullUrl = `${issuesUrl}${queryStringPrefix}body=${encodedBody}`;
+    const issueDefault = "Please paste the output from your clipboard";
+    const fullUrl = `${issuesUrl}${queryStringPrefix}body=${issueDefault}`;
+    await vscode.env.clipboard.writeText(body);
     eventStream.post(new OpenURL(fullUrl));
 }
 

src/features/reportIssue.ts

@@ -16,7 +16,7 @@ export class OpenURLObserver {
         switch (event.type) {
             case EventType.OpenURL:
                 let url = (<OpenURL>event).url;
-                this.vscode.commands.executeCommand("vscode.open", this.vscode.Uri.parse(url));
+                this.vscode.env.openExternal(this.vscode.Uri.parse(url));
                 break;
         }
     }

src/observers/OpenURLObserver.ts

@@ -418,6 +418,21 @@ export interface Uri {
     toJSON(): any;
 }
 
+export interface Clipboard {
+
+    /**
+     * Read the current clipboard contents as text.
+     * @returns A thenable that resolves to a string.
+     */
+    readText(): Thenable<string>;
+
+    /**
+     * Writes text into the clipboard.
+     * @returns A thenable that resolves when writing happened.
+     */
+    writeText(value: string): Thenable<void>;
+}
+
 export interface MessageItem {
 
     /**
@@ -902,7 +917,7 @@ interface Thenable<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => void): Thenable<TResult>;
 }
 
-export interface Extension<T>{
+export interface Extension<T> {
     readonly id: string;
     readonly packageJSON: any;
 }
@@ -935,4 +950,14 @@ export interface vscode {
     };
 
     version: string;
+
+    env: {
+        appName: string;
+        appRoot: string;
+        language: string;
+        clipboard: Clipboard;
+        machineId: string;
+        sessionId: string;
+        openExternal(target: Uri): Thenable<boolean>;
+    };
 }

src/vscodeAdapter.ts

@@ -44,6 +44,7 @@ suite(`${reportIssue.name}`, () => {
     let eventBus: TestEventBus;
     let getDotnetInfo = FakeGetDotnetInfo;
     let options: Options;
+    let issueBody: string;
 
     setup(() => {
         vscode = getFakeVsCode();
@@ -55,6 +56,12 @@ suite(`${reportIssue.name}`, () => {
                 id: ""
             };
         };
+
+        vscode.env.clipboard.writeText = (body:string) => {
+            issueBody = body;
+            return undefined;
+        };
+
         vscode.version = vscodeVersion;
         vscode.extensions.all = [extension1, extension2];
         eventStream = new EventStream();
@@ -72,60 +79,56 @@ suite(`${reportIssue.name}`, () => {
     test(`${OpenURL.name} event is created with the omnisharp-vscode github repo issues url`, async () => {
         await reportIssue(vscode, eventStream, getDotnetInfo, false, options, fakeMonoResolver);
         let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.include("https://github.com/OmniSharp/omnisharp-vscode/issues/new");
+        expect(url).to.include("https://github.com/OmniSharp/omnisharp-vscode/issues/new?body=Please paste the output from your clipboard");
     });
 
-    test("The url contains the vscode version", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.include(encodeURIComponent(encodeURIComponent(`**VSCode version**: ${vscodeVersion}`)));
-    });
+    suite("The body is passed to the vscode clipboard and", () => {
+        test("it contains the vscode version", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(issueBody).to.include(`**VSCode version**: ${vscodeVersion}`);
+        });
 
-    test("The body contains the csharp extension version", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.include(encodeURIComponent(encodeURIComponent(`**C# Extension**: ${csharpExtVersion}`)));
-    });
+        test("it contains the csharp extension version", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(issueBody).to.include(`**C# Extension**: ${csharpExtVersion}`);
+        });
 
-    test("dotnet info is obtained and put into the url", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.contain(fakeDotnetInfo);
-    });
+        test("it contains dotnet info", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(issueBody).to.contain(fakeDotnetInfo);
+        });
 
-    test("mono information is obtained when it is a valid mono platform", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
-    });
+        test("mono information is obtained when it is a valid mono platform", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
+        });
 
-    test("mono version is put in the body when shouldUseGlobalMono returns a monoInfo", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.contain(fakeMonoInfo.version);
-    });
+        test("mono version is put in the body when shouldUseGlobalMono returns a monoInfo", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
+            expect(issueBody).to.contain(fakeMonoInfo.version);
+        });
 
-    test("built-in mono usage message is put in the body when shouldUseGlobalMono returns a null", async () => {
-        fakeMonoResolver = new FakeMonoResolver(false);
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.contain(encodeURIComponent(encodeURIComponent(`OmniSharp using built-in mono`)));
-    });
+        test("built-in mono usage message is put in the body when shouldUseGlobalMono returns a null", async () => {
+            fakeMonoResolver = new FakeMonoResolver(false);
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(true);
+            expect(issueBody).to.contain(`OmniSharp using built-in mono`);
+        });
 
-    test("mono information is not obtained when it is not a valid mono platform", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, false, options, fakeMonoResolver);
-        expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(false);
-    });
+        test("mono information is not obtained when it is not a valid mono platform", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, false, options, fakeMonoResolver);
+            expect(fakeMonoResolver.getGlobalMonoCalled).to.be.equal(false);
+        });
 
-    test("The url contains the name, publisher and version for all the extensions that are not builtin", async () => {
-        await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
-        let url = (<OpenURL>eventBus.getEvents()[0]).url;
-        expect(url).to.contain(extension2.packageJSON.name);
-        expect(url).to.contain(extension2.packageJSON.publisher);
-        expect(url).to.contain(extension2.packageJSON.version);
-        expect(url).to.not.contain(extension1.packageJSON.name);
-        expect(url).to.not.contain(extension1.packageJSON.publisher);
-        expect(url).to.not.contain(extension1.packageJSON.version);
+        test("The url contains the name, publisher and version for all the extensions that are not builtin", async () => {
+            await reportIssue(vscode, eventStream, getDotnetInfo, isValidForMono, options, fakeMonoResolver);
+            expect(issueBody).to.contain(extension2.packageJSON.name);
+            expect(issueBody).to.contain(extension2.packageJSON.publisher);
+            expect(issueBody).to.contain(extension2.packageJSON.version);
+            expect(issueBody).to.not.contain(extension1.packageJSON.name);
+            expect(issueBody).to.not.contain(extension1.packageJSON.publisher);
+            expect(issueBody).to.not.contain(extension1.packageJSON.version);
+        });
     });
 });

test/unitTests/features/reportIssue.test.ts

@@ -4,42 +4,39 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { OpenURLObserver } from "../../../src/observers/OpenURLObserver";
-import { vscode } from "../../../src/vscodeAdapter";
+import { vscode, Uri } from "../../../src/vscodeAdapter";
 import { getFakeVsCode } from "../testAssets/Fakes";
 import { OpenURL } from "../../../src/omnisharp/loggingEvents";
 import { expect } from "chai";
 
 suite(`${OpenURLObserver.name}`, () => {
     let observer: OpenURLObserver;
     let vscode: vscode;
-    let commands: Array<string>;
     let valueToBeParsed: string;
     const url = "someUrl";
+    let openExternalCalled: boolean;
 
     setup(() => {
         vscode = getFakeVsCode();
-        commands = [];
+        openExternalCalled = false;
         valueToBeParsed = undefined;
-        vscode.commands.executeCommand = (command: string, ...rest: any[]) => {
-            commands.push(command);
+        vscode.env.openExternal = (target: Uri) => {
+            openExternalCalled = true;
             return undefined;
         };
+
         vscode.Uri.parse = (value: string) => {
             valueToBeParsed = value;
             return undefined;
         };
-        observer = new OpenURLObserver(vscode);
-    });
 
-    test("Execute command is called with the vscode.open command", () => {
-        let event = new OpenURL(url);
-        observer.post(event);
-        expect(commands).to.be.deep.equal(["vscode.open"]);
+        observer = new OpenURLObserver(vscode);
     });
 
-    test("url is passed to the rest parameter in executeCommand via vscode.uri.parse ", () => {
+    test("openExternal function is called and the url is passed through the vscode.Uri.parse function", () => {
         let event = new OpenURL(url);
         observer.post(event);
         expect(valueToBeParsed).to.be.equal(url);
+        expect(openExternalCalled).to.be.true;
     });
 });

test/unitTests/logging/OpenURLObserver.test.ts

@@ -110,7 +110,7 @@ export function getFakeVsCode(): vscode.vscode {
         },
         window: {
             activeTextEditor: undefined,
-            showInformationMessage:  <T extends MessageItem>(message: string, ...items: T[]) => {
+            showInformationMessage: <T extends MessageItem>(message: string, ...items: T[]) => {
                 throw new Error("Not Implemented");
             },
             showWarningMessage: <T extends MessageItem>(message: string, ...items: T[]) => {
@@ -145,7 +145,25 @@ export function getFakeVsCode(): vscode.vscode {
                 throw new Error("Not Implemented");
             }
         },
-        version: ""
+        version: "",
+        env: {
+            appName: null,
+            appRoot: null,
+            language: null,
+            clipboard: {
+                writeText: () => {
+                    throw new Error("Not Implemented");
+                },
+                readText: () => {
+                    throw new Error("Not Implemented");
+                }
+            },
+            machineId: null,
+            sessionId: null,
+            openExternal: () => {
+                throw new Error("Not Implemented");
+            }
+        }
     };
 }
 
@@ -162,23 +180,20 @@ export function getWorkspaceInformationUpdated(msbuild: protocol.MsBuildWorkspac
     };
 
     return new WorkspaceInformationUpdated(a);
-} 
+}
 
 export function getVSCodeWithConfig() {
     const vscode = getFakeVsCode();
 
     const _omnisharpConfig = getWorkspaceConfiguration();
     const _csharpConfig = getWorkspaceConfiguration();
 
-    vscode.workspace.getConfiguration = (section?, resource?) =>
-    {
-        if (section === 'omnisharp')
-        {
+    vscode.workspace.getConfiguration = (section?, resource?) => {
+        if (section === 'omnisharp') {
             return _omnisharpConfig;
         }
 
-        if (section === 'csharp')
-        {
+        if (section === 'csharp') {
             return _csharpConfig;
         }