public TwoFerSolution(ParsedSolution solution) : base(solution.Solution, solution.SyntaxRoot)
{
TwoFerClass = solution.SyntaxRoot.GetClass("TwoFer");
SpeakMethod = TwoFerClass.GetMethod("Speak");
InputParameter = SpeakMethod?.ParameterList.Parameters.FirstOrDefault();
ReturnedExpression = SpeakMethod?.ReturnedExpression();
Variable = SpeakMethod?.AssignedVariable();
}
private static bool WritesToConsole(this ParsedSolution parsedSolution) =>
parsedSolution.SyntaxRoot.InvokesMethod(
SimpleMemberAccessExpression(
IdentifierName("Console"),
IdentifierName("WriteLine"))) ||
parsedSolution.SyntaxRoot.InvokesMethod(
SimpleMemberAccessExpression(
IdentifierName("Console"),
IdentifierName("Write")));
public static TwoFerSolution Parse(ParsedSolution solution)
{
var twoFerClass = solution.SyntaxRoot.GetClass("TwoFer");
var speakMethod = twoFerClass.GetMethod("Speak");
var speakMethodParameter = speakMethod?.ParameterList.Parameters.FirstOrDefault();
var speakMethodReturnedExpression = speakMethod?.ReturnedExpression();
var speakMethodVariable = speakMethod?.AssignedVariable();
var twoFerError = ToTwoFerError(twoFerClass, speakMethod, speakMethodParameter);
return(new TwoFerSolution(solution, twoFerClass, speakMethod, speakMethodParameter, speakMethodReturnedExpression, speakMethodVariable, twoFerError));
}
static void Main(string[] args)
{
ResultsDirectory = Path.Combine(Directory.GetCurrentDirectory(), DateTime.Now.ToString("yyyy_MM_dd - HH_mm_ss"));
Directory.CreateDirectory(ResultsDirectory);
log4net.GlobalContext.Properties["LogName"] = Path.Combine(ResultsDirectory, "Maggot.log");
_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
StartTime = DateTime.Now;
if (args.Length != 1)
{
Console.WriteLine("Syntax is 'maggot <solution_to_process>'.");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
return;
}
InputSolutionFile = args[0];
if (!File.Exists(InputSolutionFile))
{
Console.WriteLine("Specified solution file does not exist.");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
return;
}
_log.Info("Beginning analysis of " + InputSolutionFile);
ParseSolution();
_log.Info("=============================");
_log.Info("Projects: " + ParsedSolution.Count);
_log.Info("Implementation Files: " + ParsedSolution.SelectMany(x => x.Value).Count());
_log.Info("=============================");
_log.Info("Beginning debridement");
var projectCounter = 1;
foreach (var project in ParsedSolution)
{
_log.Info("-----------------------------");
ProcessProject(project.Key, project.Value, projectCounter);
projectCounter++;
}
_log.Info("-----------------------------");
_log.Info("Debridement complete!");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public TwoFerSolution(ParsedSolution solution,
ClassDeclarationSyntax twoFerClass,
MethodDeclarationSyntax speakMethod,
ParameterSyntax speakMethodParameter,
ExpressionSyntax twoFerExpression,
VariableDeclaratorSyntax twoFerVariableDeclarator,
TwoFerError twoFerError) : base(solution.Solution, solution.SyntaxRoot)
{
_twoFerError = twoFerError;
TwoFerClass = twoFerClass;
SpeakMethod = speakMethod;
InputMethodParameter = speakMethodParameter;
TwoFerExpression = twoFerExpression;
TwoFerVariable = twoFerVariableDeclarator;
}
public GigasecondSolution(ParsedSolution solution,
MethodDeclarationSyntax addMethod,
ReturnType addMethodReturnType,
InvocationExpressionSyntax addSecondsInvocationExpression,
LocalDeclarationStatementSyntax addSecondsLocalArgument,
FieldDeclarationSyntax addSecondsFieldArgument,
ArgumentType addSecondsArgumentType,
GigasecondValueType gigasecondValueType) : base(solution.Solution, solution.SyntaxRoot)
{
_addMethod = addMethod;
_addSecondsInvocationExpression = addSecondsInvocationExpression;
_addSecondsLocalArgument = addSecondsLocalArgument;
_addSecondsFieldArgument = addSecondsFieldArgument;
_addSecondsArgumentType = addSecondsArgumentType;
_gigasecondValueType = gigasecondValueType;
_addMethodReturnType = addMethodReturnType;
}
public static GigasecondSolution Parse(ParsedSolution solution)
{
var gigasecondClass = solution.GigasecondClass();
var addMethod = gigasecondClass.AddMethod();
var addMethodParameter = addMethod.FirstParameter();
var addMethodReturnedExpression = addMethod.ReturnedExpression();
var addSecondsInvocationExpression = addMethod.AddSecondsInvocationExpression(addMethodParameter);
var addSecondsArgumentExpression = addSecondsInvocationExpression.FirstArgumentExpression();
var addSecondsArgumentVariable = gigasecondClass.ArgumentVariable(addSecondsArgumentExpression);
var addSecondsArgumentVariableFieldDeclaration = addSecondsArgumentVariable.FieldDeclaration();
var addSecondsArgumentVariableLocalDeclarationStatement = addSecondsArgumentVariable.LocalDeclarationStatement();
var addSecondsArgumentType = ArgumentDefinedAs(addSecondsArgumentVariableFieldDeclaration, addSecondsArgumentVariableLocalDeclarationStatement, addSecondsArgumentExpression);
var addSecondsArgumentValueExpression = ArgumentValueExpression(addSecondsArgumentType, addSecondsArgumentExpression, addSecondsArgumentVariable);
var addMethodReturnType = ReturnedAs(addSecondsInvocationExpression, addMethodReturnedExpression, addMethodParameter);
var addSecondsArgumentValueType = addSecondsArgumentValueExpression.GigasecondValueType();
return(new GigasecondSolution(solution, addMethod, addMethodReturnType, addSecondsInvocationExpression, addSecondsArgumentVariableLocalDeclarationStatement, addSecondsArgumentVariableFieldDeclaration, addSecondsArgumentType, addSecondsArgumentValueType));
}
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution)
{
if (parsedSolution.HasCompileErrors())
{
return(parsedSolution.DisapproveWithComment(SharedComments.FixCompileErrors));
}
if (parsedSolution.HasMainMethod())
{
return(parsedSolution.DisapproveWithComment(SharedComments.RemoveMainMethod));
}
if (parsedSolution.ThrowsNotImplementedException())
{
return(parsedSolution.DisapproveWithComment(SharedComments.RemoveThrowNotImplementedException));
}
if (parsedSolution.WritesToConsole())
{
return(parsedSolution.DisapproveWithComment(SharedComments.DontWriteToConsole));
}
return(null);
}
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => Analyze(GigasecondSolutionParser.Parse(parsedSolution));
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => Analyze(new TwoFerSolution(parsedSolution));
public LeapSolution(ParsedSolution solution) : base(solution.Solution, solution.SyntaxRoot)
{
IsLeapYearMethod = solution.SyntaxRoot.GetClassMethod("Leap", "IsLeapYear");
YearParameter = IsLeapYearMethod.ParameterList?.Parameters.FirstOrDefault();
ReturnedExpression = IsLeapYearMethod?.ReturnedExpression();
}
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => Analyze(new GigasecondSolution(parsedSolution));
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => Analyze(new LeapSolution(parsedSolution));
private static ClassDeclarationSyntax GigasecondClass(this ParsedSolution solution) =>
solution.SyntaxRoot.GetClass("Gigasecond");
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => parsedSolution.ReferToMentor();
public static SolutionAnalysis Analyze(ParsedSolution parsedSolution) => Analyze(TwoFerSolutionParser.Parse(parsedSolution));
private static bool ThrowsNotImplementedException(this ParsedSolution parsedSolution) => parsedSolution.SyntaxRoot.ThrowsExceptionOfType <NotImplementedException>();
private static bool HasMainMethod(this ParsedSolution parsedSolution) =>
parsedSolution.SyntaxRoot.GetClassMethod("Program", "Main") != null;
private static bool HasCompileErrors(this ParsedSolution parsedSolution) => parsedSolution.SyntaxRoot.GetDiagnostics().Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
public GigasecondSolution(ParsedSolution solution) : base(solution.Solution, solution.SyntaxRoot)
{
AddMethod = solution.SyntaxRoot.GetClassMethod("Gigasecond", "Add");
BirthDateParameter = AddMethod?.ParameterList.Parameters.FirstOrDefault();
ReturnedExpression = AddMethod?.ReturnedExpression();
}
