Add and pass more regression tests for PerseusItem parser

packages/perseus/src/util/parse-perseus-json/general-purpose-parsers/discriminated-union.test.ts

@@ -0,0 +1,80 @@
+import {discriminatedUnion} from "./discriminated-union";
+import {constant} from "./constant";
+import {object} from "./object";
+import {number} from "./number";
+import {parse} from "../parse";
+import {failure, success} from "../result";
+
+describe("a discriminatedUnion with one variant", () => {
+    const unionParser = discriminatedUnion(
+        object({type: constant("ok")}),
+        object({type: constant("ok"), value: number}),
+    ).parser;
+
+    it("parses a valid value", () => {
+        const input = {type: "ok", value: 3};
+
+        expect(parse(input, unionParser)).toEqual(success(input))
+    })
+
+    it("rejects a value with the wrong `type`", () => {
+        const input = {type: "bad", value: 3};
+
+        expect(parse(input, unionParser)).toEqual(
+            failure(`At (root).type -- expected "ok", but got "bad"`),
+        )
+    })
+
+    it("rejects a value with a valid type but wrong fields", () => {
+        const input = {type: "ok", value: "foobar"};
+
+        expect(parse(input, unionParser)).toEqual(
+            failure(`At (root).value -- expected number, but got "foobar"`),
+        )
+    })
+})
+
+describe("a discriminatedUnion with two variants", () => {
+    const unionParser = discriminatedUnion(
+        object({type: constant("rectangle")}),
+        object({type: constant("rectangle"), width: number}),
+    ).or(
+        object({type: constant("circle")}),
+        object({type: constant("circle"), radius: number}),
+    ).parser;
+
+    it("parses a valid rectangle", () => {
+        const input = {type: "rectangle", width: 42};
+
+        expect(parse(input, unionParser)).toEqual(success(input))
+    })
+
+    it("rejects a rectangle with no width", () => {
+        const input = {type: "rectangle", radius: 99};
+
+        expect(parse(input, unionParser)).toEqual(
+            failure(`At (root).width -- expected number, but got undefined`))
+    })
+
+    it("parses a valid circle", () => {
+        const input = {type: "circle", radius: 7};
+
+        expect(parse(input, unionParser)).toEqual(success(input))
+    })
+
+    it("rejects a circle with no radius", () => {
+        const input = {type: "circle", width: 99};
+
+        expect(parse(input, unionParser)).toEqual(
+            failure(`At (root).radius -- expected number, but got undefined`)
+        )
+    })
+
+    it("rejects a value with an unrecognized `type`", () => {
+        const input = {type: "triangle", width: -1, radius: 99};
+
+        expect(parse(input, unionParser)).toEqual(
+            failure(`At (root).type -- expected "rectangle", but got "triangle"`)
+        )
+    })
+})

packages/perseus/src/util/parse-perseus-json/general-purpose-parsers/discriminated-union.ts

@@ -0,0 +1,34 @@
+import type {Parser} from "../parser-types";
+import {isSuccess} from "../result";
+import {pipeParsers} from "./pipe-parsers";
+
+// discriminatedUnion() should be preferred over union() when parsing a
+// discriminated union type, because discriminatedUnion() produces more
+// understandable failure messages. It takes the discriminant as the source of
+// truth for which variant is to be parsed, and expects the other data to match
+// that variant.
+export function discriminatedUnion<T>(narrow: Parser<unknown>, parseVariant: Parser<T>): DiscriminatedUnionBuilder<T> {
+    return new DiscriminatedUnionBuilder(pipeParsers(narrow).then(parseVariant).parser)
+}
+
+class DiscriminatedUnionBuilder<Variant> {
+    constructor(public parser: Parser<Variant>) {
+    }
+
+    or<Variant2>(
+        narrow: Parser<unknown>,
+        parseVariant: Parser<Variant2>,
+    ): DiscriminatedUnionBuilder<Variant | Variant2> {
+        return new DiscriminatedUnionBuilder(either(narrow, parseVariant, this.parser));
+    }
+}
+
+function either<A, B>(narrowToA: Parser<unknown>, parseA: Parser<A>, parseB: Parser<B>): Parser<A | B> {
+    return (rawValue, ctx) => {
+        if (isSuccess(narrowToA(rawValue, ctx))) {
+            return parseA(rawValue, ctx)
+        }
+
+        return parseB(rawValue, ctx)
+    }
+}

packages/perseus/src/util/parse-perseus-json/perseus-parsers/expression-widget.ts

@@ -24,6 +24,9 @@ import type {
     ParseResult,
 } from "../parser-types";
 import {convert} from "../general-purpose-parsers/convert";
+import {
+    discriminatedUnion
+} from "../general-purpose-parsers/discriminated-union";
 
 const parsePossiblyInvalidAnswerForm = object({
     // `value` is the possibly invalid part of this. It should always be a
@@ -52,9 +55,10 @@ function removeInvalidAnswerForms(
     return valid
 }
 
+const version1 = object({major: constant(1), minor: number});
 const parseExpressionWidgetV1: Parser<ExpressionWidget> =
     parseWidgetWithVersion(
-        object({major: constant(1), minor: number}),
+        version1,
         constant("expression"),
         object({
             answerForms: pipeParsers(array(parsePossiblyInvalidAnswerForm))
@@ -79,8 +83,9 @@ const parseExpressionWidgetV1: Parser<ExpressionWidget> =
         }),
     );
 
+const version0 = optional(object({major: constant(0), minor: number}));
 const parseExpressionWidgetV0 = parseWidgetWithVersion(
-    optional(object({major: constant(0), minor: number})),
+    version0,
     constant("expression"),
     object({
         functions: array(string),
@@ -133,6 +138,10 @@ function migrateV0ToV1(
     });
 }
 
-export const parseExpressionWidget: Parser<ExpressionWidget> = union(
+export const parseExpressionWidget: Parser<ExpressionWidget> = discriminatedUnion(
+    object({version: version1}),
     parseExpressionWidgetV1,
-).or(pipeParsers(parseExpressionWidgetV0).then(migrateV0ToV1).parser).parser;
+).or(
+    object({version: version0}),
+    pipeParsers(parseExpressionWidgetV0).then(migrateV0ToV1).parser,
+).parser;