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); }