public void ITaskItemParameter_EscapableNotEscapedMetadata()
{
IDictionary metadata = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
metadata.Add("a", "a1(b1");
metadata.Add("b", "c1)d1");
TaskParameter t = new TaskParameter(new TaskItem("foo", metadata));
Assert.Equal(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem2 foo = t.WrappedParameter as ITaskItem2;
Assert.NotNull(foo);
Assert.Equal("foo", foo.ItemSpec);
Assert.Equal("a1(b1", foo.GetMetadata("a"));
Assert.Equal("c1)d1", foo.GetMetadata("b"));
Assert.Equal("a1(b1", foo.GetMetadataValueEscaped("a"));
Assert.Equal("c1)d1", foo.GetMetadataValueEscaped("b"));
((ITranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem2 foo2 = t2.WrappedParameter as ITaskItem2;
Assert.NotNull(foo2);
Assert.Equal("foo", foo2.ItemSpec);
Assert.Equal("a1(b1", foo2.GetMetadata("a"));
Assert.Equal("c1)d1", foo2.GetMetadata("b"));
Assert.Equal("a1(b1", foo2.GetMetadataValueEscaped("a"));
Assert.Equal("c1)d1", foo2.GetMetadataValueEscaped("b"));
}
private static ProjectItemInstance.TaskItem CreateTaskItem(ITaskItem2 taskItemInterface)
{
var taskItem = new ProjectItemInstance.TaskItem(taskItemInterface.EvaluatedIncludeEscaped, null);
foreach (string metadataName in taskItemInterface.MetadataNames)
{
taskItem.SetMetadata(metadataName, taskItemInterface.GetMetadataValueEscaped(metadataName));
}
return(taskItem);
}
public MSBuildItemGroupAdditionalText(ITaskItem2 taskItem)
{
Path = taskItem.ItemSpec;
var metadata = new Dictionary <string, string>();
foreach (string name in taskItem.MetadataNames)
{
metadata.Add($"build_metadata.AdditionalFiles.{name}", taskItem.GetMetadata(name));
}
}
public void AddCredentialTaskItemIfExists(string userName, string password)
{
if (!string.IsNullOrEmpty(userName))
{
TaskItem credentialItem = new TaskItem(CredentailItemSpecName);
ITaskItem2 iTaskItem2 = (credentialItem as ITaskItem2);
iTaskItem2.SetMetadataValueLiteral(UserMetaDataName, userName);
iTaskItem2.SetMetadataValueLiteral(PasswordMetaDataName, password);
_items.Add(credentialItem);
}
}
/// <summary>
/// Creates a new ITaskItem with the contents of the old one.
/// </summary>
private ITaskItem CreateNewTaskItemFrom(ITaskItem copyFrom)
{
ITaskItem2 copyFromAsITaskItem2 = copyFrom as ITaskItem2;
string escapedItemSpec = null;
string escapedDefiningProject = null;
Dictionary <string, string> escapedMetadata = null;
if (copyFromAsITaskItem2 != null)
{
escapedItemSpec = copyFromAsITaskItem2.EvaluatedIncludeEscaped;
escapedDefiningProject = copyFromAsITaskItem2.GetMetadataValueEscaped(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath);
IDictionary nonGenericEscapedMetadata = copyFromAsITaskItem2.CloneCustomMetadataEscaped();
if (nonGenericEscapedMetadata is Dictionary <string, string> )
{
escapedMetadata = (Dictionary <string, string>)nonGenericEscapedMetadata;
}
else
{
escapedMetadata = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (object key in nonGenericEscapedMetadata.Keys)
{
escapedMetadata[(string)key] = (string)nonGenericEscapedMetadata[key] ?? String.Empty;
}
}
}
else
{
// If we don't have ITaskItem2 to fall back on, we have to make do with the fact that
// CloneCustomMetadata, GetMetadata, & ItemSpec returns unescaped values, and
// TaskParameterTaskItem's constructor expects escaped values, so escaping them all
// is the closest approximation to correct we can get.
escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec);
escapedDefiningProject = EscapingUtilities.EscapeWithCaching(copyFrom.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
IDictionary customMetadata = copyFrom.CloneCustomMetadata();
escapedMetadata = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (customMetadata != null && customMetadata.Count > 0)
{
foreach (string key in customMetadata.Keys)
{
escapedMetadata.Add(key, EscapingUtilities.Escape((string)customMetadata[key] ?? String.Empty));
}
}
}
TaskParameterTaskItem taskItem = new TaskParameterTaskItem(escapedItemSpec, escapedDefiningProject, escapedMetadata);
return(taskItem);
}
public TaskItem(ITaskItem sourceItem)
{
ErrorUtilities.VerifyThrowArgumentNull(sourceItem, "sourceItem");
ITaskItem2 item = sourceItem as ITaskItem2;
if (item == null)
{
this.itemSpec = sourceItem.ItemSpec;
}
else
{
this.itemSpec = item.EvaluatedIncludeEscaped;
}
sourceItem.CopyMetadataTo(this);
}
public void CopyMetadataTo(ITaskItem destinationItem)
{
ErrorUtilities.VerifyThrowArgumentNull(destinationItem, "destinationItem");
string metadata = destinationItem.GetMetadata("OriginalItemSpec");
ITaskItem2 item = destinationItem as ITaskItem2;
if (this.metadata != null)
{
TaskItem item2 = destinationItem as TaskItem;
if ((item2 != null) && (item2.metadata == null))
{
item2.metadata = this.metadata.Clone();
}
else
{
foreach (KeyValuePair <string, string> pair in this.metadata)
{
if (item != null)
{
if (string.IsNullOrEmpty(item.GetMetadataValueEscaped(pair.Key)))
{
item.SetMetadata(pair.Key, pair.Value);
}
}
else if (string.IsNullOrEmpty(destinationItem.GetMetadata(pair.Key)))
{
destinationItem.SetMetadata(pair.Key, EscapingUtilities.Escape(pair.Value));
}
}
}
}
if (string.IsNullOrEmpty(metadata))
{
if (item != null)
{
item.SetMetadata("OriginalItemSpec", ((ITaskItem2)this).EvaluatedIncludeEscaped);
}
else
{
destinationItem.SetMetadata("OriginalItemSpec", EscapingUtilities.Escape(this.ItemSpec));
}
}
}
public void ITaskItemParameter_EscapableNotEscapedItemSpec()
{
TaskParameter t = new TaskParameter(new TaskItem("foo;bar"));
Assert.Equal(TaskParameterType.ITaskItem, t.ParameterType);
ITaskItem2 foo = t.WrappedParameter as ITaskItem2;
Assert.NotNull(foo);
Assert.Equal("foo;bar", foo.ItemSpec);
Assert.Equal("foo;bar", foo.EvaluatedIncludeEscaped);
((ITranslatable)t).Translate(TranslationHelpers.GetWriteTranslator());
TaskParameter t2 = TaskParameter.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(TaskParameterType.ITaskItem, t2.ParameterType);
ITaskItem2 foo2 = t2.WrappedParameter as ITaskItem2;
Assert.NotNull(foo2);
Assert.Equal("foo;bar", foo2.ItemSpec);
Assert.Equal("foo;bar", foo2.EvaluatedIncludeEscaped);
}
/// <summary>
/// This constructor creates a new TaskItem, using the given ITaskItem.
/// </summary>
/// <param name="sourceItem">The item to copy.</param>
public TaskItem
(
ITaskItem sourceItem
)
{
ErrorUtilities.VerifyThrowArgumentNull(sourceItem, "sourceItem");
ITaskItem2 sourceItemAsITaskItem2 = sourceItem as ITaskItem2;
// Attempt to preserve escaped state
if (sourceItemAsITaskItem2 == null)
{
_itemSpec = EscapingUtilities.Escape(sourceItem.ItemSpec);
_definingProject = EscapingUtilities.EscapeWithCaching(sourceItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
}
else
{
_itemSpec = sourceItemAsITaskItem2.EvaluatedIncludeEscaped;
_definingProject = sourceItemAsITaskItem2.GetMetadataValueEscaped(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath);
}
sourceItem.CopyMetadataTo(this);
}
/// <summary>
/// If OutputFiles is null, we need to generate default output names
/// to pass to resgen.exe (which would generate the names on its own, but
/// then we wouldn't have access to them)
/// </summary>
private void GenerateOutputFileNames()
{
ErrorUtilities.VerifyThrow(!ResGen.IsNullOrEmpty(InputFiles), "If InputFiles is empty, the task should have returned before reaching this point");
ITaskItem[] inputFiles = InputFiles;
ITaskItem[] outputFiles = new ITaskItem[inputFiles.Length];
// Set the default OutputFiles values
for (int i = 0; i < inputFiles.Length; i++)
{
ITaskItem2 inputFileAsITaskItem2 = inputFiles[i] as ITaskItem2;
if (inputFileAsITaskItem2 != null)
{
outputFiles[i] = new TaskItem(Path.ChangeExtension(inputFileAsITaskItem2.EvaluatedIncludeEscaped, ".resources"));
}
else
{
outputFiles[i] = new TaskItem(Path.ChangeExtension(EscapingUtilities.Escape(inputFiles[i].ItemSpec), ".resources"));
}
}
Bag["OutputFiles"] = outputFiles;
}
/// <summary>
/// Write the given ITaskItem, using the given write translator
/// </summary>
private void WriteITaskItem(ITranslator translator, ITaskItem wrappedItem)
{
ErrorUtilities.VerifyThrow(translator.Mode == TranslationDirection.WriteToStream, "Cannot call this method when reading!");
if (!TranslateNullable(translator, wrappedItem))
{
return;
}
string escapedItemSpec;
string escapedDefiningProject;
IDictionary wrappedMetadata;
bool wrappedMetadataIsEscaped;
ITaskItem2 wrappedItemAsITaskItem2 = wrappedItem as ITaskItem2;
if (wrappedItemAsITaskItem2 != null)
{
escapedItemSpec = wrappedItemAsITaskItem2.EvaluatedIncludeEscaped;
escapedDefiningProject = wrappedItemAsITaskItem2.GetMetadataValueEscaped(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath);
wrappedMetadata = wrappedItemAsITaskItem2.CloneCustomMetadataEscaped();
wrappedMetadataIsEscaped = true;
}
else
{
// We know that the ITaskItem constructor expects an escaped string, and that ITaskItem.ItemSpec
// is expected to be unescaped, so make sure we give the constructor what it wants.
escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);
escapedDefiningProject = EscapingUtilities.EscapeWithCaching(wrappedItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
wrappedMetadata = wrappedItem.CloneCustomMetadata();
wrappedMetadataIsEscaped = false;
}
Dictionary <string, string> escapedGenericWrappedMetadata = wrappedMetadata as Dictionary <string, string>;
if (escapedGenericWrappedMetadata == null)
{
escapedGenericWrappedMetadata = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (object key in wrappedMetadata.Keys)
{
string value = (string)wrappedMetadata[key];
if (!wrappedMetadataIsEscaped)
{
value = (value == null) ? value : EscapingUtilities.Escape(value);
}
escapedGenericWrappedMetadata.Add((string)key, value);
}
}
else if (!wrappedMetadataIsEscaped)
{
foreach (KeyValuePair <string, string> entry in escapedGenericWrappedMetadata)
{
escapedGenericWrappedMetadata[entry.Key] = entry.Value == null ? entry.Value : EscapingUtilities.Escape(entry.Value);
}
}
translator.Translate(ref escapedItemSpec);
translator.Translate(ref escapedDefiningProject);
translator.TranslateDictionary(ref escapedGenericWrappedMetadata, StringComparer.OrdinalIgnoreCase);
}
public void ITaskItem2Operations()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectItemInstance item = projectInstance.AddItem("EscapedItem", "esca%20ped%3bitem");
item.SetMetadata("m", "m1");
item.SetMetadata("m;", "m%3b1");
ITaskItem2 taskItem = (ITaskItem2)item;
Assert.Equal(taskItem.EvaluatedIncludeEscaped, "esca%20ped%3bitem");
Assert.Equal(taskItem.ItemSpec, "esca ped;item");
Assert.Equal(taskItem.GetMetadata("m;"), "m;1");
Assert.Equal(taskItem.GetMetadataValueEscaped("m;"), "m%3b1");
Assert.Equal(taskItem.GetMetadataValueEscaped("m"), "m1");
Assert.Equal(taskItem.EvaluatedIncludeEscaped, "esca%20ped%3bitem");
Assert.Equal(taskItem.ItemSpec, "esca ped;item");
ITaskItem2 taskItem2 = new Microsoft.Build.Utilities.TaskItem(taskItem);
taskItem2.SetMetadataValueLiteral("m;", "m;2");
Assert.Equal(taskItem2.GetMetadataValueEscaped("m;"), "m%3b2");
Assert.Equal(taskItem2.GetMetadata("m;"), "m;2");
IDictionary <string, string> taskItem2Metadata = (IDictionary <string, string>)taskItem2.CloneCustomMetadata();
Assert.Equal(3, taskItem2Metadata.Count);
foreach (KeyValuePair <string, string> pair in taskItem2Metadata)
{
if (pair.Key.Equals("m"))
{
Assert.Equal("m1", pair.Value);
}
if (pair.Key.Equals("m;"))
{
Assert.Equal("m;2", pair.Value);
}
if (pair.Key.Equals("OriginalItemSpec"))
{
Assert.Equal("esca ped;item", pair.Value);
}
}
IDictionary <string, string> taskItem2MetadataEscaped = (IDictionary <string, string>)taskItem2.CloneCustomMetadataEscaped();
Assert.Equal(3, taskItem2MetadataEscaped.Count);
foreach (KeyValuePair <string, string> pair in taskItem2MetadataEscaped)
{
if (pair.Key.Equals("m"))
{
Assert.Equal("m1", pair.Value);
}
if (pair.Key.Equals("m;"))
{
Assert.Equal("m%3b2", pair.Value);
}
if (pair.Key.Equals("OriginalItemSpec"))
{
Assert.Equal("esca%20ped%3bitem", pair.Value);
}
}
}
/// <summary>
/// Copy the metadata (but not the ItemSpec) to destinationItem. If a particular metadata already exists on the
/// destination item, then it is not overwritten -- the original value wins.
/// </summary>
/// <param name="destinationItem">The item to copy metadata to.</param>
public void CopyMetadataTo
(
ITaskItem destinationItem
)
{
ErrorUtilities.VerifyThrowArgumentNull(destinationItem, "destinationItem");
// also copy the original item-spec under a "magic" metadata -- this is useful for tasks that forward metadata
// between items, and need to know the source item where the metadata came from
string originalItemSpec = destinationItem.GetMetadata("OriginalItemSpec");
ITaskItem2 destinationAsITaskItem2 = destinationItem as ITaskItem2;
if (_metadata != null)
{
TaskItem destinationAsTaskItem = destinationItem as TaskItem;
// Avoid a copy if we can
if (destinationAsTaskItem != null && destinationAsTaskItem.Metadata == null)
{
destinationAsTaskItem.Metadata = _metadata.Clone(); // Copy on write!
}
else
{
foreach (KeyValuePair <string, string> entry in _metadata)
{
string value;
if (destinationAsITaskItem2 != null)
{
value = destinationAsITaskItem2.GetMetadataValueEscaped(entry.Key);
if (String.IsNullOrEmpty(value))
{
destinationAsITaskItem2.SetMetadata(entry.Key, entry.Value);
}
}
else
{
value = destinationItem.GetMetadata(entry.Key);
if (String.IsNullOrEmpty(value))
{
destinationItem.SetMetadata(entry.Key, EscapingUtilities.Escape(entry.Value));
}
}
}
}
}
if (String.IsNullOrEmpty(originalItemSpec))
{
if (destinationAsITaskItem2 != null)
{
destinationAsITaskItem2.SetMetadata("OriginalItemSpec", ((ITaskItem2)this).EvaluatedIncludeEscaped);
}
else
{
destinationItem.SetMetadata("OriginalItemSpec", EscapingUtilities.Escape(ItemSpec));
}
}
}
