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/package.json

@@ -77,6 +77,8 @@
   "homepage": "https://github.com/siefkenj/unified-latex#readme",
   "private": true,
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "cross-spawn": "^7.0.3",
     "source-map-support": "^0.5.21"
   }
 }

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

@@ -4,6 +4,7 @@ import "../../test-common";
 import { exec as _exec } from "node:child_process";
 import * as fsLegacy from "node:fs";
 import * as path from "node:path";
+import spawn from "cross-spawn";
 
 const exec = util.promisify(_exec);
 
@@ -18,87 +19,152 @@ console.log = (...args) => {
 const exePath = path.resolve(__dirname, "../dist/unified-latex-cli.mjs");
 const examplesPath = path.resolve(__dirname, "examples");
 
-describe("unified-latex-cli", () => {
-    let stdout: string, stderr: string;
-    it("executable exists", async () => {
-        expect(fsLegacy.existsSync(exePath)).toBeTruthy();
-    });
-    it("can execute without error", async () => {
-        let { stdout, stderr } = await exec(`node ${exePath} -h`);
-        expect(stdout).toBeTruthy();
-    });
-    it("can format document", async () => {
-        let { stdout, stderr } = await exec(
-            `node ${exePath} ${examplesPath}/needs-fixing.tex`
-        );
-        expect(stdout).toMatchSnapshot();
-    });
-    it("can expand macro", async () => {
-        {
+describe(
+    "unified-latex-cli",
+    () => {
+        let stdout: string, stderr: string;
+        it("executable exists", async () => {
+            expect(fsLegacy.existsSync(exePath)).toBeTruthy();
+        });
+        it("can execute without error", async () => {
+            let { stdout, stderr } = await exec(`node ${exePath} -h`);
+            expect(stdout).toBeTruthy();
+        });
+        it("can format document", async () => {
             let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/needs-expanding.tex -e '\\newcommand{foo}[1]{FOO(#1)}' -e '{name: "bar", body: "baz"}'`
+                `node ${exePath} ${examplesPath}/needs-fixing.tex`
             );
             expect(stdout).toMatchSnapshot();
-        }
-        {
-            // Make sure we don't lose spaces in math mode
+        });
+        it("can expand macro", async () => {
+            {
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/needs-expanding.tex`,
+                    `-e`,
+                    "\\newcommand{foo}[1]{FOO(#1)}",
+                    `-e`,
+                    '{name: "bar", body: "baz"}',
+                ]);
+                expect(stdout).toMatchSnapshot();
+            }
+            {
+                // Make sure we don't lose spaces in math mode
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/needs-expanding.tex`,
+                    `-e`,
+                    "\\newcommand{foo}[1]{$\\x #1$}",
+                    `-e`,
+                    '{name: "bar", body: "baz"}',
+                ]);
+                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(
-                `node ${exePath} ${examplesPath}/needs-expanding.tex -e '\\newcommand{foo}[1]{$\\x #1$}' -e '{name: "bar", body: "baz"}'`
+                `node ${exePath} ${examplesPath}/has-definition.tex --stats-json`
             );
-            expect(stdout).toMatchSnapshot();
-        }
-    });
-    it("can expand macros defined in document", async () => {
-        let { stdout, stderr } = await exec(
-            `node ${exePath} ${examplesPath}/has-definition.tex --stats-json`
-        );
-        const { newcommands } = JSON.parse(stdout) as {
-            newcommands: { name: string }[];
-        };
-        const newcommandNames = newcommands.map((c) => c.name);
-        expect(newcommandNames).toEqual(["foo", "baz"]);
+            const { newcommands } = JSON.parse(stdout) as {
+                newcommands: { name: string }[];
+            };
+            const newcommandNames = newcommands.map((c) => c.name);
+            expect(newcommandNames).toEqual(["foo", "baz"]);
 
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/has-definition.tex --expand-document-macro foo --expand-document-macro baz`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
-    });
-    it("can override default macros", async () => {
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/has-existing-definition.tex`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/has-existing-definition.tex -e '\\newcommand{mathbb}{\\mathbb}'`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/has-existing-definition.tex -e '\\newcommand{mathbb}[2]{\\mathbb{#1}{#2}}'`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
-    });
-    it("can convert to html", async () => {
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/simple.tex --html`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
-    });
-    it("can convert to markdown", async () => {
-        {
-            let { stdout, stderr } = await exec(
-                `node ${exePath} ${examplesPath}/simple.tex --markdown`
-            );
-            expect(stdout).toMatchSnapshot();
-        }
+            {
+                let { stdout, stderr } = await exec(
+                    `node ${exePath} ${examplesPath}/has-definition.tex --expand-document-macro foo --expand-document-macro baz`
+                );
+                expect(stdout).toMatchSnapshot();
+            }
+        });
+        it("can override default macros", async () => {
+            {
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/has-existing-definition.tex`,
+                ]);
+                expect(stdout).toMatchSnapshot();
+            }
+            {
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/has-existing-definition.tex`,
+                    `-e`,
+                    "\\newcommand{mathbb}{\\mathbb}",
+                ]);
+                expect(stdout).toMatchSnapshot();
+            }
+            {
+                let stdout = await executeCommand(`node`, [
+                    exePath,
+                    `${examplesPath}/has-existing-definition.tex`,
+                    `-e`,
+                    "\\newcommand{mathbb}[2]{\\mathbb{#1}{#2}}",
+                ]);
+                expect(stdout).toMatchSnapshot();
+            }
+        });
+        it("can convert to html", async () => {
+            {
+                let { stdout, stderr } = await exec(
+                    `node ${exePath} ${examplesPath}/simple.tex --html`
+                );
+                expect(stdout).toMatchSnapshot();
+            }
+        });
+        it("can convert to markdown", async () => {
+            {
+                let { stdout, stderr } = await exec(
+                    `node ${exePath} ${examplesPath}/simple.tex --markdown`
+                );
+                expect(stdout).toMatchSnapshot();
+            }
+        });
+    },
+    {
+        timeout: 60 * 1000,
+    }
+);
+
+/**
+ * Run commands with arguments using "cross-spawn", which correctly escapes arguments
+ * so that end results are the same across different shells.
+ */
+async function executeCommand(executablePath: string, args: string[]) {
+    return new Promise((resolve, reject) => {
+        const childProcess = spawn(executablePath, args, { stdio: "pipe" });
+
+        let stdoutData = "";
+
+        // Listen for stdout data
+        childProcess.stdout!.on("data", (data) => {
+            stdoutData += data.toString();
+        });
+
+        // Listen for errors
+        childProcess.on("error", (err) => {
+            reject(err);
+        });
+
+        // Listen for process completion
+        childProcess.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdoutData);
+            } else {
+                reject(new Error(`Child process exited with code ${code}`));
+            }
+        });
     });
