static void AddItems(ProjectRootElement elem, string groupName, params string[] items)
{
ProjectItemGroupElement group = elem.AddItemGroup();
foreach (var item in items)
{
ProjectItemElement projItem = group.AddItem(groupName, item);
//if (groupName == "Compile")
//{
// projItem.AddMetadata("Link", item);
//}
}
}
private static bool IsGuidValue(ProjectItemElement e)
{
Guid g;
foreach (var i in (e.Include?.Split('/', '\\')).MaybeEnumerate())
{
if (Guid.TryParse(i?.Trim() ?? "", out g))
{
return(true);
}
}
return(false);
}
private void AddFiles(IReadOnlyCollection <string> filesToAdd)
{
// await InMemoryProjectSourceItemProviderExtension.CallListeners(this.SourceItemsAddingListeners, contexts, false);
foreach (string path in filesToAdd)
{
RemoveItem(_filesItemGroup, _fileItems, path);
ProjectItemElement item = _filesItemGroup.AddItem("Content", path, Enumerable.Empty <KeyValuePair <string, string> >());
_fileItems.Add(path, item);
}
// await InMemoryProjectSourceItemProviderExtension.CallListeners(this.SourceItemsAddedListeners, contexts, false);
}
private bool AddAssemblyReferences(ProjectRootElement inMemoryProject, Microsoft.Build.Evaluation.Project originalProject)
{
foreach (Microsoft.Build.Evaluation.ProjectItem item in originalProject.GetItems("Reference"))
{
ProjectItemElement condition = inMemoryProject.AddItem(item.ItemType, item.UnevaluatedInclude);
condition.Condition = item.Xml.Condition;
foreach (ProjectMetadata metadatum in item.Metadata)
{
condition.AddMetadata(metadatum.Name, metadatum.EvaluatedValue);
}
}
return(true);
}
/// <summary>
/// Adds the item group containting the ProjectConfiguration items to a new project.
/// </summary>
void AddProjectConfigurationsItemGroup()
{
ProjectRootElement file = MSBuildProjectFile;
ProjectItemGroupElement configItemGroup = file.AddItemGroup();
configItemGroup.Label = "ProjectConfigurations";
foreach (string target in new string[] { "Debug|Win32", "Release|Win32" })
{
ProjectItemElement prjConfiguration = configItemGroup.AddItem("ProjectConfiguration", target);
prjConfiguration.AddMetadata("Configuration", GetConfigurationNameFromKey(target));
prjConfiguration.AddMetadata("Platform", GetPlatformNameFromKey(target));
}
}
public static bool HasInclude(this ProjectItemElement el, string include)
{
include = NormalizeIncludeForComparison(include);
foreach (var i in el.Includes())
{
if (include == NormalizeIncludeForComparison(i))
{
return(true);
}
}
return(false);
}
public static void SetMetadataValue(this ProjectItemElement pel, string name, string value)
{
var existing = pel.Metadata.FirstOrDefault(p => p.Name == name);
if (existing != null)
{
existing.Value = value;
}
else
{
pel.AddMetadata(name, value);
}
}
private MergeResult MergeItems(ProjectItemElement item, ProjectItemElement existingItem)
{
if (!string.IsNullOrEmpty(item.Include))
{
return(MergeItemsOnIncludes(item, existingItem));
}
if (!string.IsNullOrEmpty(item.Update))
{
return(MergeItemsOnUpdates(item, existingItem));
}
throw new InvalidOperationException(LocalizableStrings.CannotMergeItemsWithoutCommonIncludeError);
}
private static ProjectItemElement AddItem(ProjectRootElement projectRoot, string itemTypeName, string include, params string[] idAndValuePairs)
{
ProjectItemElement item = projectRoot.AddItem(itemTypeName, include);
Math.DivRem(idAndValuePairs.Length, 2, out int remainder);
Assert.AreEqual(0, remainder, "Test setup error: the supplied list should contain id-location pairs");
for (int index = 0; index < idAndValuePairs.Length; index += 2)
{
item.AddMetadata(idAndValuePairs[index], idAndValuePairs[index + 1]);
}
return(item);
}
public void SettingItemRemoveDirties()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectItemElement item = project.AddTarget("t").AddItemGroup().AddItem("i", "i1");
item.Include = null;
Helpers.ClearDirtyFlag(project);
item.Remove = "i2";
Assert.Equal("i2", item.Remove);
Assert.Equal(true, project.HasUnsavedChanges);
}
public static Reference AsReference(this ProjectItemElement item)
{
var name = item.Include;
var comma = name.IndexOf(',', StringComparison.Ordinal);
if (comma > 0)
{
name = name.Substring(0, comma);
}
return(new(name)
{
HintPath = item.GetHintPath(),
});
public static bool TryMoveElementsBelow(Project project, ImmutableArray <ProjectItemElement> elements, IProjectTree target)
{
Requires.NotNull(project, nameof(project));
Requires.NotNull(target, nameof(target));
ProjectItemElement referenceElement = TryGetReferenceElement(project, target, ImmutableArray <string> .Empty, MoveAction.Below);
if (referenceElement == null)
{
return(false);
}
return(TryMoveElements(elements, referenceElement, MoveAction.Below));
}
private static List <CsClass> ParseCsFile(ProjectInSolution solutionProject, ProjectItemElement csFile)
{
var filePath = csFile.Include;
var fileAbsolutePath = Path.Combine(Path.GetDirectoryName(solutionProject.AbsolutePath), filePath);
var source = File.ReadAllText(fileAbsolutePath);
SyntaxTree projectSyntaxTree = CSharpSyntaxTree.ParseText(source);
var projectTree = (CompilationUnitSyntax)projectSyntaxTree.GetRoot();
var namespaceTree = projectTree.Members.OfType <NamespaceDeclarationSyntax>().SingleOrDefault();
var csFileClasses = new List <CsClass>();
if (namespaceTree == null)
{
return(csFileClasses);
}
foreach (var classTree in namespaceTree.Members.OfType <ClassDeclarationSyntax>())
{
if (classTree.BaseList?.Types == null)
{
continue;
}
foreach (var baseType in classTree.BaseList?.Types.OfType <SimpleBaseTypeSyntax>())
{
var props = classTree.Members.OfType <PropertyDeclarationSyntax>()
.Select(x => new CsProperty()
{
Name = x.Identifier.ToString(), Type = x.Type.ToString()
});
var methods = classTree.Members.OfType <MethodDeclarationSyntax>()
.Select(x => ParseMethod(x));
var csClass = new CsClass()
{
Name = classTree.Identifier.ToString(),
ParentName = baseType?.Type.ToString(),
Properties = props,
Methods = methods
};
csFileClasses.Add(csClass);
}
}
return(csFileClasses);
}
public static void AddMetadata(this ProjectItemElement item, ProjectMetadataElement metadata)
{
var existingMetadata = item.GetMetadataWithName(metadata.Name);
if (existingMetadata != default(ProjectMetadataElement) && !existingMetadata.ValueEquals(metadata))
{
throw new Exception("Cannot merge metadata with the same name and different values");
}
if (existingMetadata == default(ProjectMetadataElement))
{
MigrationTrace.Instance.WriteLine($"{nameof(AddMetadata)}: Adding metadata to {item.ItemType} item: {{ {metadata.Name}, {metadata.Value} }}");
item.AddMetadata(metadata.Name, metadata.Value);
}
}
public void ShouldCopyToOutputDirectory(string copyToOutputDirectoryValue, bool expectedResult)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
ProjectItemElement item = projectRootElement.AddItem("Foo", "Foo.xml");
if (!string.IsNullOrEmpty(copyToOutputDirectoryValue))
{
item.AddMetadata("CopyToOutputDirectory", copyToOutputDirectoryValue);
}
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
ProjectItemInstance itemInstance = projectInstance.GetItems("Foo").Single();
Assert.Equal(expectedResult, itemInstance.ShouldCopyToOutputDirectory());
}
protected LazyItemOperation(OperationBuilder builder, LazyItemEvaluator <P, I, M, D> lazyEvaluator)
{
_itemElement = builder.ItemElement;
_itemType = builder.ItemType;
_itemSpec = builder.ItemSpec;
_referencedItemLists = builder.ReferencedItemLists.ToImmutable();
_lazyEvaluator = lazyEvaluator;
_evaluatorData = new EvaluatorData(_lazyEvaluator._outerEvaluatorData, itemType => GetReferencedItems(itemType, ImmutableHashSet <string> .Empty));
_itemFactory = new ItemFactoryWrapper(_itemElement, _lazyEvaluator._itemFactory);
_expander = new Expander <P, I>(_evaluatorData, _evaluatorData);
_itemSpec.Expander = _expander;
}
public static ProjectMetadataElement SetMetadata(this ProjectItemElement itemElement, string name, string unevaluatedValue)
{
ProjectMetadataElement metadataElement = itemElement.Metadata.FirstOrDefault(i => i.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (metadataElement != null)
{
metadataElement.Value = unevaluatedValue;
}
else
{
metadataElement = AddMetadataAsAttribute(itemElement, name, unevaluatedValue);
}
return(metadataElement);
}
/// Creates an empty file on disc and adds it to the project as an
/// item with the specified ItemGroup include name.
/// The SonarQubeExclude metadata item is set to the specified value.
/// </summary>
/// <param name="includeName">The name of the item type e.g. Compile, Content</param>
/// <param name="sonarQubeExclude">The value to assign to the SonarExclude metadata item</param>
/// <returns>The full path to the new file</returns>
private string AddFileToProject(ProjectRootElement projectRoot, string includeName, string sonarQubeExclude, string autoGen)
{
ProjectItemElement newItem = AddFileToProject(projectRoot, includeName);
if (sonarQubeExclude != null)
{
newItem.AddMetadata(TargetProperties.SonarQubeExcludeMetadata, sonarQubeExclude);
}
if (autoGen != null)
{
newItem.AddMetadata(TargetProperties.AutoGenMetadata, autoGen);
}
return(newItem.Include);
}
private ProjectFileEntry ReadProjectFileEntryItem(ProjectItemElement element)
{
var entry = new ProjectFileEntry(new FilePath(this.ProjectDirectory, element.Include));
foreach (var metadata in element.Metadata)
{
if (metadata.Name == "DependentUpon")
{
entry.Dependencies.Add(metadata.Value);
}
}
entry.ParentProject = this;
return(entry);
}
/// <summary>
/// Get a valid ProjectItemElement with no metadata
/// </summary>
private static ProjectItemElement GetItemXml()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<ItemGroup>
<i Include='i'/>
</ItemGroup>
</Project>
";
ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
ProjectItemGroupElement itemGroup = (ProjectItemGroupElement)Helpers.GetFirst(project.Children);
ProjectItemElement item = Helpers.GetFirst(itemGroup.Items);
return(item);
}
/// <summary>
/// Create a new <see cref="MSBuildItemGroup"/>.
/// </summary>
/// <param name="items">
/// The underlying MSBuild <see cref="ProjectItem"/>s.
/// </param>
/// <param name="originatingElement">
/// The MSBuild <see cref="ProjectItemElement"/> from where the items originate.
/// </param>
/// <param name="itemElement">
/// An <see cref="XSElement"/> representing the item's XML element.
/// </param>
public MSBuildItemGroup(IReadOnlyList <ProjectItem> items, ProjectItemElement originatingElement, XSElement itemElement)
: base(items, itemElement)
{
if (Items.Count == 0)
{
throw new ArgumentException("Must specify at least one ProjectItem.", nameof(items));
}
if (originatingElement == null)
{
throw new ArgumentNullException(nameof(originatingElement));
}
Name = itemElement.Name;
OriginatingElement = originatingElement;
}
public void SettingItemUpdateDirties()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectItemElement item = project.AddItemGroup().AddItem("i", "i1");
item.Include = null;
Helpers.ClearDirtyFlag(project);
Assert.False(project.HasUnsavedChanges);
item.Update = "i2";
Assert.Equal("i2", item.Update);
Assert.True(project.HasUnsavedChanges);
}
private void ProcessMetadataElements(ProjectItemElement itemElement, OperationBuilderWithMetadata operationBuilder)
{
if (itemElement.HasMetadata)
{
operationBuilder.Metadata.AddRange(itemElement.Metadata);
var itemsAndMetadataFound = ExpressionShredder.GetReferencedItemNamesAndMetadata(GetExpandedMetadataValuesAndConditions(itemElement.Metadata, _expander));
if (itemsAndMetadataFound.Items != null)
{
foreach (var itemType in itemsAndMetadataFound.Items)
{
AddReferencedItemList(itemType, operationBuilder.ReferencedItemLists);
}
}
}
}
/// <summary>
/// Adds an item to the current item group.
/// </summary>
/// <param name="itemGroup">The parent item group to add the item to.</param>
/// <param name="itemType">The type of the item to add.</param>
/// <param name="include">The file or wildcard to include in the list of items.</param>
/// <param name="exclude">An optional file or wildcard to exclude from the list of items.</param>
/// <param name="metadata">An optional <see cref="IDictionary{String,String}"/> containing metadata for the item.</param>
/// <param name="remove">The file or wildcard to remove from the list of items.</param>
/// <param name="update">The file or wildcard to update in the list of items.</param>
/// <param name="condition">An optional condition to add to the item.</param>
/// <param name="keepDuplicates">Specifies whether an item should be added to the target group if it's an exact duplicate of an existing item.</param>
/// <param name="keepMetadata">The metadata for the source items to add to the target items.</param>
/// <param name="label">An optional label to add to the item.</param>
/// <returns>The current <see cref="ProjectCreator"/>.</returns>
private ProjectCreator Item(
ProjectItemGroupElement itemGroup,
string itemType,
string include,
string exclude = null,
IDictionary <string, string> metadata = null,
string remove = null,
string update = null,
string condition = null,
string keepDuplicates = null,
string keepMetadata = null,
string label = null)
{
ProjectItemElement item = include == null
? RootElement.CreateItemElement(itemType)
: RootElement.CreateItemElement(itemType, include);
item.Remove = remove;
item.Update = update;
// Item must be added after Include, Update, or Remove is set but before metadata is added
itemGroup.AppendChild(item);
if (metadata != null)
{
foreach (KeyValuePair <string, string> metadatum in metadata.Where(i => i.Value != null))
{
item.AddMetadata(metadatum.Key, metadatum.Value);
}
}
item.Condition = condition;
item.Label = label;
item.Exclude = exclude;
if (keepDuplicates != null)
{
item.KeepDuplicates = keepDuplicates;
}
if (keepMetadata != null)
{
item.KeepMetadata = keepMetadata;
}
return(this);
}
public static void AddMetadata(this ProjectItemElement item, ProjectMetadataElement metadata, TextWriter trace = null)
{
var existingMetadata = item.GetMetadataWithName(metadata.Name);
if (existingMetadata != default(ProjectMetadataElement) && !existingMetadata.ValueEquals(metadata))
{
throw new Exception(LocalizableStrings.CannotMergeMetadataError);
}
if (existingMetadata == default(ProjectMetadataElement))
{
trace?.WriteLine(String.Format(LocalizableStrings.AddingMetadataToItem, nameof(AddMetadata), item.ItemType, metadata.Name, metadata.Value, metadata.Condition));
var metametadata = item.AddMetadata(metadata.Name, metadata.Value);
metametadata.Condition = metadata.Condition;
metametadata.ExpressedAsAttribute = metadata.ExpressedAsAttribute;
}
}
public void GetTargetPath(string itemIdentity, string linkValue, string expectedResult)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
itemIdentity = itemIdentity.Replace("{ProjectDir}", projectRootElement.DirectoryPath, StringComparison.Ordinal);
ProjectItemElement item = projectRootElement.AddItem("Foo", itemIdentity);
if (!string.IsNullOrEmpty(linkValue))
{
item.AddMetadata("Link", linkValue);
}
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
ProjectItemInstance itemInstance = projectInstance.GetItems("Foo").Single();
Assert.Equal(expectedResult, itemInstance.GetTargetPath());
}
public void ReadMetadata(string project)
{
ProjectRootElement projectElement = ProjectRootElement.Create(XmlReader.Create(new StringReader(project)));
ProjectItemGroupElement itemGroup = (ProjectItemGroupElement)projectElement.AllChildren.FirstOrDefault(c => c is ProjectItemGroupElement);
ProjectItemElement item = Helpers.GetFirst(itemGroup.Items);
var metadata = Helpers.MakeList(item.Metadata);
Assert.Equal(3, metadata.Count);
Assert.Equal("m1", metadata[0].Name);
Assert.Equal("v1", metadata[0].Value);
Assert.Equal("m2", metadata[1].Name);
Assert.Equal("v2", metadata[1].Value);
Assert.Equal("c", metadata[1].Condition);
Assert.Equal("m1", metadata[2].Name);
Assert.Equal("v3", metadata[2].Value);
}
private ProjFilePackageInfo ConvetProjectPackage(ProjectItemElement ele)
{
ProjFilePackageInfo info = new ProjFilePackageInfo();
if (ele == null)
{
return(null);
}
string includeStr = ele.Include;
var includeArr = includeStr.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
info.Include_Name = includeArr[0];
foreach (var item in includeArr)
{
if (item.Contains("Version"))
{
info.Include_Version = item.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries)[1];
}
else if (item.Contains("Culture"))
{
info.Include_Culture = item.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries)[1];
}
else if (item.Contains("PublicKeyToken"))
{
info.Include_PublicKeyToken = item.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries)[1];
}
else if (item.Contains("processorArchitecture"))
{
info.Include_ProcessorArchitecture = item.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries)[1];
}
}
foreach (var item in ele.Metadata)
{
if (item.Name == "HintPath")
{
info.HintPath = item.Value.ToString().Trim();
}
else if (item.Name == "Private")
{
info.Private = item.Value.ToString().Trim();
}
}
return(info);
}
private void AddItemToItemGroup(ProjectItemElement item, ProjectItemGroupElement itemGroup)
{
var outputItem = itemGroup.ContainingProject.CreateItemElement("___TEMP___");
outputItem.CopyFrom(item);
MigrationTrace.Instance.WriteLine(String.Format(
LocalizableStrings.ItemTransformApplicatorAddItemHeader,
nameof(ItemTransformApplicator),
outputItem.ItemType,
outputItem.Condition,
outputItem.Include,
outputItem.Exclude,
outputItem.Update));
itemGroup.AppendChild(outputItem);
outputItem.AddMetadata(item.Metadata, MigrationTrace.Instance);
}
public static bool IsEquivalentTo(this ProjectItemElement item, ProjectItemElement otherItem)
{
// Different includes
if (item.IntersectIncludes(otherItem).Count() != item.Includes().Count())
{
MigrationTrace.Instance.WriteLine($"{nameof(MSBuildExtensions)}.{nameof(IsEquivalentTo)} includes not equivalent.");
return(false);
}
// Different Excludes
if (item.IntersectExcludes(otherItem).Count() != item.Excludes().Count())
{
MigrationTrace.Instance.WriteLine($"{nameof(MSBuildExtensions)}.{nameof(IsEquivalentTo)} excludes not equivalent.");
return(false);
}
return(item.IsEquivalentToExceptIncludeAndExclude(otherItem));
}
