ic-mops 1.11.1 → 2.0.0

package/dist/commands/test/reporters/verbose-reporter.js

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
-import { absToRel } from '../utils.js';
+import chalk from "chalk";
+import { absToRel } from "../utils.js";
 export class VerboseReporter {
     passed = 0;
     failed = 0;
@@ -7,11 +7,11 @@ export class VerboseReporter {
     #startTime = Date.now();
     #curFileIndex = 0;
     addFiles(files) {
-        console.log('Test files:');
+        console.log("Test files:");
         for (let file of files) {
             console.log(chalk.gray(`• ${absToRel(file)}`));
         }
-        console.log('='.repeat(50));
+        console.log("=".repeat(50));
     }
     addRun(file, mmf, state, mode, progressive = false) {
         if (progressive) {
@@ -31,21 +31,25 @@ export class VerboseReporter {
         });
     }
     done() {
-        console.log('='.repeat(50));
+        console.log("=".repeat(50));
         if (this.failed) {
-            console.log(chalk.redBright('Tests failed'));
+            console.log(chalk.redBright("Tests failed"));
         }
         else {
-            console.log(chalk.greenBright('Tests passed'));
+            console.log(chalk.greenBright("Tests passed"));
         }
-        console.log(`Done in ${chalk.gray(((Date.now() - this.#startTime) / 1000).toFixed(2) + 's')}`
-            + `, passed ${chalk.greenBright(this.passed)}`
-            + (this.skipped ? `, skipped ${chalk[this.skipped ? 'yellowBright' : 'gray'](this.skipped)}` : '')
-            + (this.failed ? `, failed ${chalk[this.failed ? 'redBright' : 'gray'](this.failed)}` : ''));
+        console.log(`Done in ${chalk.gray(((Date.now() - this.#startTime) / 1000).toFixed(2) + "s")}` +
+            `, passed ${chalk.greenBright(this.passed)}` +
+            (this.skipped
+                ? `, skipped ${chalk[this.skipped ? "yellowBright" : "gray"](this.skipped)}`
+                : "") +
+            (this.failed
+                ? `, failed ${chalk[this.failed ? "redBright" : "gray"](this.failed)}`
+                : ""));
         return this.failed === 0;
     }
     _printStart(file, mode) {
-        this.#curFileIndex++ && console.log('-'.repeat(50));
-        console.log(`Running ${chalk.gray(absToRel(file))} ${mode === 'interpreter' ? '' : chalk.gray(`(${mode})`)}`);
+        this.#curFileIndex++ && console.log("-".repeat(50));
+        console.log(`Running ${chalk.gray(absToRel(file))} ${mode === "interpreter" ? "" : chalk.gray(`(${mode})`)}`);
     }
 }

package/dist/commands/test/test.d.ts

@@ -1,7 +1,7 @@
-import { Reporter } from './reporters/reporter.js';
-import { TestMode } from '../../types.js';
-type ReporterName = 'verbose' | 'files' | 'compact' | 'silent';
-type ReplicaName = 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
+import { Reporter } from "./reporters/reporter.js";
+import { TestMode } from "../../types.js";
+type ReporterName = "verbose" | "files" | "compact" | "silent";
+type ReplicaName = "dfx" | "pocket-ic" | "dfx-pocket-ic";
 type TestOptions = {
     watch: boolean;
     reporter: ReporterName;

package/dist/commands/test/test.js

@@ -1,31 +1,31 @@
-import process from 'node:process';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-import chalk from 'chalk';
-import { globSync } from 'glob';
-import chokidar from 'chokidar';
-import debounce from 'debounce';
-import { SemVer } from 'semver';
-import { sources } from '../sources.js';
-import { getRootDir, readConfig } from '../../mops.js';
-import { parallel } from '../../parallel.js';
-import { MMF1 } from './mmf1.js';
-import { absToRel } from './utils.js';
-import { VerboseReporter } from './reporters/verbose-reporter.js';
-import { FilesReporter } from './reporters/files-reporter.js';
-import { CompactReporter } from './reporters/compact-reporter.js';
-import { SilentReporter } from './reporters/silent-reporter.js';
-import { toolchain } from '../toolchain/index.js';
-import { Replica } from '../replica.js';
-import { PassThrough } from 'node:stream';
-import { getDfxVersion } from '../../helpers/get-dfx-version.js';
+import process from "node:process";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { PassThrough } from "node:stream";
+import chalk from "chalk";
+import { globSync } from "glob";
+import chokidar from "chokidar";
+import debounce from "debounce";
+import { SemVer } from "semver";
+import { sources } from "../sources.js";
+import { getRootDir, readConfig } from "../../mops.js";
+import { parallel } from "../../parallel.js";
+import { MMF1 } from "./mmf1.js";
+import { absToRel, pipeMMF, pipeStderrToMMF, pipeStdoutToMMF, } from "./utils.js";
+import { VerboseReporter } from "./reporters/verbose-reporter.js";
+import { FilesReporter } from "./reporters/files-reporter.js";
+import { CompactReporter } from "./reporters/compact-reporter.js";
+import { SilentReporter } from "./reporters/silent-reporter.js";
+import { toolchain } from "../toolchain/index.js";
+import { Replica } from "../replica.js";
+import { getDfxVersion } from "../../helpers/get-dfx-version.js";
 let ignore = [
-    '**/node_modules/**',
-    '**/.mops/**',
-    '**/.vessel/**',
-    '**/.git/**',
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
 ];
 let globConfig = {
     nocase: true,
@@ -41,18 +41,19 @@ async function startReplicaOnce(replica, type) {
     }
     return replicaStartPromise;
 }
-export async function test(filter = '', options = {}) {
+export async function test(filter = "", options = {}) {
     let config = readConfig();
     let rootDir = getRootDir();
-    let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
-    if (replicaType === 'pocket-ic' && !config.toolchain?.['pocket-ic']) {
+    let replicaType = options.replica ??
+        (config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx");
+    if (replicaType === "pocket-ic" && !config.toolchain?.["pocket-ic"]) {
         let dfxVersion = getDfxVersion();
-        if (!dfxVersion || new SemVer(dfxVersion).compare('0.24.1') < 0) {
-            console.log(chalk.red('Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml'));
+        if (!dfxVersion || new SemVer(dfxVersion).compare("0.24.1") < 0) {
+            console.log(chalk.red("Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml"));
             process.exit(1);
         }
         else {
-            replicaType = 'dfx-pocket-ic';
+            replicaType = "dfx-pocket-ic";
         }
     }
     replica.type = replicaType;
@@ -60,14 +61,14 @@ export async function test(filter = '', options = {}) {
     if (options.watch) {
         replica.ttl = 60 * 15; // 15 minutes
         let sigint = false;
-        process.on('SIGINT', () => {
+        process.on("SIGINT", () => {
             if (sigint) {
-                console.log('Force exit');
+                console.log("Force exit");
                 process.exit(0);
             }
             sigint = true;
             if (replicaStartPromise) {
-                console.log('Stopping replica...');
+                console.log("Stopping replica...");
                 replica.stop(true).then(() => {
                     process.exit(0);
                 });
@@ -84,22 +85,19 @@ export async function test(filter = '', options = {}) {
             controller.abort();
             await curRun;
             console.clear();
-            process.stdout.write('\x1Bc');
+            process.stdout.write("\x1Bc");
             controller = new AbortController();
             curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
             await curRun;
-            console.log('-'.repeat(50));
-            console.log('Waiting for file changes...');
-            console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
+            console.log("-".repeat(50));
+            console.log("Waiting for file changes...");
+            console.log(chalk.gray(`Press ${chalk.gray("Ctrl+C")} to exit.`));
         }, 200);
-        let watcher = chokidar.watch([
-            path.join(rootDir, '**/*.mo'),
-            path.join(rootDir, 'mops.toml'),
-        ], {
+        let watcher = chokidar.watch([path.join(rootDir, "**/*.mo"), path.join(rootDir, "mops.toml")], {
             ignored: ignore,
             ignoreInitial: true,
         });
-        watcher.on('all', () => {
+        watcher.on("all", () => {
             run();
         });
         run();
@@ -111,21 +109,21 @@ export async function test(filter = '', options = {}) {
         }
     }
 }
-let mocPath = '';
-let wasmtimePath = '';
-async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false, signal) {
+let mocPath = "";
+let wasmtimePath = "";
+async function runAll(reporterName, filter = "", mode = "interpreter", replicaType, watch = false, signal) {
     let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
     return done;
 }
-export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false, signal) {
+export async function testWithReporter(reporterName, filter = "", defaultMode = "interpreter", replicaType, watch = false, signal) {
     let rootDir = getRootDir();
     let files = [];
-    let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
+    let libFiles = globSync("**/test?(s)/lib.mo", globConfig);
     if (libFiles[0]) {
         files = [libFiles[0]];
     }
     else {
-        let globStr = '**/test?(s)/**/*.test.mo';
+        let globStr = "**/test?(s)/**/*.test.mo";
         if (filter) {
             globStr = `**/test?(s)/**/*${filter}*.mo`;
         }
@@ -136,26 +134,26 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
             console.log(`No test files found for filter '${filter}'`);
             return false;
         }
-        console.log('No test files found');
-        console.log('Put your tests in \'test\' directory in *.test.mo files');
+        console.log("No test files found");
+        console.log("Put your tests in 'test' directory in *.test.mo files");
         return false;
     }
     let reporter;
-    if (!reporterName || typeof reporterName === 'string') {
+    if (!reporterName || typeof reporterName === "string") {
         if (!reporterName) {
-            reporterName = files.length > 1 ? 'files' : 'verbose';
+            reporterName = files.length > 1 ? "files" : "verbose";
         }
-        if (reporterName == 'compact') {
-            reporter = new CompactReporter;
+        if (reporterName == "compact") {
+            reporter = new CompactReporter();
         }
-        else if (reporterName == 'files') {
-            reporter = new FilesReporter;
+        else if (reporterName == "files") {
+            reporter = new FilesReporter();
         }
-        else if (reporterName == 'silent') {
-            reporter = new SilentReporter;
+        else if (reporterName == "silent") {
+            reporter = new SilentReporter();
         }
         else {
-            reporter = new VerboseReporter;
+            reporter = new VerboseReporter();
         }
     }
     else {
@@ -165,45 +163,59 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     let config = readConfig();
     let sourcesArr = await sources();
     if (!mocPath) {
-        mocPath = await toolchain.bin('moc', { fallback: true });
+        mocPath = await toolchain.bin("moc", { fallback: true });
     }
-    let testTempDir = path.join(getRootDir(), '.mops/.test/');
+    let testTempDir = path.join(getRootDir(), ".mops/.test/");
     replica.dir = testTempDir;
     fs.rmSync(testTempDir, { recursive: true, force: true });
     fs.mkdirSync(testTempDir, { recursive: true });
-    await parallel(os.cpus().length, files, async (file) => {
-        if (signal?.aborted) {
-            return;
-        }
-        let mmf = new MMF1('store', absToRel(file));
-        // mode overrides
-        let lines = fs.readFileSync(file, 'utf8').split('\n');
+    let filesWithMode = files.map((file) => {
+        let lines = fs.readFileSync(file, "utf8").split("\n");
         let mode = defaultMode;
-        if (lines.includes('// @testmode wasi')) {
-            mode = 'wasi';
+        if (lines.includes("// @testmode wasi")) {
+            mode = "wasi";
         }
-        else if (lines.includes('// @testmode replica') || lines.find(line => line.match(/^(persistent )?actor( class)?/))) {
-            mode = 'replica';
+        else if (lines.includes("// @testmode replica") ||
+            lines.find((line) => line.match(/^(persistent )?actor( class)?/))) {
+            mode = "replica";
         }
-        if (mode === 'wasi' && !wasmtimePath) {
-            // ensure wasmtime is installed or specified in config
-            if (config.toolchain?.wasmtime) {
-                wasmtimePath = await toolchain.bin('wasmtime');
-            }
-            // fallback wasmtime to global binary if not specified in config (legacy)
-            else {
-                wasmtimePath = 'wasmtime';
-                console.log(chalk.yellow('Warning:'), 'Wasmtime is not specified in config. Using global binary "wasmtime". This will be removed in the future.');
-                console.log(`Run ${chalk.green('mops toolchain use wasmtime')} or add ${chalk.green('wasmtime = "<version>"')} in mops.toml to avoid breaking changes with future versions of mops.`);
-            }
+        return { file, mode };
+    });
+    let hasWasiTests = filesWithMode.some(({ mode }) => mode === "wasi");
+    let hasReplicaTests = filesWithMode.some(({ mode }) => mode === "replica");
+    // prepare wasmtime path
+    if (hasWasiTests && !wasmtimePath) {
+        // ensure wasmtime is installed or specified in config
+        if (config.toolchain?.wasmtime) {
+            wasmtimePath = await toolchain.bin("wasmtime");
+        }
+        // fallback wasmtime to global binary if not specified in config (legacy)
+        else {
+            wasmtimePath = "wasmtime";
+            console.log(chalk.yellow("Warning:"), 'Wasmtime is not specified in config. Using global binary "wasmtime". This will be removed in the future.');
+            console.log(`Run ${chalk.green("mops toolchain use wasmtime")} or add ${chalk.green('wasmtime = "<version>"')} in mops.toml to avoid breaking changes with future versions of mops.`);
+        }
+    }
+    let runTestFile = async ({ file, mode, }) => {
+        if (signal?.aborted) {
+            return;
         }
+        // print logs immediately for replica tests because we run them one-by-one
+        let mmf = new MMF1(mode === "replica" ? "print" : "store", absToRel(file));
         let promise = new Promise((resolve) => {
-            let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
+            let mocArgs = [
+                "--hide-warnings",
+                "--error-detail=2",
+                ...sourcesArr.join(" ").split(" "),
+                file,
+            ].filter((x) => x);
             // interpret
-            if (mode === 'interpreter') {
-                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs], { signal });
-                proc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+            if (mode === "interpreter") {
+                let proc = spawn(mocPath, ["-r", "-ref-system-api", ...mocArgs], {
+                    signal,
+                });
+                proc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
@@ -211,63 +223,76 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                 pipeMMF(proc, mmf).then(resolve);
             }
             // build and run wasm
-            else if (mode === 'wasi') {
+            else if (mode === "wasi") {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs], { signal });
-                buildProc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, "-wasi-system-api", ...mocArgs], { signal });
+                buildProc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf).then(async () => {
+                pipeMMF(buildProc, mmf)
+                    .then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
                     // run
                     let wasmtimeArgs = [];
-                    if (config.toolchain?.wasmtime && config.toolchain?.wasmtime >= '14.0.0') {
+                    if (config.toolchain?.wasmtime &&
+                        config.toolchain?.wasmtime >= "14.0.0") {
                         wasmtimeArgs = [
-                            '-S', 'preview2=n',
-                            '-C', 'cache=n',
-                            '-W', 'bulk-memory',
-                            '-W', 'multi-memory',
-                            '-W', 'memory64',
-                            '-W', 'max-wasm-stack=4000000',
-                            '-W', 'nan-canonicalization=y',
+                            "-S",
+                            "preview2=n",
+                            "-C",
+                            "cache=n",
+                            "-W",
+                            "bulk-memory",
+                            "-W",
+                            "multi-memory",
+                            "-W",
+                            "memory64",
+                            "-W",
+                            "max-wasm-stack=4000000",
+                            "-W",
+                            "nan-canonicalization=y",
                             wasmFile,
                         ];
                     }
                     else {
-                        console.error(chalk.red('Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version'));
+                        console.error(chalk.red("Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version"));
                         process.exit(1);
                     }
                     let proc = spawn(wasmtimePath, wasmtimeArgs, { signal });
-                    proc.addListener('error', (error) => {
-                        if (error?.code === 'ABORT_ERR') {
+                    proc.addListener("error", (error) => {
+                        if (error?.code === "ABORT_ERR") {
                             return;
                         }
                         throw error;
                     });
                     await pipeMMF(proc, mmf);
-                }).finally(() => {
+                })
+                    .finally(() => {
                     fs.rmSync(wasmFile, { force: true });
-                }).then(resolve);
+                })
+                    .then(resolve);
             }
             // build and execute in replica
-            else if (mode === 'replica') {
-                // mmf.strategy = 'print'; // because we run replica tests one-by-one
+            else if (mode === "replica") {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], { signal });
-                buildProc.addListener('error', (error) => {
-                    if (error?.code === 'ABORT_ERR') {
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], {
+                    signal,
+                });
+                buildProc.addListener("error", (error) => {
+                    if (error?.code === "ABORT_ERR") {
                         return;
                     }
                     throw error;
                 });
-                pipeMMF(buildProc, mmf).then(async () => {
+                pipeMMF(buildProc, mmf)
+                    .then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
@@ -277,14 +302,14 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                     }
                     let canisterName = path.parse(file).name;
                     let idlFactory = ({ IDL }) => {
-                        return IDL.Service({ 'runTests': IDL.Func([], [], []) });
+                        return IDL.Service({ runTests: IDL.Func([], [], []) });
                     };
                     let canister = await replica.deploy(canisterName, wasmFile, idlFactory, undefined, signal);
                     if (signal?.aborted || !canister) {
                         return;
                     }
                     pipeStdoutToMMF(canister.stream, mmf);
-                    let actor = await replica.getActor(canisterName);
+                    let actor = (await replica.getActor(canisterName));
                     try {
                         if (globalThis.mopsReplicaTestRunning) {
                             await new Promise((resolve) => {
@@ -293,7 +318,7 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                                         resolve();
                                         clearInterval(timerId);
                                     }
-                                }, Math.random() * 1000 | 0);
+                                }, (Math.random() * 1000) | 0);
                             });
                         }
                         if (signal?.aborted) {
@@ -309,10 +334,12 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         pipeStderrToMMF(stderrStream, mmf, path.dirname(file));
                         stderrStream.write(e.message);
                     }
-                }).finally(async () => {
+                })
+                    .finally(async () => {
                     globalThis.mopsReplicaTestRunning = false;
                     fs.rmSync(wasmFile, { force: true });
-                }).then(resolve);
+                })
+                    .then(resolve);
             }
         });
         if (signal?.aborted) {
@@ -320,8 +347,10 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
         }
         reporter.addRun(file, mmf, promise, mode);
         await promise;
-    });
-    if (replicaStartPromise && !watch) {
+    };
+    await parallel(os.cpus().length, filesWithMode.filter(({ mode }) => mode !== "replica"), runTestFile);
+    await parallel(1, filesWithMode.filter(({ mode }) => mode === "replica"), runTestFile);
+    if (hasReplicaTests && !watch) {
         await replica.stop();
         fs.rmSync(testTempDir, { recursive: true, force: true });
     }
@@ -330,62 +359,3 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     }
     return reporter.done();
 }
-function pipeStdoutToMMF(stdout, mmf) {
-    stdout.on('data', (data) => {
-        for (let line of data.toString().split('\n')) {
-            line = line.trim();
-            if (line) {
-                mmf.parseLine(line);
-            }
-        }
-    });
-}
-function pipeStderrToMMF(stderr, mmf, dir = '') {
-    stderr.on('data', (data) => {
-        let text = data.toString().trim();
-        let failedLine = '';
-        text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
-            // change absolute file path to relative
-            // change :line:col-line:col to :line:col to work in vscode
-            let res = `${absToRel(m1)}:${m2}:${m3}`;
-            let file = path.join(dir, m1);
-            if (!fs.existsSync(file)) {
-                return res;
-            }
-            // show failed line
-            let content = fs.readFileSync(file);
-            let lines = content.toString().split('\n') || [];
-            failedLine += chalk.dim('\n   ...');
-            let lineBefore = lines[+m2 - 2];
-            if (lineBefore) {
-                failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
-            }
-            failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
-            if (lines.length > +m2) {
-                failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
-            }
-            failedLine += chalk.dim('\n   ...');
-            return res;
-        });
-        if (failedLine) {
-            text += failedLine;
-        }
-        mmf.fail(text);
-    });
-}
-function pipeMMF(proc, mmf) {
-    return new Promise((resolve) => {
-        pipeStdoutToMMF(proc.stdout, mmf);
-        pipeStderrToMMF(proc.stderr, mmf);
-        // exit
-        proc.on('close', (code) => {
-            if (code === 0) {
-                mmf.strategy !== 'print' && mmf.pass();
-            }
-            else if (code !== 1) {
-                mmf.fail(`unknown exit code: ${code}`);
-            }
-            resolve();
-        });
-    });
-}

package/dist/commands/test/utils.d.ts

@@ -1 +1,7 @@
+import { ChildProcessWithoutNullStreams } from "node:child_process";
+import { Readable } from "node:stream";
+import { MMF1 } from "./mmf1.js";
 export declare function absToRel(p: string): string;
+export declare function pipeStdoutToMMF(stdout: Readable, mmf: MMF1): void;
+export declare function pipeStderrToMMF(stderr: Readable, mmf: MMF1, dir?: string): void;
+export declare function pipeMMF(proc: ChildProcessWithoutNullStreams, mmf: MMF1): Promise<void>;

package/dist/commands/test/utils.js

@@ -1,6 +1,67 @@
-import path from 'node:path';
-import { getRootDir } from '../../mops.js';
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
+import { getRootDir } from "../../mops.js";
 export function absToRel(p) {
     let rootDir = getRootDir();
     return path.relative(rootDir, path.resolve(p));
 }
+export function pipeStdoutToMMF(stdout, mmf) {
+    stdout.on("data", (data) => {
+        for (let line of data.toString().split("\n")) {
+            line = line.trim();
+            if (line) {
+                mmf.parseLine(line);
+            }
+        }
+    });
+}
+export function pipeStderrToMMF(stderr, mmf, dir = "") {
+    stderr.on("data", (data) => {
+        let text = data.toString().trim();
+        let failedLine = "";
+        text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
+            // change absolute file path to relative
+            // change :line:col-line:col to :line:col to work in vscode
+            let res = `${absToRel(m1)}:${m2}:${m3}`;
+            let file = path.join(dir, m1);
+            if (!fs.existsSync(file)) {
+                return res;
+            }
+            // show failed line
+            let content = fs.readFileSync(file);
+            let lines = content.toString().split("\n") || [];
+            failedLine += chalk.dim("\n   ...");
+            let lineBefore = lines[+m2 - 2];
+            if (lineBefore) {
+                failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll("\t", "  ")}`);
+            }
+            failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll("\t", "  ")}`;
+            if (lines.length > +m2) {
+                failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll("\t", "  ")}`);
+            }
+            failedLine += chalk.dim("\n   ...");
+            return res;
+        });
+        if (failedLine) {
+            text += failedLine;
+        }
+        mmf.fail(text);
+    });
+}
+export function pipeMMF(proc, mmf) {
+    return new Promise((resolve) => {
+        pipeStdoutToMMF(proc.stdout, mmf);
+        pipeStderrToMMF(proc.stderr, mmf);
+        // exit
+        proc.on("close", (code) => {
+            if (code === 0) {
+                mmf.strategy !== "print" && mmf.pass();
+            }
+            else if (code !== 1) {
+                mmf.fail(`unknown exit code: ${code}`);
+            }
+            resolve();
+        });
+    });
+}