public bool IsSatisfied(IAnalyzableNode node)
{
node = node ?? throw new ArgumentNullException(nameof(node));
return(node.IsInvocationOfMemberOfTypeNamespaceContainingText(Log4NetRootNamespace) ||
node.IsInvocationOfMemberOfTypeNamespaceContainingText(NLogRootNamespace) ||
node.IsInvocationOfMemberOfTypeNamespaceContainingText(SerilogRootNamespace));
}
public bool IsSatisfied(IAnalyzableNode node)
{
var systemIoNamespace = typeof(System.IO.File).Namespace;
return(node.IsInvocationOfMemberOfTypeBelongingToNamespace(systemIoNamespace) ||
node.IsMemberAccessExpressionOfTypeBelongingToNamespace(systemIoNamespace));
}
public AridCheckResult GetResult(IAnalyzableNode syntaxNode)
{
if (!_results.ContainsKey(syntaxNode))
{
throw new InvalidOperationException($"No result exists for the {nameof(IAnalyzableNode)} provided.");
}
return(_results[syntaxNode]);
}
private AridCheckResult CheckSimpleNode(IAnalyzableNode node)
{
var filterPassing = _filters.FirstOrDefault(filter => filter.IsSatisfied(node));
return(filterPassing != null
? AridCheckResult.CreateForArid(filterPassing)
: AridCheckResult.CreateForNonArid());
}
public AridCheckResult Check(IAnalyzableNode node, IDictionary <IAnalyzableNode, AridCheckResult> results)
{
if (IsAnyParentArid(results, node, out var parentResult))
{
return(AridCheckResult.CreateForArid(parentResult.TriggeredBy));
}
return(node.IsCompoundNode ? CheckCompoundNode(node, results) : CheckSimpleNode(node));
}
public bool TryGetResult(IAnalyzableNode syntaxNode, out AridCheckResult result)
{
if (!_results.ContainsKey(syntaxNode))
{
result = null;
return(false);
}
result = _results[syntaxNode];
return(true);
}
public NodesClassification Classify(IAnalyzableNode root)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
var syntaxNodes = root.DescendantNodesAndSelf();
var results = new Dictionary <IAnalyzableNode, AridCheckResult>();
foreach (var node in syntaxNodes)
{
results[node] = Check(node, results);
}
return(new NodesClassification(results));
}
private AridCheckResult CheckCompoundNode(IAnalyzableNode node, IDictionary <IAnalyzableNode, AridCheckResult> results)
{
var filtersTriggered = new List <IAridNodeFilter>();
var childNodes = node.ChildNodes();
foreach (var childNode in childNodes)
{
var check = Check(childNode, results);
if (!check.IsArid)
{
return(check);
}
filtersTriggered.AddRange(check.TriggeredBy);
}
return(AridCheckResult.CreateForArid(filtersTriggered.ToArray()));
}
private static void WriteClassificationToConsole(
IAnalyzableNode @class,
NodesClassification classification,
IChalk chalk)
{
foreach (var node in @class.DescendantNodesAndSelf())
{
var result = classification.GetResult(node);
if (result.IsArid)
{
chalk.Magenta($"ARID {node.Kind()}");
}
else
{
chalk.Green($"NON-ARID {node.Kind()}");
}
chalk.Default(node.GetText());
chalk.Default(Environment.NewLine + Environment.NewLine);
}
}
public bool IsSatisfied(IAnalyzableNode node)
{
switch (node.SyntaxType)
{
case AnalyzableNodeSyntaxType.BinaryExpressionSyntax:
case AnalyzableNodeSyntaxType.AssignmentExpressionSyntax:
case AnalyzableNodeSyntaxType.LiteralExpressionSyntax:
case AnalyzableNodeSyntaxType.CheckedExpressionSyntax:
case AnalyzableNodeSyntaxType.InterpolatedStringExpressionSyntax:
case AnalyzableNodeSyntaxType.InvocationExpressionSyntax:
case AnalyzableNodeSyntaxType.ConditionalExpressionSyntax:
case AnalyzableNodeSyntaxType.PostfixUnaryExpressionSyntax:
case AnalyzableNodeSyntaxType.PrefixUnaryExpressionSyntax:
case AnalyzableNodeSyntaxType.MemberAccessExpressionSyntax:
case AnalyzableNodeSyntaxType.BlockSyntax:
case AnalyzableNodeSyntaxType.StatementSyntax:
return(false);
default:
return(true);
}
}
public bool IsSatisfied(IAnalyzableNode simpleNode)
{
return(simpleNode.IsInvocationOfMemberOfType(typeof(Console)) ||
simpleNode.IsMemberAccessExpressionOfType(typeof(Console)));
}
private static bool TryGetResult(IDictionary <IAnalyzableNode, AridCheckResult> results, IAnalyzableNode syntaxNode, out AridCheckResult result)
{
if (!results.ContainsKey(syntaxNode))
{
result = null;
return(false);
}
result = results[syntaxNode];
return(true);
}
private static bool IsAnyParentArid(IDictionary <IAnalyzableNode, AridCheckResult> results, IAnalyzableNode node, out AridCheckResult parentResult)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
var parent = node.Parent;
while (parent != null &&
parent.SyntaxType != AnalyzableNodeSyntaxType.StatementSyntax &&
parent.SyntaxType != AnalyzableNodeSyntaxType.MethodDeclarationSyntax &&
parent.SyntaxType != AnalyzableNodeSyntaxType.PropertyDeclarationSyntax)
{
if (TryGetResult(results, parent, out var result) && result.IsArid)
{
parentResult = result;
return(true);
}
parent = parent.Parent;
}
parentResult = null;
return(false);
}
