public virtual IRPResultNode EvaluateElement(IRPResultNode resultNode, IEnumerable <IRPElement> elements)
{
if (!elements.Any())
{
return(resultNode);
}
IRPElement element = elements.First();
if (!_rpElementRPResultNodeBuilderPairs.ContainsKey(element.GetType()))
{
throw new Exception($"{element.GetType()} does not have an associated RPResultNodeBuilder");
}
Type rpResultNodeBuilderType = _rpElementRPResultNodeBuilderPairs[element.GetType()];
if (rpResultNodeBuilderType.GetMethod("EvaluateElement").DeclaringType == typeof(RPResultNodeBuilder))
{
throw new Exception($"{rpResultNodeBuilderType} does not implement the EvaluateElement method.");
}
IRPResultNodeBuilder resultNodeBuilder = (IRPResultNodeBuilder)Activator.CreateInstance(rpResultNodeBuilderType);
return(resultNodeBuilder.EvaluateElement(resultNode, elements));
}
public override IRPResultNode EvaluateElement(IRPResultNode resultNode, IEnumerable <IRPElement> elements)
{
if (!(elements.First() is RPIndexElement indexElement))
{
throw new ArgumentException($"{elements.First()} is not an RPIndexElement.");
}
IEnumerable <SyntaxNode> searchPool;
switch (indexElement.ScanType)
{
case RPScanTypes.Children:
searchPool = resultNode.SyntaxNode.ChildNodes();
break;
case RPScanTypes.Descendants:
searchPool = resultNode.SyntaxNode.DescendantNodes();
break;
default:
throw new ArgumentException("Invalid scan type.");
}
SyntaxNode matchingNode = searchPool.ElementAtOrDefault(indexElement.Index);
if (matchingNode == null)
{
return(null);
}
resultNode.Children.Add(base.EvaluateElement(new RPResultNode(resultNode, matchingNode), elements.Skip(1)));
return(resultNode);
}
public override IRPResultNode EvaluateElement(IRPResultNode resultNode, IEnumerable <IRPElement> elements)
{
if (!(elements.First() is RPWildcardElement wildcardElement))
{
throw new ArgumentException($"{elements.First()} is not an RPWildcardElement.");
}
IEnumerable <SyntaxNode> searchPool;
switch (wildcardElement.ScanType)
{
case RPScanTypes.Children:
searchPool = resultNode.SyntaxNode.ChildNodes();
break;
case RPScanTypes.Descendants:
searchPool = resultNode.SyntaxNode.DescendantNodes();
break;
default:
throw new ArgumentException("Invalid scan type.");
}
if (searchPool.Count() == 0)
{
return(null);
}
foreach (SyntaxNode matchingNode in searchPool)
{
resultNode.Children.Add(base.EvaluateElement(new RPResultNode(resultNode, matchingNode), elements.Skip(1)));
}
return(resultNode);
}
public IEnumerable <SyntaxNode> Evaluate(SyntaxNode syntaxNode, IEnumerable <IRPElement> roslynPath)
{
IRPResultNode resultNode = _builder.EvaluateElement(new RPResultNode(null, syntaxNode), roslynPath);
_leaves = new List <IRPResultNode>();
PopulateLeavesRecursive(resultNode);
return(_leaves.Select(rn => rn.SyntaxNode));
}
public override IRPResultNode EvaluateElement(IRPResultNode resultNode, IEnumerable <IRPElement> elements)
{
if (!(elements.First() is RPSyntaxKindRegexPairElement syntaxKindRegexPairElement))
{
throw new ArgumentException($"{elements.First()} is not an RPSyntaxKindRegexPairElement.");
}
string parentText = resultNode.SyntaxNode.ToString();
IEnumerable <TextSpan> matchingTextSpans = syntaxKindRegexPairElement.Regex.Matches(parentText)
.Cast <Match>()
.Select(m => new TextSpan(m.Index + resultNode.SyntaxNode.SpanStart, m.Length));
if (matchingTextSpans.Count() == 0)
{
return(null);
}
bool anyMatches = false;
foreach (TextSpan matchingTextSpan in matchingTextSpans)
{
IEnumerable <SyntaxNode> searchPool;
switch (syntaxKindRegexPairElement.ScanType)
{
case RPScanTypes.Children:
searchPool = resultNode.SyntaxNode.ChildNodes();
break;
case RPScanTypes.Descendants:
searchPool = resultNode.SyntaxNode.DescendantNodes();
break;
default:
throw new ArgumentException("Invalid scan type.");
}
searchPool = searchPool.Where(sn => sn.IsKind(syntaxKindRegexPairElement.SyntaxKind));
SyntaxNode matchingNode = searchPool.Where(sn => sn.Span.OverlapsWith(matchingTextSpan))
.OrderBy(sn => (sn.Span, matchingTextSpan), _rpTextSpanComparer)
.FirstOrDefault();
if (matchingNode == null)
{
continue;
}
anyMatches = true;
resultNode.Children.Add(base.EvaluateElement(new RPResultNode(resultNode, matchingNode), elements.Skip(1)));
}
return(anyMatches ? resultNode : null);
}
private void PopulateLeavesRecursive(IRPResultNode resultNode)
{
if (resultNode == null || resultNode.SyntaxNode == null)
{
return;
}
if (!resultNode.Children.Any())
{
_leaves.Add(resultNode);
}
else
{
foreach (IRPResultNode childNode in resultNode.Children)
{
PopulateLeavesRecursive(childNode);
}
}
}
public override IRPResultNode EvaluateElement(IRPResultNode resultNode, IEnumerable <IRPElement> elements)
{
return(base.EvaluateElement(resultNode, elements.Skip(1)));
}
public RPResultNode(IRPResultNode parent, SyntaxNode syntaxNode)
{
Parent = parent;
SyntaxNode = syntaxNode;
}
