Default arguments support #24

package.json

@@ -24,6 +24,7 @@
     "devDependencies": {
         "@types/node": "^20.5.9",
         "@types/prettier": "^2.7.3",
+        "@typescript-eslint/eslint-plugin": "^6.16.0",
         "esbuild": "^0.19.2",
         "esbuild-runner": "^2.2.2",
         "lerna": "^7.2.0",

packages/unified-latex-cli/tests/__snapshots__/cli.test.ts.snap

@@ -45,6 +45,12 @@ hi $\\\\x fooArg$ and baz!
 "
 `;
 
+exports[`unified-latex-cli > can expand macro 3`] = `
+"% Expand via> tests/needs-expanding.tex --stats -e \\"\\\\\\\\newcommand{foo}[1]{FOO(#1)}\\" -e '{name: \\"bar\\", body: \\"baz\\"}'
+hi FOO(fooArg) and baz!
+"
+`;
+
 exports[`unified-latex-cli > can expand macros defined in document 1`] = `
 "\\\\newcommand{\\\\foo}[1]{$BAR #1$}
 \\\\DeclareDocumentCommand{\\\\baz}{m}{\\\\foo{xxx} .#1.}

packages/unified-latex-cli/tests/cli.test.ts

@@ -60,6 +60,17 @@ describe(
                 ]);
                 expect(stdout).toMatchSnapshot();
             }
+            {
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/needs-expanding.tex`,
+                    `-e`,
+                    "\\newcommand{foo}[1]{FOO(#1)}",
+                    `-e`,
+                    '{name: "bar", signature: "O{baz}", body: "#1"}',
+                ]);
+                expect(stdout).toMatchSnapshot();
+            }
         });
         it("can expand macros defined in document", async () => {
             let { stdout, stderr } = await exec(

packages/unified-latex-util-argspec/libs/argspec-parser.ts

@@ -29,13 +29,19 @@ export function printRaw(
         const sepToken = root ? " " : "";
         return node.map((tok) => printRaw(tok)).join(sepToken);
     }
-
+    return printRawInner(node);
+}
+function printRawInner(node: ArgSpec.Node) {
     const decorators = getDecorators(node);
-    const defaultArg = (node as ArgSpec.DefaultArgument).defaultArg
-        ? printRaw((node as ArgSpec.DefaultArgument).defaultArg!)
-        : "";
     let spec = decorators;
-
+    function appendDefaultArg() {
+        if ("defaultArg" in node && node.defaultArg) {
+            spec = appendTokenOrGroup(spec, node.defaultArg);
+        }
+    }
+    function appendCollection(collection: string[]) {
+        spec += printTokenOrCollection(collection);
+    }
     const type = node.type;
     switch (type) {
         case "body":
@@ -52,7 +58,8 @@ export function printRaw(
                 spec += node.defaultArg ? "D" : "d";
                 spec += node.openBrace + node.closeBrace;
             }
-            return spec + defaultArg;
+            appendDefaultArg();
+            return spec;
         case "mandatory":
             // {...} is the default enclosure for mandatory arguments
             if (node.openBrace === "{" && node.closeBrace === "}") {
@@ -61,32 +68,78 @@ export function printRaw(
                 spec += node.defaultArg ? "R" : "r";
                 spec += node.openBrace + node.closeBrace;
             }
-            return spec + defaultArg;
+            appendDefaultArg();
+            return spec;
         case "embellishment":
-            spec += node.defaultArg ? "E" : "e";
-            return (
-                spec +
-                "{" +
-                printRaw(node.embellishmentTokens) +
-                "}" +
-                defaultArg
-            );
+            spec += node.embellishmentDefaultArg ? "E" : "e";
+            appendCollection(node.embellishmentTokens);
+            if (node.embellishmentDefaultArg) {
+                appendCollection(node.embellishmentDefaultArg);
+            }
+            return spec;
         case "verbatim":
             return spec + "v" + node.openBrace;
-        case "group":
-            return spec + "{" + printRaw(node.content) + "}";
         case "until": {
-            const stopTokens = printRaw(node.stopTokens);
-            return stopTokens.length > 1 || stopTokens[0] === " "
-                ? `u{${stopTokens}}`
-                : `u${stopTokens}`;
+            spec += "u";
+            appendCollection(node.stopTokens);
+            return spec;
         }
         default:
             const neverType: never = type;
             console.warn(`Unknown node type "${neverType}" for node`, node);
             return "";
     }
 }
+/**
+ * See xparse-argspec.pegjs - token_or_group is parsed to an array of strings.
+ * This function will reconstruct a representative in an inverse image of token_or_group
+ * for a given array of strings, and append it to a given string.
+ * In order to avoid parsing ambiguity, we force enclose the representative with braces in some case.
+ * For instance, if the given string ends with a control word such as "\asdf", and if the representative is a
+ * whitespace where we are in a circumstance where no whitespaces are allowed.
+ */
+function appendTokenOrGroup(
+    existingString: string,
+    tokenOrGroup: string,
+    allowWhitespace = false
+) {
+    // If a previous token consists of more than one chars and ends with letters,
+    // then we need to separate the next token by enclosing it with braces.
+    // This can happen with control words such as \asdf.
+    const followsControlWord = /\\[a-zA-Z]+$/.test(existingString);
+    if (
+        (!followsControlWord &&
+            tokenOrGroup.length === 1 &&
+            (allowWhitespace || tokenOrGroup !== " ")) ||
+        tokenOrGroup.startsWith("\\")
+    ) {
+        return existingString + tokenOrGroup;
+    }
+    // In normalization, prefer whitespace because it occupies less space.
+    return (
+        existingString +
+        (allowWhitespace && tokenOrGroup.length === 1
+            ? " " + tokenOrGroup
+            : "{" + tokenOrGroup + "}")
+    );
+}
+/**
+ * See xparse-argspec.pegjs, token_or_collection is used by embellishment tokens, embellishment default arguments,
+ * and stop tokens for `until`.
+ */
+function printTokenOrCollection(tokenOrCollection: string[]) {
+    if (tokenOrCollection.length <= 1) {
+        const token = tokenOrCollection[0];
+        if (token.length === 1 && token !== " ") {
+            return token;
+        }
+    }
+    let out = "";
+    for (let token of tokenOrCollection) {
+        out = appendTokenOrGroup(out, token, true);
+    }
+    return "{" + out + "}";
+}
 
 const parseCache: { [argStr: string]: ArgSpec.Node[] } = {};
 

packages/unified-latex-util-argspec/libs/argspec-types.ts

@@ -1,5 +1,5 @@
 export type Ast = Node[] | Node;
-export type Node = Optional | Mandatory | Verbatim | Body | Group | Until;
+export type Node = Optional | Mandatory | Verbatim | Body | Until;
 type Optional = OptionalArg | OptionalStar | OptionalToken | Embellishment;
 interface AstNode {
     type: string;
@@ -12,7 +12,7 @@ export interface LeadingWhitespace {
     noLeadingWhitespace: boolean | undefined;
 }
 export interface DefaultArgument {
-    defaultArg?: Group;
+    defaultArg?: string;
 }
 interface Verbatim extends Arg {
     type: "verbatim";
@@ -30,14 +30,11 @@ interface OptionalToken extends LeadingWhitespace, AstNode {
 export interface Embellishment extends DefaultArgument, AstNode {
     type: "embellishment";
     embellishmentTokens: string[];
+    embellishmentDefaultArg?: string[];
 }
 interface Mandatory extends LeadingWhitespace, DefaultArgument, Arg {
     type: "mandatory";
 }
-export interface Group extends AstNode {
-    type: "group";
-    content: (Group | string)[];
-}
 interface Body extends AstNode {
     type: "body";
 }

packages/unified-latex-util-argspec/tests/__snapshots__/argspec-parser.test.ts.snap

@@ -23,34 +23,38 @@ exports[`unified-latex-util-argspec > parses xparse argument specification strin
 
 exports[`unified-latex-util-argspec > parses xparse argument specification string "" 1`] = `[]`;
 
+exports[`unified-latex-util-argspec > parses xparse argument specification string "D(ab" 1`] = `
+[
+  {
+    "closeBrace": "a",
+    "defaultArg": "b",
+    "openBrace": "(",
+    "type": "optional",
+  },
+]
+`;
+
+exports[`unified-latex-util-argspec > parses xparse argument specification string "E{\\token ^}{{D1}2}" 1`] = `
+[
+  {
+    "embellishmentDefaultArg": [
+      "D1",
+      "2",
+    ],
+    "embellishmentTokens": [
+      "\\\\token",
+      "^",
+    ],
+    "type": "embellishment",
+  },
+]
+`;
+
 exports[`unified-latex-util-argspec > parses xparse argument specification string "O{nested{defaults}}" 1`] = `
 [
   {
     "closeBrace": "]",
-    "defaultArg": {
-      "content": [
-        "n",
-        "e",
-        "s",
-        "t",
-        "e",
-        "d",
-        {
-          "content": [
-            "d",
-            "e",
-            "f",
-            "a",
-            "u",
-            "l",
-            "t",
-            "s",
-          ],
-          "type": "group",
-        },
-      ],
-      "type": "group",
-    },
+    "defaultArg": "nested{defaults}",
     "openBrace": "[",
     "type": "optional",
   },
@@ -61,22 +65,7 @@ exports[`unified-latex-util-argspec > parses xparse argument specification strin
 [
   {
     "closeBrace": "]",
-    "defaultArg": {
-      "content": [
-        "s",
-        "o",
-        "m",
-        "e",
-        "d",
-        "e",
-        "f",
-        "a",
-        "u",
-        "l",
-        "t",
-      ],
-      "type": "group",
-    },
+    "defaultArg": "somedefault",
     "openBrace": "[",
     "type": "optional",
   },
@@ -93,6 +82,28 @@ exports[`unified-latex-util-argspec > parses xparse argument specification strin
 ]
 `;
 
+exports[`unified-latex-util-argspec > parses xparse argument specification string "Ox" 1`] = `
+[
+  {
+    "closeBrace": "]",
+    "defaultArg": "x",
+    "openBrace": "[",
+    "type": "optional",
+  },
+]
+`;
+
+exports[`unified-latex-util-argspec > parses xparse argument specification string "R\\a1{default}" 1`] = `
+[
+  {
+    "closeBrace": "1",
+    "defaultArg": "default",
+    "openBrace": "\\\\a",
+    "type": "mandatory",
+  },
+]
+`;
+
 exports[`unified-latex-util-argspec > parses xparse argument specification string "d++ D--{def}" 1`] = `
 [
   {
@@ -102,21 +113,14 @@ exports[`unified-latex-util-argspec > parses xparse argument specification strin
   },
   {
     "closeBrace": "-",
-    "defaultArg": {
-      "content": [
-        "d",
-        "e",
-        "f",
-      ],
-      "type": "group",
-    },
+    "defaultArg": "def",
     "openBrace": "-",
     "type": "optional",
   },
 ]
 `;
 
-exports[`unified-latex-util-argspec > parses xparse argument specification string "m e{^}" 1`] = `
+exports[`unified-latex-util-argspec > parses xparse argument specification string "m e^" 1`] = `
 [
   {
     "closeBrace": "}",
@@ -219,6 +223,16 @@ exports[`unified-latex-util-argspec > parses xparse argument specification strin
 ]
 `;
 
+exports[`unified-latex-util-argspec > parses xparse argument specification string "r\\abc\\d" 1`] = `
+[
+  {
+    "closeBrace": "\\\\d",
+    "openBrace": "\\\\abc",
+    "type": "mandatory",
+  },
+]
+`;
+
 exports[`unified-latex-util-argspec > parses xparse argument specification string "s m" 1`] = `
 [
   {

packages/unified-latex-util-argspec/tests/argspec-parser.test.ts

@@ -25,7 +25,7 @@ describe("unified-latex-util-argspec", () => {
         "o m o !o m",
         "!o r() m",
         "O{somedefault} m o",
-        "m e{^}",
+        "m e^",
         "m e{_^}",
         "s m",
         "v!",
@@ -35,6 +35,11 @@ describe("unified-latex-util-argspec", () => {
         "u{xx;}",
         "u;",
         "u{ }",
+        "Ox",
+        "r\\abc\\d",
+        "R\\a1{default}",
+        "D(ab",
+        "E{\\token ^}{{D1}2}",
     ];
 
     for (const spec of SPEC_STRINGS) {
@@ -46,16 +51,16 @@ describe("unified-latex-util-argspec", () => {
     }
 
     it("Embellishments always return a string", () => {
-        let ast = argspecParser.parse("e{{{x}}y{z}}");
+        let ast = argspecParser.parse("e{{x}y{z}}");
         expect(ast).toEqual([
             { type: "embellishment", embellishmentTokens: ["x", "y", "z"] },
         ]);
-        ast = argspecParser.parse("E{{{x}}y{z}}{}");
+        ast = argspecParser.parse("E{{x}y{z}}{{One}{Two}{Three}}");
         expect(ast).toEqual([
             {
                 type: "embellishment",
                 embellishmentTokens: ["x", "y", "z"],
-                defaultArg: { type: "group", content: [] },
+                embellishmentDefaultArg: ["One", "Two", "Three"],
             },
         ]);
     });