-});
+}

packages/unified-latex-to-hast/index.ts

@@ -31,7 +31,7 @@ export * from "./libs/convert-to-html";
  * import { printRaw } from "@unified-latex/unified-latex-util-print-raw";
  * import { unifiedLatexToHast } from "@unified-latex/unified-latex-to-hast";
  * import { unifiedLatexFromString } from "@unified-latex/unified-latex-util-parse";
- * import { getArgsContent } from "@unified-latex/unified-latex-util-arguments";              
+ * import { getArgsContent } from "@unified-latex/unified-latex-util-arguments";
  *
  * const convert = (value) =>
  *     unified()

packages/unified-latex-to-hast/libs/pre-html-subs/environment-subs.ts

@@ -178,5 +178,5 @@ export const environmentReplacements: Record<
             content: env.content,
             attributes: { className: "environment quote" },
         });
-    }
+    },
 };

packages/unified-latex-to-mdast/tests/convert-to-markdown.test.ts

@@ -44,24 +44,20 @@ describe("unified-latex-to-mdast:convert-to-markdown", () => {
             `### My Section\n\nHi there\n\nAnd here $x^{2}$ math\n`
         );
     });
-    
+
     it("display math converts to $$...$$", () => {
         let ast = unified()
             .use(unifiedLatexFromString)
             .parse("my\\[math\\]yay!");
         markdown = convertToMarkdown(ast);
-        expect(markdown).toEqual(
-            `my\n\n\`\`\`math\nmath\n\`\`\`\n\nyay!\n`
-        );
+        expect(markdown).toEqual(`my\n\n\`\`\`math\nmath\n\`\`\`\n\nyay!\n`);
     });
-    
+
     it("math isn't mangled when it is rendered", () => {
         let ast = unified()
             .use(unifiedLatexFromString)
             .parse("$\\sum_x^{y} x+Y$");
         markdown = convertToMarkdown(ast);
-        expect(markdown).toEqual(
-            `$\\sum_{x}^{y}x+Y$\n`
-        );
+        expect(markdown).toEqual(`$\\sum_{x}^{y}x+Y$\n`);
     });
 });