private List <ProjectItemInstance> ExpandItemIntoItems
(
ProjectItemGroupTaskItemInstance originalItem,
Expander <ProjectPropertyInstance, ProjectItemInstance> expander,
ISet <string> keepMetadata,
ISet <string> removeMetadata
)
{
// todo this is duplicated logic with the item computation logic from evaluation (in LazyIncludeOperation.SelectItems)
ProjectErrorUtilities.VerifyThrowInvalidProject(!(keepMetadata != null && removeMetadata != null), originalItem.KeepMetadataLocation, "KeepAndRemoveMetadataMutuallyExclusive");
List <ProjectItemInstance> items = new List <ProjectItemInstance>();
// Expand properties and metadata in Include
string evaluatedInclude = expander.ExpandIntoStringLeaveEscaped(originalItem.Include, ExpanderOptions.ExpandPropertiesAndMetadata, originalItem.IncludeLocation);
if (evaluatedInclude.Length == 0)
{
return(items);
}
// Compute exclude fragments, without expanding wildcards
var excludes = ImmutableList <string> .Empty.ToBuilder();
if (originalItem.Exclude.Length > 0)
{
string evaluatedExclude = expander.ExpandIntoStringLeaveEscaped(originalItem.Exclude, ExpanderOptions.ExpandAll, originalItem.ExcludeLocation);
if (evaluatedExclude.Length > 0)
{
var excludeSplits = ExpressionShredder.SplitSemiColonSeparatedList(evaluatedExclude);
foreach (string excludeSplit in excludeSplits)
{
excludes.Add(excludeSplit);
}
}
}
// Split Include on any semicolons, and take each split in turn
var includeSplits = ExpressionShredder.SplitSemiColonSeparatedList(evaluatedInclude);
ProjectItemInstanceFactory itemFactory = new ProjectItemInstanceFactory(this.Project, originalItem.ItemType);
foreach (string includeSplit in includeSplits)
{
// If expression is "@(x)" copy specified list with its metadata, otherwise just treat as string
bool throwaway;
IList <ProjectItemInstance> itemsFromSplit = expander.ExpandSingleItemVectorExpressionIntoItems(includeSplit,
itemFactory,
ExpanderOptions.ExpandItems,
false /* do not include null expansion results */,
out throwaway,
originalItem.IncludeLocation);
if (itemsFromSplit != null)
{
// Expression is in form "@(X)", so add these items directly.
foreach (ProjectItemInstance item in itemsFromSplit)
{
items.Add(item);
}
}
else
{
// The expression is not of the form "@(X)". Treat as string
// Pass the non wildcard expanded excludes here to fix https://github.com/dotnet/msbuild/issues/2621
string[] includeSplitFiles = EngineFileUtilities.GetFileListEscaped(
Project.Directory,
includeSplit,
excludes,
loggingMechanism: LoggingContext,
includeLocation: originalItem.IncludeLocation,
excludeLocation: originalItem.ExcludeLocation,
disableExcludeDriveEnumerationWarning: true);
foreach (string includeSplitFile in includeSplitFiles)
{
items.Add(new ProjectItemInstance(
Project,
originalItem.ItemType,
includeSplitFile,
includeSplit /* before wildcard expansion */,
null,
null,
originalItem.Location.File));
}
}
}
// Evaluate, split, expand and subtract any Exclude
HashSet <string> excludesUnescapedForComparison = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (string excludeSplit in excludes)
{
string[] excludeSplitFiles = EngineFileUtilities.GetFileListUnescaped(
Project.Directory,
excludeSplit,
loggingMechanism: LoggingContext,
excludeLocation: originalItem.ExcludeLocation);
foreach (string excludeSplitFile in excludeSplitFiles)
{
excludesUnescapedForComparison.Add(excludeSplitFile);
}
}
List <ProjectItemInstance> remainingItems = new List <ProjectItemInstance>();
for (int i = 0; i < items.Count; i++)
{
if (!excludesUnescapedForComparison.Contains(((IItem)items[i]).EvaluatedInclude))
{
remainingItems.Add(items[i]);
}
}
items = remainingItems;
// Filter the metadata as appropriate
if (keepMetadata != null)
{
foreach (var item in items)
{
var metadataToRemove = item.MetadataNames.Where(name => !keepMetadata.Contains(name));
foreach (var metadataName in metadataToRemove)
{
item.RemoveMetadata(metadataName);
}
}
}
else if (removeMetadata != null)
{
foreach (var item in items)
{
var metadataToRemove = item.MetadataNames.Where(name => removeMetadata.Contains(name));
foreach (var metadataName in metadataToRemove)
{
item.RemoveMetadata(metadataName);
}
}
}
return(items);
}
/// <summary>
/// Takes an item specification, evaluates it and expands it into a list of items
/// </summary>
/// <param name="originalItem">The original item data</param>
/// <param name="expander">The expander to use.</param>
/// <param name="keepMetadata">An <see cref="ISet{String}"/> of metadata names to keep.</param>
/// <param name="removeMetadata">An <see cref="ISet{String}"/> of metadata names to remove.</param>
/// <remarks>
/// This code is very close to that which exists in the Evaluator.EvaluateItemXml method. However, because
/// it invokes type constructors, and those constructors take arguments of fundamentally different types, it has not
/// been refactored.
/// </remarks>
/// <returns>A list of items.</returns>
private IList <ProjectItemInstance> ExpandItemIntoItems
(
ProjectItemGroupTaskItemInstance originalItem,
Expander <ProjectPropertyInstance, ProjectItemInstance> expander,
ISet <string> keepMetadata,
ISet <string> removeMetadata
)
{
ProjectErrorUtilities.VerifyThrowInvalidProject(!(keepMetadata != null && removeMetadata != null), originalItem.KeepMetadataLocation, "KeepAndRemoveMetadataMutuallyExclusive");
IList <ProjectItemInstance> items = new List <ProjectItemInstance>();
// UNDONE: (Refactor) This code also exists in largely the same form in Evaluator.CreateItemsFromInclude.
// STEP 1: Expand properties and metadata in Include
string evaluatedInclude = expander.ExpandIntoStringLeaveEscaped(originalItem.Include, ExpanderOptions.ExpandPropertiesAndMetadata, originalItem.IncludeLocation);
// STEP 2: Split Include on any semicolons, and take each split in turn
if (evaluatedInclude.Length > 0)
{
var includeSplits = ExpressionShredder.SplitSemiColonSeparatedList(evaluatedInclude);
ProjectItemInstanceFactory itemFactory = new ProjectItemInstanceFactory(this.Project, originalItem.ItemType);
foreach (string includeSplit in includeSplits)
{
// STEP 3: If expression is "@(x)" copy specified list with its metadata, otherwise just treat as string
bool throwaway;
IList <ProjectItemInstance> itemsFromSplit = expander.ExpandSingleItemVectorExpressionIntoItems(includeSplit, itemFactory, ExpanderOptions.ExpandItems, false /* do not include null expansion results */, out throwaway, originalItem.IncludeLocation);
if (itemsFromSplit != null)
{
// Expression is in form "@(X)", so add these items directly.
foreach (ProjectItemInstance item in itemsFromSplit)
{
items.Add(item);
}
}
else
{
// The expression is not of the form "@(X)". Treat as string
string[] includeSplitFiles = EngineFileUtilities.GetFileListEscaped(Project.Directory, includeSplit);
foreach (string includeSplitFile in includeSplitFiles)
{
items.Add(new ProjectItemInstance(Project, originalItem.ItemType, includeSplitFile, includeSplit /* before wildcard expansion */, null, null, originalItem.Location.File));
}
}
}
// STEP 4: Evaluate, split, expand and subtract any Exclude
if (originalItem.Exclude.Length > 0)
{
string evaluatedExclude = expander.ExpandIntoStringLeaveEscaped(originalItem.Exclude, ExpanderOptions.ExpandAll, originalItem.ExcludeLocation);
if (evaluatedExclude.Length > 0)
{
var excludeSplits = ExpressionShredder.SplitSemiColonSeparatedList(evaluatedExclude);
HashSet <string> excludesUnescapedForComparison = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (string excludeSplit in excludeSplits)
{
string[] excludeSplitFiles = EngineFileUtilities.GetFileListUnescaped(Project.Directory, excludeSplit);
foreach (string excludeSplitFile in excludeSplitFiles)
{
excludesUnescapedForComparison.Add(excludeSplitFile);
}
}
List <ProjectItemInstance> remainingItems = new List <ProjectItemInstance>();
for (int i = 0; i < items.Count; i++)
{
if (!excludesUnescapedForComparison.Contains(((IItem)items[i]).EvaluatedInclude))
{
remainingItems.Add(items[i]);
}
}
items = remainingItems;
}
}
}
// Filter the metadata as appropriate
if (keepMetadata != null)
{
foreach (var item in items)
{
var metadataToRemove = item.MetadataNames.Where(name => !keepMetadata.Contains(name));
foreach (var metadataName in metadataToRemove)
{
item.RemoveMetadata(metadataName);
}
}
}
else if (removeMetadata != null)
{
foreach (var item in items)
{
var metadataToRemove = item.MetadataNames.Where(name => removeMetadata.Contains(name));
foreach (var metadataName in metadataToRemove)
{
item.RemoveMetadata(metadataName);
}
}
}
return(items);
}
/// <summary>
/// Returns a list of all items in the provided item group whose itemspecs match the specification, after it is split and any wildcards are expanded.
/// If no items match, returns null.
/// </summary>
/// <param name="items">The items to match</param>
/// <param name="specification">The specification to match against the items.</param>
/// <param name="specificationLocation">The specification to match against the provided items</param>
/// <param name="expander">The expander to use</param>
/// <returns>A list of matching items</returns>
private List <ProjectItemInstance> FindItemsMatchingSpecification
(
ICollection <ProjectItemInstance> items,
string specification,
ElementLocation specificationLocation,
Expander <ProjectPropertyInstance, ProjectItemInstance> expander
)
{
if (items.Count == 0 || specification.Length == 0)
{
return(null);
}
// This is a hashtable whose key is the filename for the individual items
// in the Exclude list, after wildcard expansion.
HashSet <string> specificationsToFind = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
// Split by semicolons
var specificationPieces = expander.ExpandIntoStringListLeaveEscaped(specification, ExpanderOptions.ExpandAll, specificationLocation);
foreach (string piece in specificationPieces)
{
// Take each individual path or file expression, and expand any
// wildcards. Then loop through each file returned, and add it
// to our hashtable.
// Don't unescape wildcards just yet - if there were any escaped, the caller wants to treat them
// as literals. Everything else is safe to unescape at this point, since we're only matching
// against the file system.
string[] fileList = EngineFileUtilities.GetFileListEscaped(Project.Directory, piece);
foreach (string file in fileList)
{
// Now unescape everything, because this is the end of the road for this filename.
// We're just going to compare it to the unescaped include path to filter out the
// file excludes.
specificationsToFind.Add(EscapingUtilities.UnescapeAll(file));
}
}
if (specificationsToFind.Count == 0)
{
return(null);
}
// Now loop through our list and filter out any that match a
// filename in the remove list.
List <ProjectItemInstance> itemsRemoved = new List <ProjectItemInstance>();
foreach (ProjectItemInstance item in items)
{
// Even if the case for the excluded files is different, they
// will still get excluded, as expected. However, if the excluded path
// references the same file in a different way, such as by relative
// path instead of absolute path, we will not realize that they refer
// to the same file, and thus we will not exclude it.
if (specificationsToFind.Contains(item.EvaluatedInclude))
{
itemsRemoved.Add(item);
}
}
return(itemsRemoved);
}
/// <summary>
/// Instantiates an ItemGroup task
/// </summary>
/// <param name="taskInstance">The original task instance data</param>
/// <param name="loggingContext">The logging context</param>
/// <param name="projectInstance">The project instance</param>
/// <param name="logTaskInputs">Flag to determine whether or not to log task inputs.</param>
public ItemGroupIntrinsicTask(ProjectItemGroupTaskInstance taskInstance, TargetLoggingContext loggingContext, ProjectInstance projectInstance, bool logTaskInputs)
: base(loggingContext, projectInstance, logTaskInputs)
{
_taskInstance = taskInstance;
_engineFileUtilities = EngineFileUtilities.Default;
}
