/// <summary>
/// Processes the "include" list and the "exclude" list for an item element, and returns
/// the resultant virtual group of items. Ignores any condition on the item.
/// </summary>
/// <param name="baseDirectory">Where relative paths should be evaluated from</param>
/// <param name="originalItem">The "mother" item that's being expanded</param>
/// <param name="expander">Expander to evaluated items and properties</param>
/// <param name="expandMetadata">Whether metadata expressions should be expanded, or left as literals</param>
internal static BuildItemGroup ExpandItemIntoItems
(
string baseDirectory,
BuildItem originalItem,
Expander expander,
bool expandMetadata
)
{
ErrorUtilities.VerifyThrow(originalItem != null, "Can't add a null item to project.");
ErrorUtilities.VerifyThrow(expander != null, "expander can't be null.");
// Take the entire string specified in the "Include" attribute, and split
// it up by semi-colons. Then loop over the individual pieces.
// Expand only with properties first, so that expressions like Include="@(foo)" will transfer the metadata of the "foo" items as well, not just their item specs.
List <string> itemIncludePieces = (new Expander(expander, ExpanderOptions.ExpandProperties).ExpandAllIntoStringListLeaveEscaped(originalItem.Include, originalItem.IncludeAttribute));
BuildItemGroup itemsToInclude = new BuildItemGroup();
for (int i = 0; i < itemIncludePieces.Count; i++)
{
BuildItemGroup itemizedGroup = expander.ExpandSingleItemListExpressionIntoItemsLeaveEscaped(itemIncludePieces[i], originalItem.IncludeAttribute);
if (itemizedGroup == null)
{
// The expression did not represent a single @(...) item list reference.
if (expandMetadata)
{
// We're inside a target: metadata expressions like %(foo) are legal, so expand them now
itemIncludePieces[i] = expander.ExpandMetadataLeaveEscaped(itemIncludePieces[i]);
}
// Now it's a string constant, possibly with wildcards.
// Take each individual path or file expression, and expand any
// wildcards. Then loop through each file returned.
if (itemIncludePieces[i].Length > 0)
{
string[] includeFileList = EngineFileUtilities.GetFileListEscaped(baseDirectory, itemIncludePieces[i]);
for (int j = 0; j < includeFileList.Length; j++)
{
BuildItem newItem = itemsToInclude.AddNewItem(originalItem.Name, originalItem.Include);
newItem.SetEvaluatedItemSpecEscaped(itemIncludePieces[i]); // comes from XML include --- "arbitrarily escaped"
newItem.SetFinalItemSpecEscaped(includeFileList[j]); // comes from file system matcher -- "canonically escaped"
}
}
}
else
{
itemsToInclude.ImportItems(itemizedGroup);
}
}
List <BuildItem> matchingItems = FindItemsMatchingSpecification(itemsToInclude, originalItem.Exclude, originalItem.ExcludeAttribute, expander, baseDirectory);
if (matchingItems != null)
{
foreach (BuildItem item in matchingItems)
{
itemsToInclude.RemoveItem(item);
}
}
return(itemsToInclude);
}
// NOTE: maybe it should throw an exception?
// at the moment it probably doesn't find a "null" element
public void TestRemoveItem2 ()
{
BuildItemGroup big = new BuildItemGroup ();
big.RemoveItem (null);
}
public void RemoveItemWhenItemIsNull()
{
BuildItemGroup group = new BuildItemGroup();
group.RemoveItem(null);
Assertion.AssertEquals(0, group.Count);
}
public void TestRemoveItem1 ()
{
BuildItemGroup big = new BuildItemGroup ();
big.AddNewItem ("a", "b");
BuildItem b = big.AddNewItem ("b", "c");
big.AddNewItem ("c", "d");
big.RemoveItem (b);
BuildItem[] items = big.ToArray ();
Assert.AreEqual (2, big.Count, "A1");
Assert.AreEqual ("a", items [0].Name, "A2");
Assert.AreEqual ("c", items [1].Name, "A3");
}
public void RemoveItemAllOfSeveral()
{
BuildItemGroup group = new BuildItemGroup();
BuildItem[] item = new BuildItem[3];
item[0] = group.AddNewItem("n1", "i1");
item[1] = group.AddNewItem("n2", "i2");
item[2] = group.AddNewItem("n3", "i3");
group.RemoveItem(item[0]);
group.RemoveItem(item[1]);
group.RemoveItem(item[2]);
Assertion.AssertEquals(0, group.Count);
}
public void RemoveItemOneOfSeveral()
{
BuildItemGroup group = new BuildItemGroup();
BuildItem item = group.AddNewItem("n1", "i1");
group.AddNewItem("n2", "i2");
group.AddNewItem("n3", "i3");
group.RemoveItem(item);
Assertion.AssertEquals(2, group.Count);
Dictionary<string, string> items = GetDictionaryOfBuildItemsInBuildItemsGroup(group);
Assertion.AssertEquals("i2", items["n2"]);
Assertion.AssertEquals("i3", items["n3"]);
}
/// <summary>
/// Processes the "include" list and the "exclude" list for an item element, and returns
/// the resultant virtual group of items. Ignores any condition on the item.
/// </summary>
/// <param name="baseDirectory">Where relative paths should be evaluated from</param>
/// <param name="originalItem">The "mother" item that's being expanded</param>
/// <param name="expander">Expander to evaluated items and properties</param>
/// <param name="expandMetadata">Whether metadata expressions should be expanded, or left as literals</param>
internal static BuildItemGroup ExpandItemIntoItems
(
string baseDirectory,
BuildItem originalItem,
Expander expander,
bool expandMetadata
)
{
ErrorUtilities.VerifyThrow(originalItem != null, "Can't add a null item to project.");
ErrorUtilities.VerifyThrow(expander != null, "expander can't be null.");
// Take the entire string specified in the "Include" attribute, and split
// it up by semi-colons. Then loop over the individual pieces.
// Expand only with properties first, so that expressions like Include="@(foo)" will transfer the metadata of the "foo" items as well, not just their item specs.
List<string> itemIncludePieces = (new Expander(expander, ExpanderOptions.ExpandProperties).ExpandAllIntoStringListLeaveEscaped(originalItem.Include, originalItem.IncludeAttribute));
BuildItemGroup itemsToInclude = new BuildItemGroup();
for (int i = 0; i < itemIncludePieces.Count; i++)
{
BuildItemGroup itemizedGroup = expander.ExpandSingleItemListExpressionIntoItemsLeaveEscaped(itemIncludePieces[i], originalItem.IncludeAttribute);
if (itemizedGroup == null)
{
// The expression did not represent a single @(...) item list reference.
if (expandMetadata)
{
// We're inside a target: metadata expressions like %(foo) are legal, so expand them now
itemIncludePieces[i] = expander.ExpandMetadataLeaveEscaped(itemIncludePieces[i]);
}
// Now it's a string constant, possibly with wildcards.
// Take each individual path or file expression, and expand any
// wildcards. Then loop through each file returned.
if (itemIncludePieces[i].Length > 0)
{
string[] includeFileList = EngineFileUtilities.GetFileListEscaped(baseDirectory, itemIncludePieces[i]);
for (int j = 0; j < includeFileList.Length; j++)
{
BuildItem newItem = itemsToInclude.AddNewItem(originalItem.Name, originalItem.Include);
newItem.SetEvaluatedItemSpecEscaped(itemIncludePieces[i]); // comes from XML include --- "arbitrarily escaped"
newItem.SetFinalItemSpecEscaped(includeFileList[j]); // comes from file system matcher -- "canonically escaped"
}
}
}
else
{
itemsToInclude.ImportItems(itemizedGroup);
}
}
List<BuildItem> matchingItems = FindItemsMatchingSpecification(itemsToInclude, originalItem.Exclude, originalItem.ExcludeAttribute, expander, baseDirectory);
if (matchingItems != null)
{
foreach (BuildItem item in matchingItems)
{
itemsToInclude.RemoveItem(item);
}
}
return itemsToInclude;
}
public void RemoveItemNotBelonging()
{
XmlElement ig = CreatePersistedItemGroupElement();
BuildItemGroup group = new BuildItemGroup(ig, false, new Project());
BuildItem item = new BuildItem("x", "x1");
group.RemoveItem(item);
}
public void RemoveItem1()
{
XmlElement ig = CreatePersistedItemGroupElement();
BuildItemGroup group = new BuildItemGroup(ig, false, new Project());
BuildItem i2 = group[1];
group.RemoveItem(i2);
Assertion.AssertEquals(1, group.Count);
Assertion.AssertEquals(1, group.ItemGroupElement.ChildNodes.Count);
Assertion.AssertEquals("i1", group[0].Include);
Assertion.AssertEquals(null, i2.ParentPersistedItemGroup);
}
