Improvements to autocomplete redirects. See #1380

Author: cdsmith

web/js/codeworld_shared.js

@@ -545,62 +545,73 @@ function registerStandardHints(successFunc) {
       }
     }
 
-    // If there's a chance to find an exact match, clear out the fuzzy matches
-    // so that the exact match is chosen.
-    if (found[0].length + found[1].length === 1) {
-      found[2] = [];
-    }
-
-    const options = found[0].concat(found[1], found[2]);
-
+    let options = found[0].concat(found[1], found[2]);
+    let foundReplacementPrefix = false;
     options.forEach((candidate) => {
       const { text } = candidate;
-      const originalTermCost = substitutionCost(
-        token.string,
-        text,
-        term.length
-      );
+      candidate.cost = substitutionCost(token.string, text, term.length);
 
-      for (const [module, mapping] of Object.entries(replacementTerms)) {
-        if (window.codeWorldSymbols[text]) {
-          const mappedTerms =
-            Object.prototype.hasOwnProperty.call(mapping, text) &&
-            mapping[text];
-          const { definingModule } = window.codeWorldSymbols[text];
-
-          if (mappedTerms && definingModule && definingModule === module) {
-            const mappedTermsWithCosts = mappedTerms.map((mappedTerm) => {
-              return {
-                replacementExplanation: mappedTerm.explanation,
-                cost: substitutionCost(
-                  token.string,
-                  mappedTerm.value ? mappedTerm.value : mappedTerm,
-                  term.length,
-                  true
-                ),
-              };
-            });
+      if (!window.codeWorldSymbols[text]) {
+        return;
+      }
 
-            const lowestCost = Math.min(
-              ...mappedTermsWithCosts.map(({ cost }) => cost),
-              originalTermCost
-            );
-            candidate.cost = lowestCost;
-
-            const winningMappedTerm = mappedTermsWithCosts.find(
-              ({ cost }) => cost === lowestCost
-            );
-            if (winningMappedTerm) {
-              candidate.replacementExplanation =
-                winningMappedTerm.replacementExplanation;
-            }
-          } else {
-            candidate.cost = originalTermCost;
-          }
+      const { definingModule } = window.codeWorldSymbols[text];
+      if (!definingModule) {
+        return;
+      }
+
+      const mapping = replacementTerms[definingModule];
+      const mappedTerms =
+        Object.prototype.hasOwnProperty.call(mapping, text) && mapping[text];
+
+      if (!mappedTerms) {
+        return;
+      }
+
+      const mappedTermsWithCosts = mappedTerms.map((mappedTerm) => {
+        const replacementWord = mappedTerm.value
+          ? mappedTerm.value
+          : mappedTerm;
+        if (replacementWord.startsWith(term)) {
+          foundReplacementPrefix = true;
         }
+
+        return {
+          replacementExplanation: mappedTerm.explanation,
+          cost: substitutionCost(
+            token.string,
+            mappedTerm.value ? mappedTerm.value : mappedTerm,
+            term.length,
+            true
+          ),
+        };
+      });
+
+      const lowestCost = Math.min(
+        ...mappedTermsWithCosts.map(({ cost }) => cost),
+        candidate.cost
+      );
+      candidate.cost = lowestCost;
+
+      const winningMappedTerm = mappedTermsWithCosts.find(
+        ({ cost }) => cost === lowestCost
+      );
+      if (winningMappedTerm) {
+        candidate.replacementExplanation =
+          winningMappedTerm.replacementExplanation;
       }
     });
 
+    // If there's a chance to complete an exact prefix, clear out the fuzzy
+    // matches so that the exact match is chosen.
+    if (
+      found[0].length === 0 &&
+      found[1].length === 1 &&
+      !foundReplacementPrefix
+    ) {
+      options = found[1];
+    }
+
     if (options.length > 0) {
       options.sort((a, b) => {
         if (a.cost < b.cost) return -1;

web/replacement_terms.json

@@ -1,9 +1,14 @@
 {
   "Prelude": {
-    "abs": ["positive", "magnitude"],
+    "abs": ["positive", "magnitude", "absoluteValue"],
     "acos": ["arccos"],
     "activityOf": ["interactionOf"],
-    "arc": ["semicircle"],
+    "arc": [
+      {
+        "value": "semicircle",
+        "explanation": "Hint: A semicircle is an arc with the start and end angles 180 degrees apart."
+      }
+    ],
     "asin": ["arcsin"],
     "atan": ["arctan"],
     "mixed": ["blend"],
@@ -17,23 +22,59 @@
     "polygon": [
       {
         "value": "triangle",
-        "explanation": "A triangle is a polygon with three vertices."
+        "explanation": "Hint: A triangle is a polygon with three vertices."
+      },
+      {
+        "value": "quadrilateral",
+        "explanation": "Hint: A quadrilateral is a polygon with four vertices."
+      },
+      {
+        "value": "parallelogram",
+        "explanation": "Hint: A parallelogram is a polygon with four vertices and parallel sides."
       },
-      "quadrilateral",
-      "parallelogram",
-      "trapezoid",
-      "rhombus",
-      "pentagon",
-      "hexagon",
-      "heptagon",
-      "octagon"
+      {
+        "value": "trapezoid",
+        "explanation": "Hint: A trapezoid is a polygon with four vertices and one pair of parallel sides."
+      },
+      {
+        "value": "rhombus",
+        "explanation": "Hint: A rhombus is a polygon with four vertices and equal side lengths."
+      },
+      {
+        "value": "pentagon",
+        "explanation": "Hint: A pentagon is a polygon with five vertices."
+      },
+      {
+        "value": "hexagon",
+        "explanation": "Hint: A hexagon is a polygon with six vertices."
+      },
+      {
+        "value": "heptagon",
+        "explanation": "Hint: A heptagon is a polygon with seven vertices."
+      },
+      {
+        "value": "octagon",
+        "explanation": "Hint: An octagon is a polygon with eight vertices."
+      }
     ],
     "polyline": ["line"],
     "program": ["main"],
-    "rectangle": ["square"],
-    "rotated": ["turn"],
-    "scaled": ["stretch", "reflect", "ellipse"],
-    "sector": ["solidArc"],
+    "rectangle": [
+      {
+        "value": "square",
+        "explanation": "Hint: A square is a rectangle with the height and width equal."
+      }
+    ],
+    "reflected": ["mirror", "flip"],
+    "rotated": ["turn", "flip"],
+    "scaled": [
+      "stretch",
+      {
+        "value": "ellipse",
+        "explanation": "Hint: An ellipse is a scaled circle."
+      }
+    ],
+    "sector": ["solidArc", "pie"],
     "sin": ["sine"],
     "solidClosedCurve": ["solidCurve", "solidLoop", "solidOval"],
     "solidPolygon": [
@@ -48,7 +89,7 @@
       "solidOctagon"
     ],
     "solidRectangle": ["solidSquare"],
-    "sqrt": ["root", "radical"],
+    "sqrt": ["root", "radical", "squareRoot"],
     "tan": ["tangent"],
     "thickClosedCurve": ["thickLoop", "thickOval"],
     "thickPolygon": [
@@ -64,6 +105,6 @@
     ],
     "thickPolyline": ["thickLine"],
     "thickRectangle": ["thickSquare"],
-    "translated": ["move"]
+    "translated": ["move", "shift", "position"]
   }
 }