Add ConfigurationProvider API, ${workspaceRoot} -> ${workspaceFolder} (#1801)

* Updating tasks.json schema

New tasks schema from 0.1.0 to 2.0.0

* Updating tasks.json and initialConfigurations

package.json's initialConfiguraitons have been deprecated. It uses
DebugConfigurationProvider instead.

C# extension uses generate assets initially to create launch.json and
tasks.json. However, if a user desides to dismiss the message and
generate via f5, the prompt will initiate the
DebugConfigurationProvider.

* Adding ConfigurationProvider

${workspaceRoot} is now ${workspaceFolder}

ConfigurationProvider activates on f5. This will also trigger generating
a tasks file.

tasks args are now 'build <path>', updating tests for these changes.

* API requires October 2017 Drop (1.18)

* Fixing version requirement error

* Addressing PR issues

* Detect older tasks.json

Checking if folder.uri.fsPath is a subfolder of GetSolutionPathOrFolder
to generate assets.

* Fixing PR issues

* Upgrading fs-extra for promises

* Rewriting package.json for activation events

* Reverting start activationEvents

Removing empty if and assuming paths have consistent casing.

Author: WardenGnaw

debugger-launchjson.md

@@ -20,9 +20,9 @@ This will create a task that runs `dotnet build`. You can read more about tasks
 ## Program
 The program field is set to the path of the application dll or .NET Core host executable to launch.
 
-This property normally takes the form: "${workspaceRoot}/bin/Debug/\<target-framework\>/\<project-name.dll\>".
+This property normally takes the form: "${workspaceFolder}/bin/Debug/\<target-framework\>/\<project-name.dll\>".
 
-Example: `"${workspaceRoot}/bin/Debug/netcoreapp1.1/MyProject.dll"`
+Example: `"${workspaceFolder}/bin/Debug/netcoreapp1.1/MyProject.dll"`
 
 Where:
 
@@ -102,7 +102,7 @@ then add the pipeTransport field folloing this schema:
         "pipeProgram": "ssh",
         "pipeArgs": [ "-T", "ExampleAccount@ExampleTargetComputer" ],
         "debuggerPath": "~/vsdbg/vsdbg",
-        "pipeCwd": "${workspaceRoot}",
+        "pipeCwd": "${workspaceFolder}",
         "quoteArgs": true
     }
 

debugger.md

