public CodeCheckTest()
{
_codeCheckService = GetRequiredService <ICodeCheckService>();
_codeCheckOptions = GetRequiredService <IOptionsMonitor <CodeCheckOptions> >().CurrentValue;
_contractAuditorContainer = GetRequiredService <IContractAuditorContainer>();
_requiredAcsProvider = GetRequiredService <IRequiredAcsProvider>();
}
public static StringBuilder Check(string sourceCode, CodeCheckOptions options)
{
StringBuilder sb = new StringBuilder();
var limit = options.VariableCount;
SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode);
//The recommended value is 64;
//But for demonstration purpose it is changed to 4
//const int MAX_LOCALS_ALLOWED = 4; // 2
var results = tree.GetRoot().DescendantNodes()
.OfType <MethodDeclarationSyntax>() // 3
.Where(mds =>
mds.Body.Statements
.OfType <LocalDeclarationStatementSyntax>()
.Count() >= limit) // 4
.Select(mds => mds.Identifier.ValueText); // 5
foreach (var item in results)
{
sb.AppendLine($" {item}");
}
return(sb);
}
public CodeCheckService(ISmartContractRequiredAcsService smartContractRequiredAcsService,
IContractAuditorContainer contractAuditorContainer,
IOptionsMonitor <CodeCheckOptions> codeCheckOptionsMonitor)
{
_smartContractRequiredAcsService = smartContractRequiredAcsService;
_contractAuditorContainer = contractAuditorContainer;
_codeCheckOptions = codeCheckOptionsMonitor.CurrentValue;
}
public CodeCheckService(IRequiredAcsProvider requiredAcsProvider,
IContractAuditorContainer contractAuditorContainer,
IOptionsMonitor <CodeCheckOptions> codeCheckOptionsMonitor)
{
_requiredAcsProvider = requiredAcsProvider;
_contractAuditorContainer = contractAuditorContainer;
_codeCheckOptions = codeCheckOptionsMonitor.CurrentValue;
}
public static StringBuilder Check(string sourceCode, CodeCheckOptions options)
{
StringBuilder sb = new StringBuilder();
SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode);
// TODO(crhodes)
// Look at Long Parameter List. Is it useful to have class??
List <MethodDeclarationSyntax> methods = tree.GetRoot().DescendantNodes()
.Where(d => d.Kind() == SyntaxKind.MethodDeclaration)
.Cast <MethodDeclarationSyntax>()
.ToList();//1
if (methods.Count() > 0)
{
var results = methods.Select(z =>
new
{
MethodName = z.Identifier.ValueText, // 2
NBLocal = z.Body.Statements
.Count(x => x.Kind() == SyntaxKind.LocalDeclarationStatement) // 3
})
.OrderByDescending(x => x.NBLocal)
.ToList();
var limit = options.VariableCount;
foreach (var item in results)
{
if (item.NBLocal > limit)
{
sb.AppendLine($"Has Lots (> {limit}) of Local Variables");
sb.AppendLine($" Method: {item.MethodName, -20} Variables: {item.NBLocal, 2}");
}
}
}
return(sb);
}
public static StringBuilder Check(string sourceCode, CodeCheckOptions options)
{
StringBuilder sb = new StringBuilder();
var tree = CSharpSyntaxTree.ParseText(sourceCode);
var results = tree.GetRoot().DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.Select(cds =>
new
{
ClassName = cds.Identifier.ValueText, // 1
Methods = cds.Members.OfType <MethodDeclarationSyntax>()
.Select(mds => new
{
MethodName = mds.Identifier.ValueText, // 2
Parameters = mds.ParameterList.Parameters.Count // 3
})
});
var limit = options.ParameterCount;
if (results.Count() > 0)
{
foreach (var item in results)
{
foreach (var method in item.Methods)
{
if (method.Parameters > limit)
{
sb.AppendLine($"Has Long (> {limit}) Parameter List");
sb.AppendLine($" Class: {item.ClassName, -20} Method: {method.MethodName, -20} Parameters: {method.Parameters,2}");
}
}
}
}
return(sb);
}
public InitialSyncFinishedEventHandler(IOptionsMonitor <CodeCheckOptions> codeCheckOptionsMonitor)
{
_codeCheckOptions = codeCheckOptionsMonitor.CurrentValue;
}
public static StringBuilder Check(string sourceCode, CodeCheckOptions options)
{
StringBuilder sb = new StringBuilder();
SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode);
var classes = tree.GetRoot().DescendantNodes()
.Where(d => d.Kind() == SyntaxKind.ClassDeclaration)
.Cast <ClassDeclarationSyntax>();
var classes2 = tree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>();
sb.AppendLine("--------------------------------------------------------------------------------");
sb.AppendLine($"classes {classes.Count()}");
sb.AppendLine("--------------------------------------------------------------------------------");
foreach (var item in classes)
{
sb.AppendLine($" {item.Identifier.ValueText}");
}
sb.AppendLine("================================================================================");
sb.AppendLine($"classes2 {classes2.Count()}");
sb.AppendLine("================================================================================");
foreach (var item in classes2)
{
sb.AppendLine($" {item.Identifier.ValueText}");
}
//var foo = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>()
// .Select(mds => mds.ChildNodes().OfType<FieldDeclarationSyntax>());
//var foo2 = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>()
// .Select(mds => mds.ChildNodes().OfType<FieldDeclarationSyntax>()
// .Select (fds =>
// new
// {
// AAA = fds.GetFirstToken().ValueText,
// BBB = fds.Kind()
// })
// );
//sb.AppendLine("foo");
//foreach (var item in foo)
//{
// sb.AppendLine($"item: {item} Type: {item.GetType()}");
// foreach (var itemitem in item)
// {
// sb.AppendLine($" itemitem: {itemitem} Type: {itemitem.GetType()} Kind: {itemitem.Kind()}");
// }
//}
//sb.AppendLine($"{foo2}");
//foreach (var item in foo2)
//{
// sb.AppendLine($"{item} Type: {item.GetType()}");
//}
//if (classes.Count() > 0)
//{
// var results = classes.DescendantNo.Select(z =>
// new
// {
// ClassName = z.Identifier.ValueText, // 2
// NBLocal = z.St.Statements
// .Count(x => x.Kind() == SyntaxKind.LocalDeclarationStatement) // 3
// })
// .OrderByDescending(x => x.NBLocal)
// .ToList();
// var limit = options.VariableCount;
// foreach (var item in results)
// {
// if (item.NBLocal > limit)
// {
// sb.AppendLine($"Has Lots (> {limit}) of Local Variables");
// sb.AppendLine($" Method: {item.MethodName, -20} Variables: {item.NBLocal, 2}");
// }
// }
//}
return(sb);
}
