using System;
|
using System.IO;
|
using System.Linq;
|
using System.Xml.Linq;
|
|
namespace OpenTap.Package
|
{
|
/// <summary>
|
/// The <see cref="PackageXmlPreprocessor"/> class can expand variables of the form $(VarName) -> VarNameValue
|
/// in an XML document. It reads the current environment variables, and optionally document-local variables set in
|
/// a <Variables/> element as a child of the root element. A variable will be expanded exactly once either if it is
|
/// an XMLText element, or if it appears as text in an attribute.
|
/// (e.g. <SomeElement Attr1="$(abc)">abc $(def) ghi</SomeElement> will expand $(abc) and $(def))
|
/// A variable will only be expanded once. If $(abc) -> "$(def)", then the expansion of $(abc) will not be expanded.
|
/// Additionally, 'Conditions' are supported. Conditions are attributes on elements. If the condition evaluates to
|
/// false, the element containing the condition is removed from the document. If the condition is true, the
|
/// condition itself is removed. A condition takes the form Condition="$(abc)" or Condition="$(abc) == $(def)" or
|
/// Condition="$(abc) != $(def)". A condition is true if it has the value '1' or 'true', or if the comparison operator evaluates to true.
|
/// </summary>
|
internal class PackageXmlPreprocessor
|
{
|
/// <summary>
|
/// Initializes a new instance of <see cref="PackageXmlPreprocessor"/> from an <see cref="XElement"/> object.
|
/// </summary>
|
/// <param name="root"></param>
|
/// <param name="projectPath"></param>
|
public PackageXmlPreprocessor(XElement root, string projectPath = null)
|
{
|
// Create a deep copy of the source element
|
Root = new XElement(root);
|
InitExpander(projectPath);
|
}
|
|
/// <summary>
|
/// Initializes a new instance of <see cref="PackageXmlPreprocessor"/> from a file path.
|
/// </summary>
|
/// <param name="path"></param>
|
/// <param name="projectPath"></param>
|
public PackageXmlPreprocessor(string path, string projectPath = null)
|
{
|
if (File.Exists(path) == false) throw new FileNotFoundException($"The file '{path}' does not exist.");
|
try
|
{
|
Root = XElement.Load(path, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
|
}
|
catch (Exception)
|
{
|
log.Debug($"Error loading XML Document from file '{path}'.");
|
throw;
|
}
|
InitExpander(projectPath);
|
}
|
|
private readonly DefaultVariableExpander _defaultExpander = new DefaultVariableExpander();
|
private void InitExpander(string projectPath = null)
|
{
|
// The project directory is required to compute the gitversion. If it is not set, GitVersion will not be computed.
|
Expander.AddProvider(new GitVersionExpander(projectPath));
|
Expander.AddProvider(_defaultExpander);
|
Expander.AddProvider(new EnvironmentVariableExpander());
|
Expander.AddProvider(new ConditionExpander());
|
|
|
// Evaluate all '<PropertyGroup/> elements and remove them from the document
|
var variables = Root.Elements(Root.GetDefaultNamespace().GetName("Variables")).ToArray();
|
|
var variableExpander = new VariableExpander(Expander);
|
Expander.AddProvider(variableExpander);
|
variableExpander.InitVariables(variables);
|
|
foreach (var propElem in variables)
|
{
|
// The property could have been removed due to a Condition.
|
if (propElem.Parent != null)
|
propElem.Remove();
|
}
|
}
|
|
private ElementExpander Expander { get; } = new ElementExpander();
|
|
/// <summary>
|
/// Evaluate all variables of the form $(VarName) -> VarNameValue in the <see cref="Root"/> document.
|
/// Evaluate all Conditions of the form 'Condition="Some-Condition-Expression"'
|
/// Removes the node which contains the condition if it evaluates to false. Otherwise it removes the condition itself.
|
/// </summary>
|
public XElement Evaluate()
|
{
|
ExpandNodeRecursive(Root);
|
|
// OpenTAP only supports a single <Files/>, <Dependencies/> and <PackageActionExtensions/> element,
|
// but with conditions it makes sense to specify these elements multiple times with different conditions.
|
// Their children should be merged in a single parent element so the XML is still valid according to the schema.
|
MergeDuplicateElements(Root);
|
|
if (_defaultExpander.UndefinedVariables.Any())
|
throw new Exception(
|
$"The following required variables are not defined: {string.Join(", ", _defaultExpander.UndefinedVariables)}");
|
|
return Root;
|
}
|
|
static TraceSource log = Log.CreateSource(nameof(PackageXmlPreprocessor));
|
XElement Root { get; }
|
|
/// <summary>
|
/// Merge all top-level elements in <see cref="XElement"/> elem by adding all of the children of duplicate elements to
|
/// the first element
|
/// </summary>
|
/// <param name="elem"></param>
|
static void MergeDuplicateElements(XElement elem)
|
{
|
var remaining = elem.Elements().GroupBy(e => e.Name.LocalName);
|
foreach (var rem in remaining)
|
{
|
var main = rem.First();
|
var rest = rem.Skip(1).ToArray();
|
|
foreach (var dup in rest)
|
{
|
foreach (var child in dup.Elements().ToArray())
|
{
|
main.Add(new XElement(child));
|
}
|
dup.Remove();
|
}
|
}
|
}
|
|
/// <summary>
|
/// Recursively expand the children of ele until a terminal node is reached.
|
/// </summary>
|
/// <param name="ele"></param>
|
void ExpandNodeRecursive(XElement ele)
|
{
|
Expander.ExpandElement(ele);
|
foreach (var desc in ele.Elements().ToArray())
|
{
|
ExpandNodeRecursive(desc);
|
}
|
}
|
}
|
}
|
