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)); } } }