public void GetTargetFramework_NoTFM_ReturnsTargetFrameworkVersion() { // Arrange const string targetFramework = "v4.6.1"; var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty(ProjectLoadListener.TargetFrameworkVersion, targetFramework); // Act var tfm = ProjectLoadListener.GetTargetFrameworks(projectInstance); // Assert Assert.Equal(targetFramework, tfm.First()); }
public void TryGetConfiguration_FailsIfNoLanguageVersion() { // Arrange var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty("RazorDefaultConfiguration", "Razor-13.37"); // Act var result = LatestProjectConfigurationProvider.TryGetConfiguration(projectInstance, out var configuration); // Assert Assert.False(result); Assert.Null(configuration); }
public void GetRootNamespace_ReturnsRootNamespace() { // Arrange var expectedRootNamespace = "SomeApp.Root.Namespace"; var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty(LatestProjectConfigurationProvider.RootNamespaceProperty, expectedRootNamespace); // Act var rootNamespace = LatestProjectConfigurationProvider.GetRootNamespace(projectInstance); // Assert Assert.Equal(expectedRootNamespace, rootNamespace); }
public void TryGetLanguageVersion_SucceedsWithUnknownLanguageVersion_DefaultsToLatest() { // Arrange var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty("RazorLangVersion", "13.37"); // Act var result = LatestProjectConfigurationProvider.TryGetLanguageVersion(projectInstance, out var languageVersion); // Assert Assert.True(result); Assert.Same(RazorLanguageVersion.Latest, languageVersion); }
public void TryGetLanguageVersion_FailsIfEmptyLanguageVersion() { // Arrange var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty("RazorLangVersion", string.Empty); // Act var result = LatestProjectConfigurationProvider.TryGetLanguageVersion(projectInstance, out var languageVersion); // Assert Assert.False(result); Assert.Null(languageVersion); }
public void TryGetDefaultConfiguration_SucceedsWithValidConfiguration() { // Arrange var expectedConfiguration = "Razor-13.37"; var projectInstance = new ProjectInstance(ProjectRootElement.Create()); projectInstance.SetProperty("RazorDefaultConfiguration", expectedConfiguration); // Act var result = LatestProjectConfigurationProvider.TryGetDefaultConfiguration(projectInstance, out var defaultConfiguration); // Assert Assert.True(result); Assert.Equal(expectedConfiguration, defaultConfiguration); }
public bool BuildProject(ProjectInstance instance, string [] targetNames, IDictionary globalProperties) { if (globalProperties != null) { foreach (DictionaryEntry de in globalProperties) { //Note: trying to set this on the project causes the project to be added to the PC // again, which of course, fails instance.SetProperty((string)de.Key, (string)de.Value); } } //FIXME: assumption that we are still using the same PC! return(instance.Build(targetNames, ProjectCollection.Loggers)); }
private IEnumerable <string> ResolveAssemblyReferences(Project project) { // Use MSBuild to figure out the full path of the referenced assemblies ProjectInstance projectInstance = project.CreateProjectInstance(); projectInstance.SetProperty("BuildingProject", "false"); project.SetProperty("DesignTimeBuild", "true"); projectInstance.Build("ResolveAssemblyReferences", new[] { new ConsoleLogger(LoggerVerbosity.Minimal) }); ICollection <ProjectItemInstance> items = projectInstance.GetItems("_ResolveAssemblyReferenceResolvedFiles"); string baseDirectory = Path.GetDirectoryName(_projectLocation); // ReSharper disable once AssignNullToNotNullAttribute return(items.Select(i => Path.Combine(baseDirectory, i.GetMetadataValue("Identity")))); }
// FIXME: Exception should be caught at caller site. bool DoBuildTarget(ProjectTargetInstance target, TargetResult targetResult, InternalBuildArguments args) { var request = submission.BuildRequest; // Here we check cancellation (only after TargetStarted event). if (args.CheckCancel()) { targetResult.Failure(new BuildAbortedException("Build has canceled")); return(false); } try { foreach (var child in target.Children) { // Evaluate additional target properties var tp = child as ProjectPropertyGroupTaskInstance; if (tp != null) { if (!args.Project.EvaluateCondition(tp.Condition)) { continue; } foreach (var p in tp.Properties) { if (!args.Project.EvaluateCondition(p.Condition)) { continue; } var value = args.Project.ExpandString(p.Value); project.SetProperty(p.Name, value); } continue; } var ii = child as ProjectItemGroupTaskInstance; if (ii != null) { if (!args.Project.EvaluateCondition(ii.Condition)) { continue; } foreach (var item in ii.Items) { if (!args.Project.EvaluateCondition(item.Condition)) { continue; } project.AddItem(item.ItemType, project.ExpandString(item.Include)); } continue; } var task = child as ProjectTaskInstance; if (task != null) { current_task = task; if (!args.Project.EvaluateCondition(task.Condition)) { LogMessageEvent(new BuildMessageEventArgs(string.Format("Task '{0}' was skipped because condition '{1}' wasn't met.", task.Name, task.Condition), null, null, MessageImportance.Low)); continue; } if (!RunBuildTask(target, task, targetResult, args)) { return(false); } continue; } var onError = child as ProjectOnErrorInstance; if (onError != null) { continue; // evaluated under catch clause. } throw new NotSupportedException(string.Format("Unexpected Target element children \"{0}\"", child.GetType())); } } catch (Exception ex) { // fallback task specified by OnError element foreach (var c in target.Children.OfType <ProjectOnErrorInstance> ()) { if (!args.Project.EvaluateCondition(c.Condition)) { continue; } foreach (var fallbackTarget in project.ExpandString(c.ExecuteTargets).Split(';')) { BuildTargetByName(fallbackTarget, args); } } int line = target.Location != null ? target.Location.Line : 0; int col = target.Location != null ? target.Location.Column : 0; LogErrorEvent(new BuildErrorEventArgs(null, null, target.FullPath, line, col, 0, 0, ex.Message, null, null)); targetResult.Failure(ex); return(false); } return(true); }
/// <summary> /// Resolves the location of the reference files. /// </summary> /// <param name="baseProject">The base project.</param> /// <param name="referenceReplacements">A different set of references to use instead of those in the project. /// Used by the GacReferencePanel.</param> public static IList <ReferenceProjectItem> ResolveAssemblyReferences( MSBuildBasedProject baseProject, ReferenceProjectItem[] additionalReferences = null, bool resolveOnlyAdditionalReferences = false, bool logErrorsToOutputPad = true) { ProjectInstance project = baseProject.CreateProjectInstance(); project.SetProperty("BuildingProject", "false"); project.SetProperty("DesignTimeBuild", "true"); List <ProjectItemInstance> references = ( from item in project.Items where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType)) select item ).ToList(); List <ReferenceProjectItem> referenceProjectItems; if (resolveOnlyAdditionalReferences) { // Remove existing references from project foreach (ProjectItemInstance reference in references) { project.RemoveItem(reference); } references.Clear(); referenceProjectItems = new List <ReferenceProjectItem>(); } else { // Remove the "Private" meta data. // This is necessary to detect the default value for "Private" foreach (ProjectItemInstance reference in references) { reference.RemoveMetadata("Private"); } referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToList(); } if (additionalReferences != null) { referenceProjectItems.AddRange(additionalReferences); foreach (ReferenceProjectItem item in additionalReferences) { references.Add(project.AddItem("Reference", item.Include)); } } List <string> targets = new List <string>(); if (baseProject.HasProjectType(ProjectTypeGuids.PortableLibrary)) { targets.Add("ResolveReferences"); targets.Add("DesignTimeResolveAssemblyReferences"); } else { targets.Add("ResolveAssemblyReferences"); } BuildRequestData requestData = new BuildRequestData(project, targets.ToArray(), new HostServices()); List <ILogger> loggers = new List <ILogger>(); //loggers.Add(new ConsoleLogger(LoggerVerbosity.Diagnostic)); if (logErrorsToOutputPad) { loggers.Add(new SimpleErrorLogger()); } lock (SolutionProjectCollectionLock) { BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection); parameters.Loggers = loggers; LoggingService.Debug("Started build for ResolveAssemblyReferences"); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData); if (result == null) { throw new InvalidOperationException("BuildResult is null"); } LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult); } IEnumerable <ProjectItemInstance> resolvedAssemblyProjectItems = project.GetItems("_ResolveAssemblyReferenceResolvedFiles"); var query = from msbuildItem in resolvedAssemblyProjectItems let originalInclude = msbuildItem.GetMetadataValue("OriginalItemSpec") join item in referenceProjectItems.Where(p => p.ItemType != ItemType.ProjectReference) on originalInclude equals item.Include into referenceItems select new { OriginalInclude = originalInclude, AssemblyName = new DomAssemblyName(msbuildItem.GetMetadataValue("FusionName")), FullPath = FileUtility.GetAbsolutePath(baseProject.Directory, msbuildItem.GetMetadataValue("Identity")), Redist = msbuildItem.GetMetadataValue("Redist"), CopyLocal = bool.Parse(msbuildItem.GetMetadataValue("CopyLocal")), ReferenceItems = referenceItems }; // HACK: mscorlib is reported twice for portable library projects (even if we don't specify it as additionalReference) query = query.DistinctBy(asm => asm.FullPath); List <ReferenceProjectItem> resolvedAssemblies = new List <ReferenceProjectItem>(); List <ReferenceProjectItem> handledReferenceItems = new List <ReferenceProjectItem>(); foreach (var assembly in query) { LoggingService.Debug("Got information about " + assembly.OriginalInclude + "; fullpath=" + assembly.FullPath); foreach (var referenceItem in assembly.ReferenceItems) { referenceItem.AssemblyName = assembly.AssemblyName; referenceItem.FileName = assembly.FullPath; referenceItem.Redist = assembly.Redist; referenceItem.DefaultCopyLocalValue = assembly.CopyLocal; handledReferenceItems.Add(referenceItem); } ReferenceProjectItem firstItem = assembly.ReferenceItems.FirstOrDefault(); if (firstItem != null) { resolvedAssemblies.Add(firstItem); } else { resolvedAssemblies.Add(new ReferenceProjectItem(baseProject, assembly.OriginalInclude) { FileName = assembly.FullPath }); } } // Add any assemblies that weren't resolved yet. This is important - for example, this adds back project references. foreach (var referenceItem in referenceProjectItems.Except(handledReferenceItems)) { resolvedAssemblies.Add(referenceItem); } return(resolvedAssemblies); }
/// <summary> /// Resolves the location of the reference files. /// </summary> /// <param name="baseProject">The base project.</param> /// <param name="referenceReplacements">A different set of references to use instead of those in the project. /// Used by the GacReferencePanel.</param> internal static void ResolveAssemblyReferences(MSBuildBasedProject baseProject, ReferenceProjectItem[] referenceReplacements) { ProjectInstance project = baseProject.CreateProjectInstance(); project.SetProperty("BuildingProject", "false"); List <ProjectItemInstance> references = ( from item in project.Items where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType)) select item ).ToList(); ReferenceProjectItem[] referenceProjectItems; if (referenceReplacements == null) { // Remove the "Private" meta data. // This is necessary to detect the default value for "Private" foreach (ProjectItemInstance reference in references) { reference.RemoveMetadata("Private"); } referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToArray(); } else { foreach (ProjectItemInstance reference in references) { project.RemoveItem(reference); } foreach (ReferenceProjectItem item in referenceReplacements) { project.AddItem("Reference", item.Include); } referenceProjectItems = referenceReplacements; } string[] targets = { "ResolveAssemblyReferences" }; BuildRequestData requestData = new BuildRequestData(project, targets, new HostServices()); List <ILogger> loggers = new List <ILogger>(); if (referenceReplacements == null) { loggers.Add(new SimpleErrorLogger()); } lock (SolutionProjectCollectionLock) { BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection); parameters.Loggers = loggers; LoggingService.Debug("Started build for ResolveAssemblyReferences"); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData); if (result == null) { throw new InvalidOperationException("BuildResult is null"); } LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult); } var referenceDict = new Dictionary <string, ReferenceProjectItem>(); foreach (ReferenceProjectItem item in referenceProjectItems) { // references could be duplicate, so we cannot use referenceDict.Add or reference.ToDictionary referenceDict[item.Include] = item; } foreach (ProjectItemInstance item in project.GetItems("_ResolveAssemblyReferenceResolvedFiles")) { string originalInclude = item.GetMetadataValue("OriginalItemSpec"); ReferenceProjectItem reference; if (referenceDict.TryGetValue(originalInclude, out reference)) { reference.AssemblyName = new Dom.DomAssemblyName(item.GetMetadataValue("FusionName")); //string fullPath = item.GetEvaluatedMetadata("FullPath"); is incorrect for relative paths string fullPath = FileUtility.GetAbsolutePath(baseProject.Directory, item.GetMetadataValue("Identity")); reference.FileName = fullPath; reference.Redist = item.GetMetadataValue("Redist"); LoggingService.Debug("Got information about " + originalInclude + "; fullpath=" + fullPath); reference.DefaultCopyLocalValue = bool.Parse(item.GetMetadataValue("CopyLocal")); } else { LoggingService.Warn("Unknown item " + originalInclude); } } }
/// <summary> /// Called before the first project configuration is about to be built. /// </summary> /// <returns> /// If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSConstants.S_OK"/>. If it fails, it returns an error code. /// </returns> /// <param name="pfCancelUpdate">[in, out] Pointer to a flag indicating cancel update.</param> int IVsUpdateSolutionEvents.UpdateSolution_StartUpdate(ref int pfCancelUpdate) { // This method is called when the entire solution starts to build. this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: UpdateSolution_StartUpdate"); string solutionFilePath = this.dte2.Solution.FullName; string solutionFolder = Path.GetDirectoryName(solutionFilePath); string solutionFileName = Path.GetFileName(solutionFilePath); string targetsFileName = "after." + solutionFileName + ".targets"; if (solutionFolder == null) { return(VSConstants.E_UNEXPECTED); } string targetsFilePath = Path.Combine(solutionFolder, targetsFileName); if (!File.Exists(targetsFilePath)) { return(VSConstants.S_OK); } string solutionConfigurationName = this.dte2.Solution.SolutionBuild.ActiveConfiguration.Name; this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: active solution configuration name is \"{0}\"", solutionConfigurationName); List <ILogger> loggers = new List <ILogger> { this.MakeBuildLogger() }; ProjectInstance solutionInitProjectInstance; try { solutionInitProjectInstance = new ProjectInstance(targetsFilePath); } catch (Exception ex) { this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: failed to load targets file \"{0}\", Exception: {1}", targetsFilePath, ex); return(VSConstants.E_FAIL); } solutionInitProjectInstance.SetProperty("Configuration", solutionConfigurationName); solutionInitProjectInstance.SetProperty("BuildingInsideVisualStudio", "true"); int numberOfPropertiesBeforeBuild = solutionInitProjectInstance.Properties.Count; var target = GetActiveBuildTarget(nameof(IVsUpdateSolutionEvents.UpdateSolution_StartUpdate)); this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: building targets file \"{0}\", target \"{1}\"", targetsFilePath, string.Join(",", target)); solutionInitProjectInstance.Build(target, loggers); // If solution targets build produced new custom properties, fetch those and add them to the global properties collection. // Most typical usage for this feature is setting "CustomAfterMicrosoftCommontargets" property. for (int propertyNumber = numberOfPropertiesBeforeBuild; propertyNumber < solutionInitProjectInstance.Properties.Count; propertyNumber++) { ProjectPropertyInstance property = solutionInitProjectInstance.Properties.ElementAt(propertyNumber); if (property.Name.StartsWith("Custom")) { this.WriteLine(LoggerVerbosity.Detailed, "CommonSolutionTargets: defined global build property {0} = {1}", property.Name, property.EvaluatedValue); ProjectCollection.GlobalProjectCollection.SetGlobalProperty(property.Name, property.EvaluatedValue); } } return(VSConstants.S_OK); }
public void TestSetFibBaseImage(string registry, string repository, string tag, string digest, string expectedFibBaseImage) { _projectInstance.SetProperty("FibBaseRegistry", registry); _projectInstance.SetProperty("FibBaseRepository", repository); _projectInstance.SetProperty("FibBaseTag", tag); _projectInstance.SetProperty("FibBaseDigest", digest); Assert.IsTrue(_projectInstance.Build("SetFibBaseImage", Loggers)); Assert.AreEqual(expectedFibBaseImage, _projectInstance.GetPropertyValue("FibBaseImage")); }