Give each class its own file.

Much easier to navigate the parsons code with it split out.

Signed-off-by: Brad Miller <bonelake@mac.com>

Author: bnmnetp

runestone/parsons/js/lineGrader.js

@@ -0,0 +1,125 @@
+export default class LineBasedGrader {
+    constructor(problem) {
+        this.problem = problem;
+    }
+    // Use a LIS (Longest Increasing Subsequence) algorithm to return the indexes
+    // that are not part of that subsequence.
+    inverseLISIndices(arr) {
+        // Get all subsequences
+        var allSubsequences = [];
+        for (var i = 0; i < arr.length; i++) {
+            var subsequenceForCurrent = [arr[i]],
+                current = arr[i],
+                lastElementAdded = -1;
+            for (var j = i; j < arr.length; j++) {
+                var subsequent = arr[j];
+                if (subsequent > current && lastElementAdded < subsequent) {
+                    subsequenceForCurrent.push(subsequent);
+                    lastElementAdded = subsequent;
+                }
+            }
+            allSubsequences.push(subsequenceForCurrent);
+        }
+        // Figure out the longest one
+        var longestSubsequenceLength = -1;
+        var longestSubsequence;
+        for (let i in allSubsequences) {
+            var subs = allSubsequences[i];
+            if (subs.length > longestSubsequenceLength) {
+                longestSubsequenceLength = subs.length;
+                longestSubsequence = subs;
+            }
+        }
+        // Create the inverse indexes
+        var indexes = [];
+        var lIndex = 0;
+        for (let i = 0; i < arr.length; i++) {
+            if (lIndex > longestSubsequence.length) {
+                indexes.push(i);
+            } else {
+                if (arr[i] == longestSubsequence[lIndex]) {
+                    lIndex += 1;
+                } else {
+                    indexes.push(i);
+                }
+            }
+        }
+        return indexes;
+    }
+    // grade that element, returning the state
+    grade() {
+        var problem = this.problem;
+        problem.clearFeedback();
+        this.correctLines = 0;
+        this.percentLines = 0;
+        this.incorrectIndents = 0;
+        var solutionLines = problem.solution;
+        var answerLines = problem.answerLines();
+        var i;
+        var state;
+        this.percentLines =
+            Math.min(answerLines.length, solutionLines.length) /
+            Math.max(answerLines.length, solutionLines.length);
+        if (answerLines.length < solutionLines.length) {
+            state = "incorrectTooShort";
+            this.correctLength = false;
+        } else if (answerLines.length == solutionLines.length) {
+            this.correctLength = true;
+        } else {
+            this.correctLength = false;
+        }
+
+        // Determine whether the code **that is there** is in the correct order
+        // If there is too much or too little code this only matters for
+        // calculating a percentage score.
+        let isCorrectOrder = true;
+        this.correctLines = 0;
+        this.solutionLength = solutionLines.length;
+        let loopLimit = Math.min(solutionLines.length, answerLines.length);
+        for (i = 0; i < loopLimit; i++) {
+            if (answerLines[i].text !== solutionLines[i].text) {
+                isCorrectOrder = false;
+            } else {
+                this.correctLines += 1;
+            }
+        }
+
+        // Determine whether blocks are indented correctly
+        this.indentLeft = [];
+        this.indentRight = [];
+        for (i = 0; i < loopLimit; i++) {
+            if (answerLines[i].viewIndent() < solutionLines[i].indent) {
+                this.indentRight.push(answerLines[i]);
+            } else if (answerLines[i].viewIndent() > solutionLines[i].indent) {
+                this.indentLeft.push(answerLines[i]);
+            }
+        }
+        this.incorrectIndents =
+            this.indentLeft.length + this.indentRight.length;
+        if (
+            this.incorrectIndents == 0 &&
+            isCorrectOrder &&
+            this.correctLength
+        ) {
+            // Perfect
+            state = "correct";
+        } else if (this.correctLength && isCorrectOrder) {
+            state = "incorrectIndent";
+        } else if (!isCorrectOrder && state != "incorrectTooShort") {
+            state = "incorrectMoveBlocks";
+        }
+        this.calculatePercent();
+        this.graderState = state;
+        return state;
+    }
+
+    calculatePercent() {
+        let numLines = this.percentLines * 0.2;
+        let lines = this.problem.answerLines().length;
+        let numCorrectBlocks = (this.correctLines / lines) * 0.4;
+        let numCorrectIndents =
+            ((this.correctLines - this.incorrectIndents) / lines) * 0.4;
+
+        this.problem.percent = numLines + numCorrectBlocks + numCorrectIndents;
+    }
+}