@@ -66,7 +66,7 @@ If your code has multiple projects or you would rather generate these files by h
 	"configurations": [
 		{
 			...
-			"program": "${workspaceRoot}/MyLaunchingProject/bin/Debug/netcoreapp1.0/MyLaunchingProject.dll",
+			"program": "${workspaceFolder}/MyLaunchingProject/bin/Debug/netcoreapp1.0/MyLaunchingProject.dll",
 
 ##### 4: Start debugging
 Your project is now all set. Set a breakpoint or two where you want to stop, click the debugger play button (or press <kbd>F5</kbd>) and you are off.

package.json

@@ -46,7 +46,7 @@ export class AssetGenerator {
 
         // First, we'll check for .NET Core .csproj projects.
         if (workspaceInfo.MsBuild && workspaceInfo.MsBuild.Projects) {
-            const executableMSBuildProjects = findExecutableMSBuildProjects(workspaceInfo.MsBuild.Projects);
+            const executableMSBuildProjects = protocol.findExecutableMSBuildProjects(workspaceInfo.MsBuild.Projects);
 
             const targetMSBuildProject = executableMSBuildProjects.length > 0
                 ? executableMSBuildProjects[0]
@@ -64,7 +64,7 @@ export class AssetGenerator {
         }
 
         // Next, we'll try looking for project.json projects.
-        const executableProjects = findExecutableProjectJsonProjects(workspaceInfo.DotNet.Projects, configurationName);
+        const executableProjects = protocol.findExecutableProjectJsonProjects(workspaceInfo.DotNet.Projects, configurationName);
 
         // TODO: We arbitrarily pick the first executable project that we find. This will need
         // revisiting when we project a "start up project" selector.
@@ -126,10 +126,10 @@ export class AssetGenerator {
     private computeProgramPath() {
         if (!this.hasProject) {
             // If there's no target project data, use a placeholder for the path.
-            return '${workspaceRoot}/bin/Debug/<insert-target-framework-here>/<insert-project-name-here>.dll';
+            return '${workspaceFolder}/bin/Debug/<insert-target-framework-here>/<insert-project-name-here>.dll';
         }
 
-        let result = '${workspaceRoot}';
+        let result = '${workspaceFolder}';
 
         if (this.projectPath) {
             result = path.join(result, path.relative(this.rootPath, this.projectPath));
@@ -143,10 +143,10 @@ export class AssetGenerator {
     private computeWorkingDirectory() : string {
         if (!this.hasProject) {
             // If there's no target project data, use a placeholder for the path.
-            return '${workspaceRoot}';
+            return '${workspaceFolder}';
         }
 
-        let result = '${workspaceRoot}';
+        let result = '${workspaceFolder}';
 
         if (this.projectPath) {
             result = path.join(result, path.relative(this.rootPath, this.projectPath));
@@ -155,84 +155,19 @@ export class AssetGenerator {
         return result;
     }
 
-    private createLaunchConfiguration(): string{
-        return `
-{
-    "name": ".NET Core Launch (console)",
-    "type": "coreclr",
-    "request": "launch",
-    "preLaunchTask": "build",
-    // If you have changed target frameworks, make sure to update the program path.
-    "program": "${util.convertNativePathToPosix(this.computeProgramPath())}",
-    "args": [],
-    "cwd": "${util.convertNativePathToPosix(this.computeWorkingDirectory())}",
-    // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
-    "console": "internalConsole",
-    "stopAtEntry": false,
-    "internalConsoleOptions": "openOnSessionStart"
-}`;
-    }
-
-    private createWebLaunchConfiguration(): string {
-        return `
-{
-    "name": ".NET Core Launch (web)",
-    "type": "coreclr",
-    "request": "launch",
-    "preLaunchTask": "build",
-    // If you have changed target frameworks, make sure to update the program path.
-    "program": "${util.convertNativePathToPosix(this.computeProgramPath())}",
-    "args": [],
-    "cwd": "${util.convertNativePathToPosix(this.computeWorkingDirectory())}",
-    "stopAtEntry": false,
-    "internalConsoleOptions": "openOnSessionStart",
-    "launchBrowser": {
-        "enabled": true,
-        "args": "\${auto-detect-url}",
-        "windows": {
-            "command": "cmd.exe",
-            "args": "/C start \${auto-detect-url}"
-        },
-        "osx": {
-            "command": "open"
-        },
-        "linux": {
-            "command": "xdg-open"
-        }
-    },
-    "env": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-    },
-    "sourceFileMap": {
-        "/Views": "\${workspaceRoot}/Views"
-    }
-}`;
-    }
-
-    // AttachConfiguration
-    private createAttachConfiguration(): string {
-        return `
-{
-    "name": ".NET Core Attach",
-    "type": "coreclr",
-    "request": "attach",
-    "processId": "\${command:pickProcess}"
-}`;
-    }
-
     public createLaunchJson(isWebProject: boolean): string {
         if (!isWebProject) {
-            const launchConfigurationsMassaged: string = indentJsonString(this.createLaunchConfiguration());
-            const attachConfigurationsMassaged: string = indentJsonString(this.createAttachConfiguration());
+            const launchConfigurationsMassaged: string = indentJsonString(createLaunchConfiguration(this.computeProgramPath(), this.computeWorkingDirectory()));
+            const attachConfigurationsMassaged: string = indentJsonString(createAttachConfiguration());
             return `
 [
     ${launchConfigurationsMassaged},
     ${attachConfigurationsMassaged}
 ]`;
         }
         else {
-            const webLaunchConfigurationsMassaged: string = indentJsonString(this.createWebLaunchConfiguration());
-            const attachConfigurationsMassaged: string = indentJsonString(this.createAttachConfiguration());
+            const webLaunchConfigurationsMassaged: string = indentJsonString(createWebLaunchConfiguration(this.computeProgramPath(), this.computeWorkingDirectory()));
+            const attachConfigurationsMassaged: string = indentJsonString(createAttachConfiguration());
             return `
 [
     ${webLaunchConfigurationsMassaged},
@@ -244,69 +179,91 @@ export class AssetGenerator {
     private createBuildTaskDescription(): tasks.TaskDescription {
         let buildPath = '';
         if (this.hasProject) {
-            buildPath = path.join('${workspaceRoot}', path.relative(this.rootPath, this.projectFilePath));
+            buildPath = path.join('${workspaceFolder}', path.relative(this.rootPath, this.projectFilePath));
         }
 
         return {
             taskName: 'build',
-            args: [util.convertNativePathToPosix(buildPath)],
-            isBuildCommand: true,
+            command: 'dotnet',
+            type: 'process',
+            args: ['build', util.convertNativePathToPosix(buildPath)],
             problemMatcher: '$msCompile'
         };
     }
 
     public createTasksConfiguration(): tasks.TaskConfiguration {
         return {
-            version: '0.1.0',
-            command: 'dotnet',
-            isShellCommand: true,
-            args: [],
+            version: "2.0.0",
             tasks: [this.createBuildTaskDescription()]
         };
     }
 }
 
-function findExecutableMSBuildProjects(projects: protocol.MSBuildProject[]) {
-    let result: protocol.MSBuildProject[] = [];
-
-    projects.forEach(project => {
-        if (project.IsExe && protocol.findNetCoreAppTargetFramework(project) !== undefined) {
-            result.push(project);
+export function createWebLaunchConfiguration(programPath: string, workingDirectory: string): string {
+    return `
+{
+    "name": ".NET Core Launch (web)",
+    "type": "coreclr",
+    "request": "launch",
+    "preLaunchTask": "build",
+    // If you have changed target frameworks, make sure to update the program path.
+    "program": "${util.convertNativePathToPosix(programPath)}",
+    "args": [],
+    "cwd": "${util.convertNativePathToPosix(workingDirectory)}",
+    "stopAtEntry": false,
+    "internalConsoleOptions": "openOnSessionStart",
+    "launchBrowser": {
+        "enabled": true,
+        "args": "\${auto-detect-url}",
+        "windows": {
+            "command": "cmd.exe",
+            "args": "/C start \${auto-detect-url}"
+        },
+        "osx": {
+            "command": "open"
+        },
+        "linux": {
+            "command": "xdg-open"
         }
-    });
-
-    return result;
+    },
+    "env": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+    },
+    "sourceFileMap": {
+        "/Views": "\${workspaceFolder}/Views"
+    }
+}`;
 }
 
-function findExecutableProjectJsonProjects(projects: protocol.DotNetProject[], configurationName: string) {
-    let result: protocol.DotNetProject[] = [];
-
-    projects.forEach(project => {
-        project.Configurations.forEach(configuration => {
-            if (configuration.Name === configurationName && configuration.EmitEntryPoint === true) {
-                if (project.Frameworks.length > 0) {
-                    result.push(project);
-                }
-            }
-        });
-    });
-
-    return result;
+ export function createLaunchConfiguration(programPath: string, workingDirectory: string): string {
+    return `
+{
+    "name": ".NET Core Launch (console)",
+    "type": "coreclr",
+    "request": "launch",
+    "preLaunchTask": "build",
+    // If you have changed target frameworks, make sure to update the program path.
+    "program": "${util.convertNativePathToPosix(programPath)}",
+    "args": [],
+    "cwd": "${util.convertNativePathToPosix(workingDirectory)}",
+    // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
+    "console": "internalConsole",
+    "stopAtEntry": false,
+    "internalConsoleOptions": "openOnSessionStart"
+}`;
 }
 
-function containsDotNetCoreProjects(workspaceInfo: protocol.WorkspaceInformationResponse) {
-    if (workspaceInfo.DotNet && findExecutableProjectJsonProjects(workspaceInfo.DotNet.Projects, 'Debug').length > 0) {
-        return true;
-    }
-
-    if (workspaceInfo.MsBuild && findExecutableMSBuildProjects(workspaceInfo.MsBuild.Projects).length > 0) {
-        return true;
-    }
-
-    return false;
+// AttachConfiguration
+export function createAttachConfiguration(): string {
+    return `
+{
+    "name": ".NET Core Attach",
+    "type": "coreclr",
+    "request": "attach",
+    "processId": "\${command:pickProcess}"
+}`;
 }
 
-
 interface Operations {
     addTasksJson?: boolean;
     updateTasksJson?: boolean;
@@ -322,30 +279,44 @@ function getOperations(generator: AssetGenerator) {
         getLaunchOperations(generator.launchJsonPath, operations));
 }
 
+/**
+ * Will return old (version=0.1.0) or new (version=2.0.0) tasks. If there are any of them, do not 
+ * write over the tasks.json.
+ */
 function getBuildTasks(tasksConfiguration: tasks.TaskConfiguration): tasks.TaskDescription[] {
     let result: tasks.TaskDescription[] = [];
 
-    function findBuildTask(tasksDescriptions: tasks.TaskDescription[]) {
-        if (tasksDescriptions) {
-            const buildTask = tasksDescriptions.find(td => td.isBuildCommand);
-            if (buildTask !== undefined) {
-                result.push(buildTask);
-            }
+    const tasksV1: string = "0.1.0";
+    const tasksV2: string = "2.0.0";
+
+    function findBuildTask(version: string, tasksDescriptions: tasks.TaskDescription[]) {
+        let buildTask = undefined;
+        // Find the old tasks
+        if (version === tasksV1 && tasksDescriptions) {
+            buildTask = tasksDescriptions.find(td => td.isBuildCommand);
+        }
+        // Find the new tasks
+        else if (version === tasksV2 && tasksDescriptions) {
+            buildTask = tasksDescriptions.find(td => td.group === 'build');
+        }
+
+        if (buildTask !== undefined) {
+            result.push(buildTask);
         }
     }
 
-    findBuildTask(tasksConfiguration.tasks);
+    findBuildTask(tasksConfiguration.version, tasksConfiguration.tasks);
 
     if (tasksConfiguration.windows) {
-        findBuildTask(tasksConfiguration.windows.tasks);
+        findBuildTask(tasksConfiguration.version, tasksConfiguration.windows.tasks);
     }
 
     if (tasksConfiguration.osx) {
-        findBuildTask(tasksConfiguration.osx.tasks);
+        findBuildTask(tasksConfiguration.version, tasksConfiguration.osx.tasks);
     }
 
     if (tasksConfiguration.linux) {
-        findBuildTask(tasksConfiguration.linux.tasks);
+        findBuildTask(tasksConfiguration.version, tasksConfiguration.linux.tasks);
     }
 
     return result;
@@ -421,7 +392,7 @@ function promptToAddAssets() {
     });
 }
 
-function addTasksJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
+export function addTasksJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
     return new Promise<void>((resolve, reject) => {
         if (!operations.addTasksJson) {
             return resolve();
@@ -498,7 +469,7 @@ export function addAssetsIfNecessary(server: OmniSharpServer): Promise<AddAssetR
 
         serverUtils.requestWorkspaceInformation(server).then(info => {
             // If there are no .NET Core projects, we won't bother offering to add assets.
-            if (containsDotNetCoreProjects(info)) {
+            if (protocol.containsDotNetCoreProjects(info)) {
                 const generator = new AssetGenerator(info);
                 return getOperations(generator).then(operations => {
                     if (!hasAddOperations(operations)) {
@@ -577,7 +548,7 @@ function shouldGenerateAssets(generator: AssetGenerator) {
 
 export function generateAssets(server: OmniSharpServer) {
     serverUtils.requestWorkspaceInformation(server).then(info => {
-        if (containsDotNetCoreProjects(info)) {
+        if (protocol.containsDotNetCoreProjects(info)) {
             const generator = new AssetGenerator(info);
             getOperations(generator).then(operations => {
                 if (hasAddOperations(operations)) {

src/assets.ts

@@ -167,4 +167,20 @@ export function deleteInstallFile(type: InstallFileType): Promise<void> {
 export function convertNativePathToPosix(pathString: string): string {
     let parts = pathString.split(path.sep);
     return parts.join(path.posix.sep);
+}
+
+/**
+ * This function checks to see if a subfolder is part of folder.
+ * 
+ * Assumes subfolder and folder are absolute paths and have consistent casing.
+ * 
+ * @param subfolder subfolder to check if it is part of the folder parameter
+ * @param folder folder to check aganist
+ */
+export function isSubfolderOf(subfolder: string, folder: string): boolean {
+    const subfolderArray: string[] = subfolder.split(path.sep);
+    const folderArray: string[] = folder.split(path.sep);
+
+    // Check to see that every sub directory in subfolder exists in folder.
+    return subfolderArray.length <= folderArray.length && subfolderArray.every((subpath, index) => folderArray[index] === subpath);
 }