private void GenerateAndAddLegacyConfigurationPropertyGroup()
{
ProjectPropertyGroupElement group = Xml.AddPropertyGroup();
group.AddProperty("ProjectGuidString", Guid.NewGuid().ToString("B").ToUpper());
group.AddProperty("ProjectTypeGuids", VsProjectTypeGuids.LegacyProjectGuid);
}
private static ProjectInstance CreateTestProjectInstance(string fileName, bool hasProjectReferences = true, bool isEnabled = true)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create($@"ServiceFabricApp\{fileName}");
// These are generally set in Microsoft.VisualStudio.Azure.Fabric.Application.targets
ProjectPropertyGroupElement propertyGroup = projectRootElement.AddPropertyGroup();
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ApplicationPackageRootFolderPropertyName, "ApplicationPackageRoot");
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ServicePackageRootFolderPropertyName, "PackageRoot");
if (isEnabled)
{
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.UpdateServiceFabricApplicationManifestEnabledPropertyName, "true");
}
if (hasProjectReferences)
{
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service1\Service1.csproj");
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service2\Service2.csproj");
}
// Extra service manifests, and some extraneous files too
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent"); // Not in a subdir, should not get picked up
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Foo");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Bar");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\extraneous.txt", "SomeContent");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
private static void InitializeExtensibilityDebugParameters(ProjectRootElement root)
{
ProjectElement firstChild = root.FirstChild;
ProjectPropertyGroupElement group = root.CreatePropertyGroupElement();
root.InsertAfterChild(group, firstChild);
group.AddProperty("StartAction", "Program");
group.AddProperty("StartProgram", "$(DevEnvDir)\\devenv.exe");
group.AddProperty("StartArguments", "/RootSuffix Exp");
}
private static void InitializeCPSClassLibraryConfigurationProperties(
ProjectRootElement root, string assemblyName, string rootNamespace, string outputType, string targetFramework)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.Label = "Configuration";
group.AddProperty("AssemblyName", assemblyName);
group.AddProperty("RootNamespace", rootNamespace);
group.AddProperty("OutputType", outputType);
group.AddProperty("TargetFramework", targetFramework);
}
public static ProjectRootElement CreateLibraryProject(string name, string defaultConfig, out ProjectPropertyGroupElement mainGroup)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException($"{nameof(name)} cannot be empty", nameof(name));
}
var root = ProjectRootElement.Create();
root.DefaultTargets = "Build";
mainGroup = root.AddPropertyGroup();
mainGroup.AddProperty("Configuration", defaultConfig).Condition = " '$(Configuration)' == '' ";
mainGroup.AddProperty("Platform", "AnyCPU").Condition = " '$(Platform)' == '' ";
mainGroup.AddProperty("ProjectGuid", "{" + Guid.NewGuid().ToString().ToUpper() + "}");
mainGroup.AddProperty("OutputType", "Library");
mainGroup.AddProperty("OutputPath", Path.Combine("bin", "$(Configuration)"));
mainGroup.AddProperty("RootNamespace", IdentifierUtils.SanitizeQualifiedIdentifier(name, allowEmptyIdentifiers: true));
mainGroup.AddProperty("AssemblyName", name);
mainGroup.AddProperty("TargetFrameworkVersion", "v4.7");
mainGroup.AddProperty("GodotProjectGeneratorVersion", Assembly.GetExecutingAssembly().GetName().Version.ToString());
var exportDebugGroup = root.AddPropertyGroup();
exportDebugGroup.Condition = " '$(Configuration)|$(Platform)' == 'ExportDebug|AnyCPU' ";
exportDebugGroup.AddProperty("DebugSymbols", "true");
exportDebugGroup.AddProperty("DebugType", "portable");
exportDebugGroup.AddProperty("Optimize", "false");
exportDebugGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;DEBUG;");
exportDebugGroup.AddProperty("ErrorReport", "prompt");
exportDebugGroup.AddProperty("WarningLevel", "4");
exportDebugGroup.AddProperty("ConsolePause", "false");
var exportReleaseGroup = root.AddPropertyGroup();
exportReleaseGroup.Condition = " '$(Configuration)|$(Platform)' == 'ExportRelease|AnyCPU' ";
exportReleaseGroup.AddProperty("DebugType", "portable");
exportReleaseGroup.AddProperty("Optimize", "true");
exportReleaseGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;");
exportReleaseGroup.AddProperty("ErrorReport", "prompt");
exportReleaseGroup.AddProperty("WarningLevel", "4");
exportReleaseGroup.AddProperty("ConsolePause", "false");
// References
var referenceGroup = root.AddItemGroup();
referenceGroup.AddItem("Reference", "System");
var frameworkRefAssembliesItem = referenceGroup.AddItem("PackageReference", "Microsoft.NETFramework.ReferenceAssemblies");
// Use metadata (child nodes) instead of attributes for the PackageReference.
// This is for compatibility with 3.2, where GodotTools uses an old Microsoft.Build.
frameworkRefAssembliesItem.AddMetadata("Version", "1.0.0");
frameworkRefAssembliesItem.AddMetadata("PrivateAssets", "All");
root.AddImport(Path.Combine("$(MSBuildBinPath)", "Microsoft.CSharp.targets").Replace("/", "\\"));
return(root);
}
/// <summary>
/// Populate the property group with the individual options
/// </summary>
private void PopulatePropertyGroup(ProjectPropertyGroupElement configPropertyGroup)
{
string propertyName;
foreach (CompSwitchInfo compSwitchInfo in validCompilerSwitches)
{
propertyName = compSwitchInfo.SwitchProjectPropertyName;
// No need to remove the already existing property node
// since the switches we are dealing with couldnt have been
// set anywhere else in the property pages except the additional
// options
switch (compSwitchInfo.SwitchValueType)
{
case SwitchValueType.SVT_Boolean:
if (null != compSwitchInfo.SwitchValue)
{
configPropertyGroup.AddProperty(
propertyName,
compSwitchInfo.SwitchValue.ToString().ToLower(CultureInfo.InvariantCulture)
);
}
break;
case SwitchValueType.SVT_String:
if (null != compSwitchInfo.SwitchValue)
{
configPropertyGroup.AddProperty(
propertyName,
compSwitchInfo.SwitchValue.ToString()
);
}
break;
case SwitchValueType.SVT_MultiString:
Debug.Assert(null != compSwitchInfo.SwitchValue, "Expected non null value for multistring switch");
if (0 != ((StringBuilder)(compSwitchInfo.SwitchValue)).Length)
{
configPropertyGroup.AddProperty(
propertyName,
compSwitchInfo.SwitchValue.ToString()
);
}
break;
default:
Debug.Assert(false, "Unknown switch value type");
break;
}
}
}
public override void Run()
{
Log.LogMessage("Generating module build package imports");
ProjectRootElement propsProject = ProjectRootElement.Create(PropsFile);
ProjectRootElement targetsProject = ProjectRootElement.Create(TargetsFile);
ProjectPropertyGroupElement propertyGroup = propsProject.AddPropertyGroup();
foreach (BuildPackageInfo buildPackageInfo in ModulePaths.Select(BuildPackageInfo.FromModulePath).Where(i => i != null))
{
if (buildPackageInfo.PropsPath == null && buildPackageInfo.TargetsPath == null)
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is not a standard NuGet build package.");
continue;
}
// If this is a cbt module do not auto import props or targets.
if (File.Exists(Path.Combine(Path.GetDirectoryName(buildPackageInfo.PropsPath ?? buildPackageInfo.TargetsPath), "module.config")))
{
Log.LogMessage(MessageImportance.Low, $" Skipping '{buildPackageInfo.Id}' because it is a CBT Module.");
continue;
}
ProjectPropertyElement enableProperty = propertyGroup.AddProperty(buildPackageInfo.EnablePropertyName, "false");
enableProperty.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == '' ";
ProjectPropertyElement runProperty = propertyGroup.AddProperty(buildPackageInfo.RunPropertyName, "true");
runProperty.Condition = $" '$({buildPackageInfo.RunPropertyName})' == '' ";
if (File.Exists(buildPackageInfo.PropsPath))
{
ProjectImportElement import = propsProject.AddImport(buildPackageInfo.PropsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
if (File.Exists(buildPackageInfo.TargetsPath))
{
ProjectImportElement import = targetsProject.AddImport(buildPackageInfo.TargetsPath);
import.Condition = $" '$({buildPackageInfo.EnablePropertyName})' == 'true' And '$({buildPackageInfo.RunPropertyName})' == 'true' ";
}
Log.LogMessage($" Generated imports for '{buildPackageInfo.Id}'.");
}
propsProject.Save();
targetsProject.Save();
}
static ProjectPropertyGroupElement CreatePropertyGroupChoice(ProjectRootElement root,
string condition,
bool unsafeMode, string outputPath, bool optimize,
bool debugSymbol, string debugType, string constants
)
{
ProjectPropertyGroupElement group = root.AddPropertyGroup();
group.Condition = condition;
if (unsafeMode)
{
group.AddProperty("AllowUnsafeBlocks", "true");
}
group.AddProperty("ErrorReport", "prompt");
group.AddProperty("WarningLevel", "4");
group.AddProperty("OutputPath", outputPath); //,eg @"bin\Debug\"
group.AddProperty("Optimize", optimize ? "true" : "false");
group.AddProperty("DebugType", debugType);
if (debugSymbol)
{
group.AddProperty("DebugSymbols", "true");
}
group.AddProperty("DefineConstants", constants); //eg DEBUG; TRACE
return(group);
}
public Microsoft.Build.Evaluation.Project Orchestrate(string projConfFile)
{
Microsoft.Build.Evaluation.Project msbuildProj = ProjectCollection.GlobalProjectCollection.LoadProject(projConfFile);
if (msbuildProj == null)
{
msbuildProj = new Microsoft.Build.Evaluation.Project(projConfFile);
if (msbuildProj == null)
{
return(null);
}
}
ProjectRootElement projRoot = msbuildProj.Xml;
if (projRoot == null)
{
return(null);
}
string instPath = extensionServ.GetVSIXInstallPath();
bool need_save = false;
string cpTargetsFullPath = Path.GetDirectoryName(projConfFile) + "\\ChartPoints.targets";
if (!File.Exists(cpTargetsFullPath))
{
bool res = CreateFileFromResource("ChartPointsLib.Resources.ChartPoints.targets", cpTargetsFullPath);
}
IEnumerable <ProjectImportElement> importElems = projRoot.Imports.Where(ig => (ig.Project == "ChartPoints.targets"));
if (!importElems.Any())
{
projRoot.AddImport("ChartPoints.targets");
need_save = true;
}
IEnumerable <ProjectPropertyGroupElement> cpPropsGroups = projRoot.PropertyGroups.Where(ig => (ig.Label == "CPTargetsVariables"));
if (!cpPropsGroups.Any())
{
ProjectPropertyGroupElement cpPropsGroup = projRoot.AddPropertyGroup();
cpPropsGroup.Label = "CPTargetsVariables";
cpPropsGroup.AddProperty("TargetFileFullPath", instPath + "\\CPInstrBuildTask.dll");
cpPropsGroup.AddProperty("ThisProjectFullName", "$(MSBuildThisFileFullPath)");
}
if (need_save)
{
msbuildProj.Save();
}
return(msbuildProj);
}
/// <exception cref="ArgumentException">Value cannot be null or whitespace.</exception>
/// <exception cref="InvalidProjectFileException">If the evaluation fails.</exception>
public void Fix(
[NotNull] Project project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var needsNewPropertyGroup = true;
/* First, remove all properties to replace with a configuration condition */
foreach (ProjectPropertyGroupElement propertyGroupElement in
GetPropertyGroupsWithPropertyToReplace(project))
{
if (propertyGroupElement.Condition == string.Empty)
{
/* This property group already defines the property for all configurations. We only need to set it
* to the requested value. */
needsNewPropertyGroup = false;
propertyGroupElement.SetProperty(_propertyName, _propertyValue);
continue;
}
ProjectPropertyElement property =
propertyGroupElement.Properties.Single(p => p.Name == _propertyName);
propertyGroupElement.RemoveChild(property);
}
if (needsNewPropertyGroup)
{
/* Add PropertyGroup containing LangVersion for all build configurations */
ProjectPropertyGroupElement newPropertyGroup = project.Xml.AddPropertyGroup();
newPropertyGroup.AddProperty(_propertyName, _propertyValue);
}
}
private void SetPropertyUnderCondition(string propertyName, string propertyValue, string condition)
{
// New OM doesn't have a convenient equivalent for setting a property with a particular property group condition.
// So do it ourselves.
ProjectPropertyGroupElement newGroup = null;
foreach (ProjectPropertyGroupElement group in this.proj.Xml.PropertyGroups)
{
if (String.Equals(group.Condition.Trim(), condition, StringComparison.OrdinalIgnoreCase))
{
newGroup = group;
break;
}
}
if (newGroup == null)
{
newGroup = this.proj.Xml.AddPropertyGroup(); // Adds after last existing PG, else at start of project
newGroup.Condition = condition;
}
foreach (ProjectPropertyElement property in newGroup.PropertiesReversed) // If there's dupes, pick the last one so we win
{
if (String.Equals(property.Name, propertyName, StringComparison.OrdinalIgnoreCase) && property.Condition.Length == 0)
{
property.Value = propertyValue;
return;
}
}
newGroup.AddProperty(propertyName, propertyValue);
}
public static void SetProperty(Microsoft.Build.Evaluation.Project project, String label, String name, String value)
{
ProjectPropertyGroupElement group = project.Xml.PropertyGroups.FirstOrDefault(g => g.Label.Equals(label));
if (group == null)
{
//
// Create our property group after the main language targets are imported so we can use the properties
// defined in this files.
//
ProjectImportElement import = project.Xml.Imports.FirstOrDefault(
p => (p.Project.IndexOf("Microsoft.Cpp.targets") != -1 || p.Project.IndexOf("IceBuilder.CSharp.props") != -1));
if (import != null)
{
group = project.Xml.CreatePropertyGroupElement();
project.Xml.InsertAfterChild(group, import);
}
else
{
group = project.Xml.CreatePropertyGroupElement();
}
group.Label = label;
}
ProjectPropertyElement property = group.Properties.FirstOrDefault(p => p.Name.Equals(name));
if (property != null)
{
property.Value = value;
}
else
{
group.AddProperty(name, value);
}
}
public void WriteProjectInfo_AnalysisFileList_FilesTypes_SpecifiedPlusDefaults()
{
// Arrange
string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs");
string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs");
ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder, "fileTypes.proj.txt");
ProjectRootElement projectRoot = CreateInitializedProject(descriptor, new WellKnownProjectProperties(), rootOutputFolder);
// Files we don't expect to be included by default
string fooType1 = AddFileToProject(projectRoot, "fooType", sonarQubeExclude: null);
string xxxType1 = AddFileToProject(projectRoot, "xxxType", sonarQubeExclude: null);
AddFileToProject(projectRoot, "barType", sonarQubeExclude: null);
// Files we'd normally expect to be included by default
string managed1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Compile, sonarQubeExclude: null);
string content1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Content, sonarQubeExclude: null);
// Update the "item types" property to add some extra item type
// NB this has to be done *after* the integration targets have been imported
ProjectPropertyGroupElement group = projectRoot.CreatePropertyGroupElement();
projectRoot.AppendChild(group);
group.AddProperty("SQAnalysisFileItemTypes", "fooType;$(SQAnalysisFileItemTypes);xxxType");
projectRoot.Save();
// Act
ProjectInfo projectInfo = ExecuteWriteProjectInfo(projectRoot, rootOutputFolder);
// Assert
AssertResultFileExists(projectInfo, AnalysisType.FilesToAnalyze, fooType1, xxxType1, content1, managed1);
}
/// <summary>
/// Adds a property element to the current <PropertyGroup />. A property group is automatically added if necessary. if <paramref name="unevaluatedValue"/> is <code>null</code>, the property is not added.
/// </summary>
/// <param name="propertyGroup">The <see cref="ProjectPropertyGroupElement"/> to add the property to.</param>
/// <param name="name">The name of the property.</param>
/// <param name="unevaluatedValue">The unevaluated value of the property.</param>
/// <param name="condition">An optional condition to add to the property.</param>
/// <param name="setIfEmpty">An optional value indicating whether or not a condition should be added that checks if the property has already been set.</param>
/// <param name="label">An option label to add to the property.</param>
/// <returns>The current <see cref="ProjectCreator"/>.</returns>
/// <remarks>
/// The <paramref name="setIfEmpty"/> parameter will add a condition such as " '$(Property)' == '' " which will only set the property if it has not already been set.
/// </remarks>
private ProjectCreator Property(ProjectPropertyGroupElement propertyGroup, string name, string unevaluatedValue, string condition = null, bool setIfEmpty = false, string label = null)
{
if (unevaluatedValue == null)
{
return(this);
}
ProjectPropertyElement propertyElement = propertyGroup.AddProperty(name, unevaluatedValue);
if (setIfEmpty && condition != null)
{
propertyElement.Condition = $" '$({propertyElement.Name})' == '' And {condition} ";
}
else if (setIfEmpty)
{
propertyElement.Condition = $" '$({propertyElement.Name})' == '' ";
}
else
{
propertyElement.Condition = condition;
}
if (label != null)
{
propertyElement.Label = label;
}
return(this);
}
/// <summary>
/// Sets a property in the given project, overriding the existing value if it exists.
/// </summary>
/// <param name="project">The project in which the property will be set.</param>
/// <param name="name">The name of the property.</param>
/// <param name="value">The value of the property.</param>
/// <exception cref="System.ArgumentNullException">Thrown if <c>project</c>, <c>name</c>, or <c>value</c> is null.</exception>
/// <exception cref="System.ArgumentException">Thrown if <c>name</c> is empty or contains invalid characters.</exception>
public void SetProperty(IVsProject project, string name, string value)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (name.Length == 0)
{
throw new ArgumentException(Resources.EmptyProperty, "name");
}
Project msbuildProject = MSBuildProjectFromIVsProject(project);
ProjectPropertyElement property = FindProperty(msbuildProject.Xml, name);
if (property == null)
{
ProjectPropertyGroupElement group = msbuildProject.Xml.AddPropertyGroup();
group.AddProperty(name, value);
}
else
{
property.Value = value;
}
}
protected virtual void CopyProperties(IProject sourceProject, IProject targetProject)
{
MSBuildBasedProject sp = sourceProject as MSBuildBasedProject;
MSBuildBasedProject tp = targetProject as MSBuildBasedProject;
if (sp != null && tp != null)
{
lock (sp.SyncRoot) {
lock (tp.SyncRoot) {
// Remove all PropertyGroups in target project:
foreach (ProjectPropertyGroupElement tpg in tp.MSBuildProjectFile.PropertyGroups)
{
tp.MSBuildProjectFile.RemoveChild(tpg);
}
// Copy all PropertyGroups from source project to target project:
foreach (ProjectPropertyGroupElement spg in sp.MSBuildProjectFile.PropertyGroups)
{
ProjectPropertyGroupElement tpg = tp.MSBuildProjectFile.AddPropertyGroup();
tpg.Condition = spg.Condition;
foreach (ProjectPropertyElement sprop in spg.Properties)
{
ProjectPropertyElement tprop = tpg.AddProperty(sprop.Name, sprop.Value);
tprop.Condition = sprop.Condition;
}
}
// use the newly created IdGuid instead of the copied one
tp.SetProperty(MSBuildBasedProject.ProjectGuidPropertyName, tp.IdGuid);
}
}
}
}
public static ProjectRootElement CreateLibraryProject(string name, string defaultConfig, out ProjectPropertyGroupElement mainGroup)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException($"{nameof(name)} cannot be empty", nameof(name));
}
var root = ProjectRootElement.Create();
root.DefaultTargets = "Build";
mainGroup = root.AddPropertyGroup();
mainGroup.AddProperty("Configuration", defaultConfig).Condition = " '$(Configuration)' == '' ";
mainGroup.AddProperty("Platform", "AnyCPU").Condition = " '$(Platform)' == '' ";
mainGroup.AddProperty("ProjectGuid", "{" + Guid.NewGuid().ToString().ToUpper() + "}");
mainGroup.AddProperty("OutputType", "Library");
mainGroup.AddProperty("OutputPath", Path.Combine("bin", "$(Configuration)"));
mainGroup.AddProperty("RootNamespace", IdentifierUtils.SanitizeQualifiedIdentifier(name, allowEmptyIdentifiers: true));
mainGroup.AddProperty("AssemblyName", name);
mainGroup.AddProperty("TargetFrameworkVersion", "v4.5");
mainGroup.AddProperty("GodotProjectGeneratorVersion", Assembly.GetExecutingAssembly().GetName().Version.ToString());
var debugGroup = root.AddPropertyGroup();
debugGroup.Condition = " '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ";
debugGroup.AddProperty("DebugSymbols", "true");
debugGroup.AddProperty("DebugType", "portable");
debugGroup.AddProperty("Optimize", "false");
debugGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;DEBUG;");
debugGroup.AddProperty("ErrorReport", "prompt");
debugGroup.AddProperty("WarningLevel", "4");
debugGroup.AddProperty("ConsolePause", "false");
var releaseGroup = root.AddPropertyGroup();
releaseGroup.Condition = " '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ";
releaseGroup.AddProperty("DebugType", "portable");
releaseGroup.AddProperty("Optimize", "true");
releaseGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;");
releaseGroup.AddProperty("ErrorReport", "prompt");
releaseGroup.AddProperty("WarningLevel", "4");
releaseGroup.AddProperty("ConsolePause", "false");
// References
var referenceGroup = root.AddItemGroup();
referenceGroup.AddItem("Reference", "System");
root.AddImport(Path.Combine("$(MSBuildBinPath)", "Microsoft.CSharp.targets").Replace("/", "\\"));
return(root);
}
public void AddProperty_ExistingPropertySameName()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyGroupElement propertyGroup = project.AddPropertyGroup();
propertyGroup.AddProperty("p", "v1");
propertyGroup.AddProperty("p", "v2");
string expected = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<PropertyGroup>
<p>v1</p>
<p>v2</p>
</PropertyGroup>
</Project>");
Helpers.VerifyAssertProjectContent(expected, project);
}
/// <summary>
/// copy properties from g into a new property group for newConfiguration and newPlatform
/// </summary>
void CopyProperties(ProjectRootElement project, ProjectPropertyGroupElement g, ConfigurationAndPlatform newConfig)
{
ProjectPropertyGroupElement ng = project.AddPropertyGroup();
ng.Condition = newConfig.ToCondition();
foreach (var p in g.Properties)
{
ng.AddProperty(p.Name, p.Value).Condition = p.Condition;
}
}
public static UniqueStringPropertyList FindOrCreatePropertyListByCondition(this ProjectPropertyGroupElement pgpe, string name, string condition)
{
var result = pgpe.Properties.FirstOrDefault(each => each.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase) && each.Condition == condition);
if (result == null)
{
result = pgpe.AddProperty(name, "");
result.Condition = condition;
}
return(new UniqueStringPropertyList(() => result.Value, (s) => result.Value = s));
}
private void AddOutputPath(ProjectPropertyGroupElement newConfig, string configName)
{
//add the output path
string outputBasePath = this.ProjectMgr.OutputBaseRelativePath;
if (outputBasePath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
{
outputBasePath = Path.GetDirectoryName(outputBasePath);
}
newConfig.AddProperty("OutputPath", Path.Combine(outputBasePath, configName) + Path.DirectorySeparatorChar.ToString());
}
public override bool Execute()
{
bool result = true;
string file = Path.Combine(m_stubsPath, m_name + ".featureproj");
try
{
_EVAL.Project proj = new _EVAL.Project();
Microsoft.Build.Evaluation.ProjectCollection projCol = proj.ProjectCollection;
ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup();
bpg.AddProperty("FeatureName", m_name);
bpg.AddProperty("Guid", System.Guid.NewGuid().ToString("B"));
bpg.AddProperty("Description", "<Add Feature Description Here>");
bpg.AddProperty("Groups", "");
bpg.AddProperty(m_name.ToUpper().Replace(".", "_") + "_FEATUREPROJ", "True");
ProjectItemGroupElement big = proj.Xml.AddItemGroup();
big.AddItem("InteropFeature", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_'));
big.AddItem("DriverLibs", Path.GetFileNameWithoutExtension(m_assemblyName).Replace('.', '_') + ".$(LIB_EXT)");
big.AddItem("MMP_DAT_CreateDatabase", "$(BUILD_TREE_CLIENT)\\pe\\$(ENDIANNESS)\\" + m_assemblyName);
big.AddItem("RequiredProjects", Path.Combine(m_stubsPath, m_nativeProjectFile));
proj.Save(file);
// after save, unload the project, so that if rebuilds it is able to regenerate the project file.
ProjectRootElement pre = proj.Xml;
projCol.UnloadProject(proj);
projCol.UnloadProject(pre);
}
catch (Exception e)
{
Log.LogError("Error trying to create feature project file \"" + file + "\": " + e.Message);
result = false;
}
return(result);
}
public void WriteDirectoryBuildProps(ISolutionOptions options)
{
string strongNameKeyDirectory = Path.Combine(options.RepositoryDirectory, "build\\strong name keys\\");
string strongNameKeyFile = Path.Combine(strongNameKeyDirectory, $"{options.SolutionName}SharedKey.snk");
Directory.CreateDirectory(strongNameKeyDirectory);
ProjectRootElement root = ProjectRootElement.Create(NewProjectFileOptions.None);
ProjectPropertyGroupElement p0 = root.AddPropertyGroup();
p0.AddProperty("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)");
ProjectPropertyGroupElement p1 = root.AddPropertyGroup();
p1.AddDefaultProperty("DisableStandardFrameworkResolution", "false");
p1.AddDefaultProperty("AppendTargetFrameworkToOutputDirectory", "false");
ProjectPropertyGroupElement p3 = root.AddPropertyGroup();
p3.AddProperty("SolutionDir", "$(MSBuildThisFileDirectory)");
p3.AddProperty("RepositoryDirectory", "$([System.IO.Path]::GetFullPath('$(SolutionDir)..\\'))");
p3.AddDefaultProperty("OutputPath", @"$([System.IO.Path]::GetFullPath('$(RepositoryDirectory)bin\$(Configuration)\$(MSBuildProjectName)\'))");
p3.AddDefaultProperty("IntermediateOutputPath", @"$([System.IO.Path]::GetFullPath('$(RepositoryDirectory)bin\obj\$(MSBuildProjectName)\$(Configuration)\'))");
StrongNameKeyInfo snk = StrongNameKeyManager.GenerateStrongNameKeyInfo();
ProjectPropertyGroupElement signingProperties = root.AddPropertyGroup();
signingProperties.AddDefaultProperty("SignAssembly", "true");
signingProperties.AddDefaultProperty("AssemblyOriginatorKeyFile", "$(RepositoryDirectory)build\\strong name keys\\$(SolutionName)SharedKey.snk");
signingProperties.AddDefaultProperty("PublicKey", snk.PublicKey);
signingProperties.AddDefaultProperty("PublicKeyToken", snk.PublicKeyToken);
File.WriteAllBytes(strongNameKeyFile, snk.RawBytes);
root.Save(options.DirectoryBuildPropsPath);
}
/// <summary>
/// Emulates the behavior of SetProperty(name, value, condition) on the old MSBuild object model.
/// This finds a property group with the specified condition (or creates one if necessary) then sets the property in there.
/// </summary>
private void SetUserPropertyUnderCondition(string propertyName, string propertyValue, string condition)
{
string conditionTrimmed = (condition == null) ? String.Empty : condition.Trim();
const string userProjectCreateProperty = "UserProject";
if (Project.UserBuildProject == null)
{
Project.SetUserProjectProperty(userProjectCreateProperty, null);
}
if (conditionTrimmed.Length == 0)
{
var userProp = Project.UserBuildProject.GetProperty(userProjectCreateProperty);
if (userProp != null)
{
Project.UserBuildProject.RemoveProperty(userProp);
}
Project.UserBuildProject.SetProperty(propertyName, propertyValue);
return;
}
// New OM doesn't have a convenient equivalent for setting a property with a particular property group condition.
// So do it ourselves.
ProjectPropertyGroupElement newGroup = null;
foreach (ProjectPropertyGroupElement group in Project.UserBuildProject.Xml.PropertyGroups)
{
if (String.Equals(group.Condition.Trim(), conditionTrimmed, StringComparison.OrdinalIgnoreCase))
{
newGroup = group;
break;
}
}
if (newGroup == null)
{
newGroup = Project.UserBuildProject.Xml.AddPropertyGroup(); // Adds after last existing PG, else at start of project
newGroup.Condition = condition;
}
foreach (ProjectPropertyElement property in newGroup.PropertiesReversed) // If there's dupes, pick the last one so we win
{
if (string.Equals(property.Name, propertyName, StringComparison.OrdinalIgnoreCase) &&
(property.Condition == null || property.Condition.Length == 0))
{
property.Value = propertyValue;
return;
}
}
newGroup.AddProperty(propertyName, propertyValue);
}
private bool AddBuildProperties(ProjectRootElement inMemoryProject, Microsoft.Build.Evaluation.Project originalProject)
{
foreach (ProjectPropertyGroupElement propertyGroup in originalProject.Xml.PropertyGroups)
{
ProjectPropertyGroupElement condition = inMemoryProject.AddPropertyGroup();
condition.Condition = propertyGroup.Condition;
foreach (ProjectPropertyElement property in propertyGroup.Properties)
{
ProjectPropertyElement projectPropertyElement = condition.AddProperty(property.Name, property.Value);
projectPropertyElement.Condition = property.Condition;
}
}
return(true);
}
private string AddScriptExtension(ProjectPropertyGroupElement propertyGroup, string scriptCommandline, string scriptId)
{
var scriptArguments = CommandGrammar.Process(
scriptCommandline,
(s) => null,
preserveSurroundingQuotes: false);
scriptArguments = scriptArguments.Where(argument => !string.IsNullOrEmpty(argument)).ToArray();
var scriptCommand = scriptArguments.First();
var propertyName = $"MigratedScriptExtension_{scriptId}";
var windowsScriptExtensionProperty = propertyGroup.AddProperty(propertyName,
s_windowsScriptExtension);
var unixScriptExtensionProperty = propertyGroup.AddProperty(propertyName,
s_unixScriptExtension);
windowsScriptExtensionProperty.Condition =
$" '$(OS)' == 'Windows_NT' and Exists('{scriptCommand}{s_windowsScriptExtension}') ";
unixScriptExtensionProperty.Condition =
$" '$(OS)' != 'Windows_NT' and Exists('{scriptCommand}{s_unixScriptExtension}') ";
return(propertyName);
}
private void PopulateEmptyConfig(ref ProjectPropertyGroupElement newConfig)
{
newConfig = this.project.BuildProject.Xml.AddPropertyGroup();
foreach (KeyValuePair <KeyValuePair <string, string>, string> pair in this.NewConfigProperties)
{
var key = pair.Key;
var unevaluatedValue = pair.Value;
var element = newConfig.AddProperty(key.Key, unevaluatedValue);
if (!string.IsNullOrEmpty(key.Value))
{
element.Condition = key.Value;
}
}
}
protected static void AddOrSetProperty(ProjectPropertyGroupElement group, string name, string value)
{
bool anySet = false;
foreach (var prop in group.Properties.Where(p => p.Name == name))
{
prop.Value = value;
anySet = true;
}
if (!anySet)
{
group.AddProperty(name, value);
}
}
public void GetPropertyTest()
{
CodeSweep.VSPackage.BuildManager_Accessor accessor = new CodeSweep.VSPackage.BuildManager_Accessor(_serviceProvider);
Microsoft.Build.Evaluation.Project project = Utilities.SetupMSBuildProject();
ProjectPropertyGroupElement group = project.Xml.AddPropertyGroup();
group.AddProperty("foo", "bar");
MockIVsProject vsProject = Utilities.RegisterProjectWithMocks(project, _serviceProvider);
Assert.IsNull(accessor.GetProperty(vsProject, "blah"), "GetProperty did not return null with invalid name.");
Assert.AreEqual("bar", accessor.GetProperty(vsProject, "foo"), "GetProperty did not return correct value.");
}
private void SetPropertyIfNotSet(Project project, ref ProjectPropertyGroupElement group, string name, string value, string condition = null)
{
string existingValue = project.GetPropertyValue(name);
if (string.IsNullOrEmpty(existingValue))
{
group = group ?? project.Xml.AddPropertyGroup();
var prop = group.AddProperty(name, value);
if (condition != null)
{
prop.Condition = condition;
}
project.MarkDirty();
}
}