public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
switch (c.Type)
{
case SpecialElement:
{
if (c.Children.Count == 1)
{
node.Name = c.Children[0]?.Content?.Trim();
}
break;
}
case "flatlistofchildren":
{
for (var index = 0; index < c.Children.Count; index++)
{
var child = c.Children[index];
c.Children[index] = child.ToTerminalNode();
}
break;
}
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
switch (node.Type)
{
case MacroElement:
{
FinalAdjustMacroElement(c);
break;
}
case NameElement:
{
FinalAdjustNameElement(c);
break;
}
case StepElement:
{
FinalAdjustStepElement(c);
break;
}
}
// do not report the attributes for the moment as that causes structural issues in SemanticMerge/GMaster (due to gaps between the attributes)
c.Children.RemoveAll(_ => _.Type == NodeType.Attribute);
}
return(base.FinalAdjustAfterParsingComplete(node));
}
private static void AdjustQuery(ContainerOrTerminalNode node, Container container)
{
// try to find out CDATA section to get the name
var cdata = container.Children.FirstOrDefault(_ => _.Type == NodeType.CDATA)?.Content;
if (!string.IsNullOrWhiteSpace(cdata))
{
// we might have a normal query
if (TryGetQueryNameFromCData(cdata, out var queryName))
{
node.Name = queryName;
}
// we might have a trend metric
if (TryGetNameFromCData(cdata, TrendMetric, out var trendMetricName))
{
node.Name = trendMetricName;
node.Type = TrendMetric;
}
// we might have a quality gate
if (TryGetNameFromCData(cdata, QualityGate, out var qualityGateName))
{
node.Name = qualityGateName;
node.Type = QualityGate;
}
}
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
switch (node.Type)
{
case Query:
AdjustQuery(node, c);
break;
default:
{
var textNode = c.Children.FirstOrDefault(_ => _.Type == NodeType.Text);
if (textNode != null)
{
c.Name = $"{c.Name}=\"{textNode.Content}\"";
}
break;
}
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
private static T Assert <T>(string name, ContainerOrTerminalNode node, LineInfo start, LineInfo end, CharacterSpan totalSpan) where T : ContainerOrTerminalNode
{
NUnitAssert.That(node.LocationSpan.Start, Is.EqualTo(start), name + " start wrong");
NUnitAssert.That(node.LocationSpan.End, Is.EqualTo(end), name + " end wrong");
NUnitAssert.That(node.GetTotalSpan(), Is.EqualTo(totalSpan), name + " span wrong");
return((T)node);
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c && c.Children.Count == 1 && c.Type == SpecialElement)
{
node.Name = c.Children[0]?.Content?.Trim();
}
return(base.FinalAdjustAfterParsingComplete(node));
}
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node)
{
var nodeType = node?.Type;
if (nodeType is null)
{
return(false);
}
return(TerminalNodeNames.Contains(nodeType) || UtilTerminalNodeNames.Contains(nodeType));
}
private static void Adjust(TerminalNode comment, ContainerOrTerminalNode nodeToAdjust)
{
AdjustLocationSpan(comment, nodeToAdjust);
if (nodeToAdjust is TerminalNode t)
{
AdjustSpan(comment, t);
}
else if (nodeToAdjust is Container c)
{
AdjustSpan(comment, c);
}
}
private static void AdjustLocationSpan(TerminalNode comment, ContainerOrTerminalNode nodeToAdjust)
{
var commentStart = comment.LocationSpan.Start;
var commentEnd = comment.LocationSpan.End;
var nodeStart = nodeToAdjust.LocationSpan.Start;
var nodeEnd = nodeToAdjust.LocationSpan.End;
var start = nodeStart < commentStart ? nodeStart : commentStart;
var end = nodeEnd < commentEnd ? commentEnd : nodeEnd;
nodeToAdjust.LocationSpan = new LocationSpan(start, end);
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
var textNode = c.Children.FirstOrDefault(_ => _.Type == NodeType.Text);
if (textNode != null)
{
c.Name = textNode.Content;
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c && c.Type == DependentAssembly)
{
var identity = c.Children.FirstOrDefault(_ => _.Type == AssemblyIdentity);
if (identity != null)
{
c.Name = identity.Name;
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node)
{
switch (node.Type)
{
case "SolutionConfiguration":
case "Settings":
case "HotSpotsExclusionList":
case "MetricsExclusionList":
return(false);
default:
return(true);
}
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c && c.Type == Assembly)
{
var name = c.Children.FirstOrDefault(_ => _.Name == "name");
if (name != null)
{
c.Children.RemoveAll(_ => _.Name == "name");
c.Name = name.Content;
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
private static int CompareStartPosition(ContainerOrTerminalNode x, ContainerOrTerminalNode y)
{
var startX = x.LocationSpan.Start;
var startY = y.LocationSpan.Start;
var result = startX.LineNumber - startY.LineNumber;
if (result == 0)
{
result = startX.LinePosition - startY.LinePosition;
}
return(result);
}
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node)
{
var type = node?.Type ?? string.Empty;
foreach (var name in NonTerminalNodeNames)
{
if (IsNonTerminalNodeName(type, name))
{
return(false);
}
}
// SHFB filters should only be adjusted for namespace
if (IsNonTerminalNodeName(type, SHFB.ElementNames.Filter))
{
return(!type.Contains(SHFB.Filter_EntryType_Namespace));
}
return(true);
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
switch (c.Type)
{
case ElementNames.Id:
// side effect: set content here to be able to get it for MetaData as well
node.Content = c.Children.FirstOrDefault(_ => _.Type == NodeType.Text)?.Content.Trim();
// ID shall be a terminal node
return(node.ToTerminalNode());
case ElementNames.Metadata:
node.Name = c.Children.FirstOrDefault(_ => _.Type == ElementNames.Id)?.Content.Trim();
break;
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
// get all attributes here as they get vanished in the next line
var attributes = c.Children.Where(_ => _.Type == NodeType.Attribute).OfType <TerminalNode>().ToList();
c.Children.RemoveAll(TypeCanBeIgnored);
var content = c.Children.FirstOrDefault(_ => _.Type == NodeType.Text)?.Content;
if (content != null)
{
FinalAdjustNodeWithContent(c, attributes, content);
}
else
{
FinalAdjustNodeWithoutContent(c, attributes);
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node)
{
if (node is null)
{
return(false);
}
var nodeType = node.Type;
if (TerminalNodeNames.Contains(nodeType))
{
return(true);
}
if (nodeType.EndsWith(ElementNames.Converter))
{
// even unknown converters shall be terminal nodes
return(true);
}
return(false);
}
public override ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
if (node is Container c)
{
switch (node.Type)
{
case Component:
{
var child = c.Children.FirstOrDefault(_ => _.Type == File) ?? c.Children.FirstOrDefault(_ => _.Type == Shortcut);
if (child != null)
{
c.Name = child.Name;
}
break;
}
case Fragment:
{
var child = c.Children.FirstOrDefault(_ => _.Type == ComponentGroup) ?? c.Children.FirstOrDefault(_ => _.Type == Component);
if (child == null && c.Children.Count == 1)
{
child = c.Children.First();
}
if (child != null)
{
c.Name = Fragment + $" '{child.Name}'";
}
break;
}
}
}
return(base.FinalAdjustAfterParsingComplete(node));
}
private static bool IsNoAttribute(ContainerOrTerminalNode node) => node.Type != NodeType.Attribute;
private static bool TypeCanBeIgnored(ContainerOrTerminalNode node)
{
var type = node?.Type;
return(type == NodeType.Comment || type == NodeType.Attribute);
}
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node) => TerminalNodeNames.Contains(node?.Type);
public virtual ContainerOrTerminalNode FinalAdjustAfterParsingComplete(ContainerOrTerminalNode node)
{
return(ShallBeTerminalNode(node)
? node.ToTerminalNode()
: node);
}
protected virtual bool ShallBeTerminalNode(ContainerOrTerminalNode node) => false;
protected override bool ShallBeTerminalNode(ContainerOrTerminalNode node) => node?.Type == "package";
