Get asset generation working

DustinCampbell · DustinCampbell · commit fc160793f2a5 · 2016-12-20T17:36:00.000-08:00
diff --git a/src/assets.ts b/src/assets.ts
@@ -59,7 +59,7 @@ export class AssetGenerator {
 
     private hasProject: boolean;
     private projectPath: string;
-    private projectJsonPath: string;
+    private projectFilePath: string;
     private targetFramework: string;
     private executableName: string;
     private configurationName: string;
@@ -82,9 +82,29 @@ export class AssetGenerator {
         // this when we allow selecting configurations.
         const configurationName = 'Debug';
 
-        const executableProjects = this.findExecutableProjects(workspaceInfo.DotNet.Projects, configurationName);
+        // First, we'll check for .NET Core .csproj projects.
+        if (workspaceInfo.MsBuild && workspaceInfo.MsBuild.Projects) {
+            const executableMSBuildProjects = findExecutableMSBuildProjects(workspaceInfo.MsBuild.Projects);
 
-        // TODO: We arbitrarily pick the first executable projec that we find. This will need
+            const targetMSBuildProject = executableMSBuildProjects.length > 0
+                ? executableMSBuildProjects[0]
+                : undefined;
+
+            if (targetMSBuildProject) {
+                this.hasProject = true;
+                this.projectPath = path.dirname(targetMSBuildProject.Path);
+                this.projectFilePath = targetMSBuildProject.Path;
+                this.targetFramework = findNetCoreAppTargetFramework(targetMSBuildProject).ShortName;
+                this.executableName = targetMSBuildProject.AssemblyName + ".dll";
+                this.configurationName = configurationName;
+                return;
+            }
+        }
+
+        // Next, we'll try looking for project.json projects.
+        const executableProjects = 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.
         const targetProject = executableProjects.length > 0
             ? executableProjects[0]
@@ -95,7 +115,7 @@ export class AssetGenerator {
             if (config) {
                 this.hasProject = true;
                 this.projectPath = targetProject.Path;
-                this.projectJsonPath = path.join(targetProject.Path, 'project.json');
+                this.projectFilePath = path.join(targetProject.Path, 'project.json');
                 this.targetFramework = targetProject.Frameworks[0].ShortName;
                 this.executableName = path.basename(config.CompilationOutputAssemblyFile);
                 this.configurationName = configurationName;
@@ -105,28 +125,14 @@ export class AssetGenerator {
         return undefined;
     }
 
-    private findExecutableProjects(projects: protocol.DotNetProject[], configName: string) {
-        let result: protocol.DotNetProject[] = [];
-
-        projects.forEach(project => {
-            project.Configurations.forEach(configuration => {
-                if (configuration.Name === configName && configuration.EmitEntryPoint === true) {
-                    if (project.Frameworks.length > 0) {
-                        result.push(project);
-                    }
-                }
-            });
-        });
-
-        return result;
-    }
-
     public hasWebServerDependency(): boolean {
-        if (!this.projectJsonPath) {
+        // TODO: Update to handle .NET Core projects.
+
+        if (!this.projectFilePath || path.extname(this.projectFilePath) !== 'json') {
             return false;
         }
 
-        let projectJson = fs.readFileSync(this.projectJsonPath, 'utf8');
+        let projectJson = fs.readFileSync(this.projectFilePath, 'utf8');
         projectJson = projectJson.replace(/^\uFEFF/, '');
 
         let projectJsonObject: any;
@@ -253,7 +259,7 @@ export class AssetGenerator {
     private createBuildTaskDescription(): tasks.TaskDescription {
         let buildPath = '';
         if (this.hasProject) {
-            buildPath = path.join('${workspaceRoot}', path.relative(this.rootPath, this.projectJsonPath));
+            buildPath = path.join('${workspaceRoot}', path.relative(this.rootPath, this.projectFilePath));
         }
 
         return {
@@ -275,6 +281,49 @@ export class AssetGenerator {
     }
 }
 
+function findNetCoreAppTargetFramework(project: protocol.MSBuildProject) {
+    return project.TargetFrameworks.find(tf => tf.ShortName.startsWith('netcoreapp'));
+}
+
+function findExecutableMSBuildProjects(projects: protocol.MSBuildProject[]) {
+    let result: protocol.MSBuildProject[] = [];
+
+    projects.forEach(project => {
+        if (project.IsExe && findNetCoreAppTargetFramework(project) !== undefined) {
+            result.push(project);
+        }
+    });
+
+    return result;
+}
+
+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;
+}
+
+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;
+    }
+}
+
+
 interface Operations {
     addTasksJson?: boolean;
     updateTasksJson?: boolean;
@@ -416,7 +465,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 (info.DotNet && info.DotNet.Projects.length > 0) {
+            if (containsDotNetCoreProjects(info)) {
                 const generator = new AssetGenerator(info);
                 return getOperations(generator).then(operations => {
                     if (!hasOperations(operations)) {
@@ -512,7 +561,7 @@ function shouldGenerateAssets(generator: AssetGenerator) {
 
 export function generateAssets(server: OmniSharpServer) {
     serverUtils.requestWorkspaceInformation(server).then(info => {
-        if (info.DotNet && info.DotNet.Projects.length > 0) {
+        if (containsDotNetCoreProjects(info)) {
             const generator = new AssetGenerator(info);
             getOperations(generator).then(operations => {
                 if (hasOperations(operations)) {
diff --git a/src/features/status.ts b/src/features/status.ts
@@ -111,7 +111,10 @@ export function reportDocumentStatus(server: OmniSharpServer): vscode.Disposable
         projectStatus = undefined;
         defaultStatus.text = undefined;
 
-        vscode.Disposable.from(...localDisposables).dispose();
+        if (localDisposables) {
+            vscode.Disposable.from(...localDisposables).dispose();
+        }
+        
         localDisposables = undefined;
     }));
 
diff --git a/src/omnisharp/protocol.ts b/src/omnisharp/protocol.ts
@@ -294,6 +294,16 @@ export interface MSBuildProject {
     TargetPath: string;
     TargetFramework: string;
     SourceFiles: string[];
+    TargetFrameworks: TargetFramework[];
+    OutputPath: string;
+    IsExe: boolean;
+    IsUnityProject: boolean;
+}
+
+export interface TargetFramework {
+    Name: string;
+    FriendlyName: string;
+    ShortName: string;
 }
 
 export interface DotNetWorkspaceInformation {
diff --git a/test/assets.test.ts b/test/assets.test.ts
@@ -8,7 +8,7 @@ import * as path from 'path';
 import * as protocol from '../src/omnisharp/protocol';
 import { AssetGenerator } from '../src/assets';
 
-suite("Asset generation", () => {
+suite("Asset generation: project.json", () => {
     suiteSetup(() => should());
 
     test("Create tasks.json for project opened in workspace", () => {
@@ -115,3 +115,111 @@ function createDotNetWorkspaceInformation(projectPath: string, compilationOutput
         }
     };
 }
+
+suite("Asset generation: csproj", () => {
+    suiteSetup(() => should());
+
+    test("Create tasks.json for project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(rootPath, 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let tasksJson = generator.createTasksConfiguration();
+        let buildPath = tasksJson.tasks[0].args[0];
+
+        // ${workspaceRoot}/project.json
+        let segments = buildPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'project.json']);
+    });
+
+    test("Create tasks.json for nested project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(path.join(rootPath, 'nested'), 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let tasksJson = generator.createTasksConfiguration();
+        let buildPath = tasksJson.tasks[0].args[0];
+
+        // ${workspaceRoot}/nested/project.json
+        let segments = buildPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'nested', 'project.json']);
+    });
+
+    test("Create launch.json for project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(rootPath, 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let launchJson = generator.createLaunchJson(/*isWebProject*/ false);
+        let programPath = launchJson.configurations[0].program;
+
+        // ${workspaceRoot}/bin/Debug/netcoreapp1.0/testApp.dll
+        let segments = programPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'bin', 'Debug', 'netcoreapp1.0', 'testApp.dll']);
+    });
+
+    test("Create launch.json for nested project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(path.join(rootPath, 'nested'), 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let launchJson = generator.createLaunchJson(/*isWebProject*/ false);
+        let programPath = launchJson.configurations[0].program;
+
+        // ${workspaceRoot}/nested/bin/Debug/netcoreapp1.0/testApp.dll
+        let segments = programPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'nested', 'bin', 'Debug', 'netcoreapp1.0', 'testApp.dll']);
+    });
+
+    test("Create launch.json for web project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(rootPath, 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let launchJson = generator.createLaunchJson(/*isWebProject*/ true);
+        let programPath = launchJson.configurations[0].program;
+
+        // ${workspaceRoot}/bin/Debug/netcoreapp1.0/testApp.dll
+        let segments = programPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'bin', 'Debug', 'netcoreapp1.0', 'testApp.dll']);
+    });
+
+    test("Create launch.json for nested web project opened in workspace", () => {
+        let rootPath = path.resolve('testRoot');
+        let info = createMSBuildWorkspaceInformation(path.join(rootPath, 'nested'), 'testApp.dll', 'netcoreapp1.0');
+        let generator = new AssetGenerator(info, rootPath);
+        let launchJson = generator.createLaunchJson(/*isWebProject*/ true);
+        let programPath = launchJson.configurations[0].program;
+
+        // ${workspaceRoot}/nested/bin/Debug/netcoreapp1.0/testApp.dll
+        let segments = programPath.split(path.sep);
+        segments.should.deep.equal(['${workspaceRoot}', 'nested', 'bin', 'Debug', 'netcoreapp1.0', 'testApp.dll']);
+    });
+});
+
+function createMSBuildWorkspaceInformation(projectPath: string, compilationOutputAssemblyFile: string, targetFrameworkShortName: string, emitEntryPoint: boolean = true) : protocol.WorkspaceInformationResponse {
+    return {
+        DotNet: {
+            Projects: [
+                {
+                    Path: projectPath,
+                    Name: '',
+                    ProjectSearchPaths: [],
+                    Configurations: [
+                        {
+                            Name: 'Debug',
+                            CompilationOutputPath: '',
+                            CompilationOutputAssemblyFile: compilationOutputAssemblyFile,
+                            CompilationOutputPdbFile: '',
+                            EmitEntryPoint: emitEntryPoint
+                        }
+                    ],
+                    Frameworks: [
+                        {
+                            Name: '',
+                            FriendlyName: '',
+                            ShortName: targetFrameworkShortName
+                        }
+                    ],
+                    SourceFiles: []
+                }
+            ],
+            RuntimePath: ''
+        }
+    };
+}
