public SnapshotGeneratorObj(SubmissionData data, DevAssignment assignment, SnapshotGenerator parent)
{
Data = data;
Assignment = assignment;
Parent = parent;
LastSnapshot = GetLastSnapshotOrDefault(data, assignment);
}
private void LogException(Exception exception, DevAssignment assignment)
{
Logger.Log($"Class: '{assignment.CourseClass.Name}'\r\n" +
$"Assignment: '{assignment.Name}'\r\n" +
$"Timestamp: {DateTime.Now}\r\n" +
$"Engine Message - \r\n{exception.Message}\r\n");
}
public IList <IList <double> > DistanceMatrix(IList <Snapshot> snapshots, MarkovModelOptions options,
DirectoryHandler handler, DevAssignment assignment)
{
var distances = CreateSquareMatrix(snapshots.Count);
for (var row = 0; row < snapshots.Count; ++row)
{
var left = snapshots[row];
var leftRoot = CreateOrDefualtAbstractSyntaxTreeNode(left, handler, assignment);
for (var col = row + 1; col < snapshots.Count; ++col)
{
var distance = 0.0;
var right = snapshots[col];
distance += CalculateBuildDistance(left, right, options);
distance += CalculateTestDistance(left, right, options, assignment);
var rightRoot = CreateOrDefualtAbstractSyntaxTreeNode(right, handler, assignment);
distance += CalculateMetricDistance(leftRoot, rightRoot, assignment, options);
distances[row][col] = distance;
distances[col][row] = distance;
}
}
return(distances);
}
public async Task <IList <Snapshot> > Generate(SubmissionData data, DevAssignment assignment)
{
var newSnapshots = new List <Snapshot>();
var generateObj = new SnapshotGeneratorObj(data, assignment, this);
var solutionNode = GetSolutionAbstractSyntaxTreeNode(data, assignment);
foreach (var snapshotName in generateObj.SnapshotNames())
{
if (generateObj.IsNewSnapshot(snapshotName))
{
var snapshotSubmission = await generateObj.AddSubmissionToStudentSubmission(snapshotName);
var snapshot = new Snapshot()
{
StudentId = generateObj.Data.Student.Id,
AssignmentId = generateObj.Assignment.Id,
SnapshotSubmission = snapshotSubmission,
Report = await ReportGenerator.Generate(generateObj.Data, snapshotName, assignment, solutionNode),
};
await Snapshots.Add(snapshot);
newSnapshots.Add(snapshot);
generateObj.LastSnapshot = snapshot;
}
}
return(newSnapshots);
}
private async Task RunMarkovModelImpl(DevAssignment assignment, MarkovModelOptions options)
{
using (var handler =
new DirectoryHandler(Path.Combine(Options.RootDirectory, GetUniqueFolderName(Options.RootDirectory))))
{
await Runner.RunMarkovModel(assignment, options, handler);
}
}
public async Task RunMarkovModel(DevAssignment assignment, MarkovModelOptions options, DirectoryHandler directory)
{
var snapshots = assignment.Snapshots.ToList();
if (options.BuildOnly)
{
snapshots = snapshots.Where(x => x.Report.Type == SnapshotReport.SnapshotReportTypes.Success).ToList();
}
await MarkovModelGenerator.Generate(snapshots, options, directory, assignment);
}
public async Task RunMarkovModel(DevAssignment assignment, MarkovModelOptions options)
{
try
{
await RunMarkovModelImpl(assignment, options);
}
catch (Exception exception)
{
LogException(exception, assignment);
}
}
public async Task <IActionResult> OnGetAsync()
{
Assignment = await Assignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnGetAsync()
{
Assignment = await Assignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
Context.Entry(Assignment).Reference(x => x.CourseClass).Load();
Context.Entry(Assignment).Reference(x => x.Solution)
.Query().Include(x => x.MethodDeclarations).Load();
Context.Entry(Assignment).Reference(x => x.TestProject)
.Query().Include(x => x.UnitTests).Load();
return(Page());
}
public AbstractSyntaxTreeNode GetStudentSnapshot(SubmissionData data, string snapshot, DevAssignment assignment)
{
var root = AbstractSyntaxTreeGenerator.CreateFromFile(data, data.SnapshotSourceFileFullPath(snapshot, assignment.Filename));
var classNode = ClassExtractor.Extract(root, assignment.Solution.Name);
return(classNode);
}
public async Task <SnapshotReport> Generate(SubmissionData data, string snapshot, DevAssignment assignment, AbstractSyntaxTreeNode solutionNode)
{
try
{
var report = await GenerateImpl(data, snapshot, assignment, solutionNode);
return(report);
}
catch (EngineReportExceptionData exception)
{
return(new SnapshotFailureReport()
{
Report = $"Error Type: {exception.Type}.\n{exception.Message}",
});
}
}
public async Task <ICollection <UnitTestResult> > GenerateResults(SubmissionData data, string snapshot, DevAssignment assignment, ICollection <SnapshotMethod> snapshotMethods)
{
try
{
return(await GenerateResultsImpl(data, snapshot, assignment, snapshotMethods));
}
catch (EngineReportExceptionData exception)
{
exception.Type = "Build";
throw;
}
}
public async Task <ICollection <UnitTestResult> > GenerateResultsImpl(SubmissionData data, string snapshot, DevAssignment assignment,
ICollection <SnapshotMethod> snapshotMethods)
{
using (var handler =
new DirectoryHandler(GetTestDirectory(data)))
{
var testProject = new TestProjectObj(handler.Directory, assignment.TestProject);
testProject.MoveFilesToProject(data.SnapshotSourceFiles(snapshot));
var preprocessorArguments = GetPreprocessorArguments(snapshotMethods);
var process = new EngineProcess(GetEngineProcessData(handler.Directory,
testProject, preprocessorArguments));
var exitCode = process.Run();
if (exitCode == 0)
{
process.Stop();
return(GetUnitTestResults(assignment.TestProject,
ResultsFile(handler.Directory)));
}
EngineReportExceptionData exception;
using (var reader = process.StandardError)
{
exception = new EngineReportExceptionData(reader.ReadToEnd())
{
Type = "Build",
};
}
process.Stop();
throw exception;
}
}
public AbstractSyntaxTreeNode CreateOrDefualtAbstractSyntaxTreeNode(Snapshot snapshot, DirectoryHandler handler, DevAssignment assignment)
{
using (var directory = new DirectoryHandler(Path.Combine(handler.Directory, nameof(MarkovModelGenerator))))
{
var snapshotPath = EngineFileUtilities.ExtractZip(directory.Directory,
"Submission", snapshot.SnapshotSubmission.Files);
var file = Path.Combine(snapshotPath, assignment.Filename);
var node = AbstractSyntaxTreeGenerator.CreateOrDefaultFromFile(directory, file);
if (node != null)
{
return(AbstractSyntaxTreeClassExtractor.ExtractOrDefault(node, assignment.Solution.Name));
}
}
return(null);
}
private double CalculateTestDistance(Snapshot left, Snapshot right, MarkovModelOptions options, DevAssignment assignment)
{
if (left.Report.Type == SnapshotReport.SnapshotReportTypes.Failure &&
right.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
return(0.0d);
}
if (left.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
var report = (SnapshotSuccessReport)right.Report;
var sum = report
.UnitTestResults
.Select(x => x.Passed ? Math.Pow(options.TestWeight, 2.0f) : 0.0d)
.Sum();
return(sum);
}
if (right.Report.Type == SnapshotReport.SnapshotReportTypes.Failure)
{
var report = (SnapshotSuccessReport)left.Report;
var sum = report
.UnitTestResults
.Select(x => x.Passed ? Math.Pow(options.TestWeight, 2.0f) : 0.0d)
.Sum();
return(sum);
}
var leftReport = (SnapshotSuccessReport)left.Report;
var rightReport = (SnapshotSuccessReport)right.Report;
var accumulator = 0.0d;
foreach (var unitTest in assignment.TestProject.UnitTests)
{
var leftTest = leftReport.UnitTestResults.Single(x => x.UnitTestId.Equals(unitTest.Id));
var rightTest = rightReport.UnitTestResults.Single(x => x.UnitTestId.Equals(unitTest.Id));
var leftValue = leftTest.Passed ? options.TestWeight : 0.0d;
var rightValue = rightTest.Passed ? options.TestWeight : 0.0d;
accumulator += Math.Pow(leftValue - rightValue, 2);
}
return(accumulator);
}
private static Snapshot GetLastSnapshotOrDefault(SubmissionData data, DevAssignment assignment)
{
return(data.Student.Snapshots
.Where(s => s.AssignmentId.Equals(assignment.Id))
.OrderByDescending(s => s.SnapshotSubmission.CreatedDateTime).FirstOrDefault());
}
public async Task Generate(IList <Snapshot> snapshots, MarkovModelOptions options, DirectoryHandler handler, DevAssignment assignment)
{
var markovModel = new MarkovModel()
{
Assignment = assignment,
Finished = false,
};
await MarkovModelRepository.Add(markovModel);
var distanceMatrix = DistanceMatrix(snapshots, options, handler, assignment);
markovModel.States = MarkovModelCreator.Create(snapshots, distanceMatrix, options.NumberOfStates);
markovModel.Finished = true;
await MarkovModelRepository.Update(markovModel);
}
public AbstractSyntaxTreeNode GetSolutionAbstractSyntaxTreeNode(SubmissionData data, DevAssignment assignment)
{
using (var directory = new DirectoryHandler(Path.Combine(data.Root, nameof(SnapshotGenerator))))
{
var snapshotPath = EngineFileUtilities.ExtractZip(directory.Directory,
"Solution", assignment.Solution.Files);
var file = Path.Combine(snapshotPath, assignment.Filename);
var solution = AbstractSyntaxTreeGenerator.CreateFromFile(directory, file);
return(ClassExtractor.Extract(solution, assignment.Solution.Name));
}
}
public async Task <SnapshotReport> GenerateImpl(SubmissionData data, string snapshot, DevAssignment assignment,
AbstractSyntaxTreeNode solutionNode)
{
var studentNode = GetStudentSnapshot(data, snapshot, assignment);
var snapshotMethods = assignment
.Solution
.MethodDeclarations
.Select(methodDeclaration =>
MethodGenerator.Generate(studentNode, solutionNode, methodDeclaration))
.ToList();
var unitTests = await UnitTestGenerator.GenerateResults(data, snapshot,
assignment, snapshotMethods);
var report = new SnapshotSuccessReport()
{
SnapshotMethods = snapshotMethods,
UnitTestResults = unitTests,
};
await SnapshotReports.Add(report);
return(report);
}
private double CalculateMetricDistance(AbstractSyntaxTreeNode leftRoot, AbstractSyntaxTreeNode rightRoot, DevAssignment assignment, MarkovModelOptions options)
{
if (leftRoot == null && rightRoot == null)
{
return(0.0d);
}
var accumlator = 0.0d;
foreach (var methodDeclarration in assignment.Solution.MethodDeclarations)
{
var leftNode = leftRoot == null ? null : GetMethodOrDefault(leftRoot, methodDeclarration);
var rightNode = rightRoot == null ? null : GetMethodOrDefault(leftRoot, methodDeclarration);
if (leftNode != null && rightNode != null)
{
var abstractSyntaxTreeMetric = AbstractSyntaxTreeMetricCreator.Create(leftNode, rightNode);
var bagOfWordsMetric = BagOfWordsMetricCreator.Create(leftNode, rightNode);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Rotations * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Insertations * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(abstractSyntaxTreeMetric.Deletions * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(bagOfWordsMetric.Difference * options.BagOfWordsWeight, 2);
}
else if (leftNode != null)
{
var amount = leftNode.NumberOfNodes();
accumlator += Math.Pow(amount * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(amount * options.BagOfWordsWeight, 2);
}
else if (rightNode != null)
{
var amount = rightNode.NumberOfNodes();
accumlator += Math.Pow(amount * options.AbstractSyntaxTreeWeight, 2);
accumlator += Math.Pow(amount * options.BagOfWordsWeight, 2);
}
}
return(accumlator);
}
