mops watch

backend/main/registry/getDefaultPackages.mo

@@ -37,6 +37,7 @@ module {
 			case ("0.20.2") [("base", "0.11.1")];
 			case ("0.21.0") [("base", "0.11.1")];
 			case ("0.22.0") [("base", "0.11.2")];
+			case ("0.23.0") [("base", "0.11.2")];
 			case (_) {
 				switch (registry.getHighestVersion("base")) {
 					case (?ver) [("base", ver)];

cli/cli.ts

@@ -25,6 +25,7 @@ import {toolchain} from './commands/toolchain/index.js';
 import {Tool} from './types.js';
 import * as self from './commands/self.js';
 import {resolvePackages} from './resolve-packages.js';
+import {watch} from './commands/watch/watch.js';
 
 declare global {
 	// eslint-disable-next-line no-var
@@ -392,4 +393,18 @@ selfCommand
 
 program.addCommand(selfCommand);
 
+// watch
+program
+	.command('watch')
+	.description('Watch *.mo files and check for syntax errors, warnings, run tests, generate declarations and deploy canisters')
+	.option('-e, --error', 'Check Motoko canisters or *.mo files for syntax errors')
+	.option('-w, --warning', 'Check Motoko canisters or *.mo files for warnings')
+	.option('-t, --test', 'Run tests')
+	.option('-g, --generate', 'Generate declarations for Motoko canisters')
+	.option('-d, --deploy', 'Deploy Motoko canisters')
+	.action(async (options) => {
+		checkConfigFile(true);
+		await watch(options);
+	});
+
 program.parse();

cli/commands/test/mmf1.ts

@@ -53,6 +53,10 @@ export class MMF1 {
 		this.output = [];
 	}
 
+	getErrorMessages() {
+		return this.output.filter(out => out.type === 'fail').map(out => out.message);
+	}
+
 	parseLine(line : string) {
 		if (line.startsWith('mops:1:start ')) {
 			this._testStart(line.split('mops:1:start ')[1] || '');

cli/commands/test/reporters/silent-reporter.ts

@@ -5,14 +5,25 @@ import {Reporter} from './reporter.js';
 import {TestMode} from '../../../types.js';
 
 export class SilentReporter implements Reporter {
+	total = 0;
 	passed = 0;
 	failed = 0;
 	skipped = 0;
 	passedFiles = 0;
 	failedFiles = 0;
 	passedNamesFlat : string[] = [];
+	flushOnError = true;
+	errorOutput = '';
+	onProgress = () => {};
 
-	addFiles(_files : string[]) {}
+	constructor(flushOnError = true, onProgress = () => {}) {
+		this.flushOnError = flushOnError;
+		this.onProgress = onProgress;
+	}
+
+	addFiles(files : string[]) {
+		this.total = files.length;
+	}
 
 	addRun(file : string, mmf : MMF1, state : Promise<void>, _mode : TestMode) {
 		state.then(() => {
@@ -30,10 +41,17 @@ export class SilentReporter implements Reporter {
 			this.failedFiles += Number(mmf.failed !== 0);
 
 			if (mmf.failed) {
-				console.log(chalk.red('✖'), absToRel(file));
-				mmf.flush('fail');
-				console.log('-'.repeat(50));
+				let output = `${chalk.red('✖'), absToRel(file)}\n${mmf.getErrorMessages().join('\n')}\n${'-'.repeat(50)}`;
+
+				if (this.flushOnError) {
+					console.log(output);
+				}
+				else {
+					this.errorOutput = `${this.errorOutput}\n${output}`.trim();
+				}
 			}
+
+			this.onProgress();
 		});
 	}
 

cli/commands/test/test.ts

@@ -127,7 +127,7 @@ async function runAll(reporterName : ReporterName | undefined, filter = '', mode
 	return done;
 }
 
-export async function testWithReporter(reporterName : ReporterName | Reporter | undefined, filter = '', defaultMode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false) : Promise<boolean> {
+export async function testWithReporter(reporterName : ReporterName | Reporter | undefined, filter = '', defaultMode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false, signal ?: AbortSignal) : Promise<boolean> {
 	let rootDir = getRootDir();
 	let files : string[] = [];
 	let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -274,6 +274,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 
 					await startReplicaOnce(replica, replicaType);
 
+					if (signal?.aborted) {
+						return;
+					}
+
 					let canisterName = path.parse(file).name;
 					let idlFactory = ({IDL} : any) => {
 						return IDL.Service({'runTests': IDL.Func([], [], [])});
@@ -282,6 +286,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 
 					let {stream} = await replica.deploy(canisterName, wasmFile, idlFactory);
 
+					if (signal?.aborted) {
+						return;
+					}
+
 					pipeStdoutToMMF(stream, mmf);
 
 					let actor = await replica.getActor(canisterName) as _SERVICE;
@@ -298,6 +306,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 							});
 						}
 
+						if (signal?.aborted) {
+							return;
+						}
+
 						globalThis.mopsReplicaTestRunning = true;
 						await actor.runTests();
 						globalThis.mopsReplicaTestRunning = false;
@@ -315,6 +327,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 			}
 		});
 
+		if (signal?.aborted) {
+			return;
+		}
+
 		reporter.addRun(file, mmf, promise, mode);
 
 		await promise;

cli/commands/watch/deployer.ts

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import os from 'node:os';
+import {promisify} from 'node:util';
+import {exec, execSync} from 'node:child_process';
+
+import {ErrorChecker} from './error-checker.js';
+import {Generator} from './generator.js';
+import {parallel} from '../../parallel.js';
+import {getRootDir} from '../../mops.js';
+
+export class Deployer {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success' = 'pending';
+	errorChecker : ErrorChecker;
+	generator : Generator;
+	success = 0;
+	errors : string[] = [];
+	aborted = false;
+	controllers = new Map<string, AbortController>();
+	currentRun : Promise<any> | undefined;
+
+	constructor({verbose, canisters, errorChecker, generator} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker, generator : Generator}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+		this.errorChecker = errorChecker;
+		this.generator = generator;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.success = 0;
+		this.errors = [];
+	}
+
+	async abortCurrent() {
+		this.aborted = true;
+		for (let controller of this.controllers.values()) {
+			controller.abort();
+		}
+		this.controllers.clear();
+		await this.currentRun;
+		this.reset();
+		this.aborted = false;
+	}
+
+	async run(onProgress : () => void) {
+		await this.abortCurrent();
+
+		if (this.errorChecker.status === 'error') {
+			this.status = 'syntax-error';
+			onProgress();
+			return;
+		}
+
+		if (Object.keys(this.canisters).length === 0) {
+			this.status = 'success';
+			onProgress();
+			return;
+		}
+
+		let rootDir = getRootDir();
+
+		try {
+			execSync('dfx ping', {cwd: rootDir});
+		}
+		catch (error) {
+			this.status = 'dfx-error';
+			onProgress();
+			return;
+		}
+
+		this.status = 'running';
+		onProgress();
+
+		// create canisters (sequentially to avoid DFX errors)
+		let resolve : (() => void) | undefined;
+		this.currentRun = new Promise<void>((res) => resolve = res);
+		for (let canister of Object.keys(this.canisters)) {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(canister, controller);
+
+			await promisify(exec)(`dfx canister create ${canister}`, {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			this.controllers.delete(canister);
+		}
+
+		resolve?.();
+
+		if (this.aborted) {
+			return;
+		}
+
+		this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
+			let controller = new AbortController();
+			let {signal} = controller;
+			this.controllers.set(canister, controller);
+
+			// build
+			if (this.generator.status !== 'success') {
+				await promisify(exec)(`dfx build ${canister}`, {cwd: rootDir, signal}).catch((error) => {
+					if (error.code === 'ABORT_ERR') {
+						return {stderr: ''};
+					}
+					throw error;
+				});
+			}
+
+			// install
+			await promisify(exec)(`dfx canister install --mode=auto ${canister}`, {cwd: rootDir, signal}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			this.success += 1;
+			this.controllers.delete(canister);
+			onProgress();
+		});
+
+		await this.currentRun;
+
+		if (!this.aborted) {
+			this.status = 'success';
+		}
+		onProgress();
+	}
+
+	getOutput() : string {
+		let get = (v : number) => v.toString();
+		let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
+
+		if (this.status === 'pending') {
+			return `Deploy: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
+		}
+		if (this.status === 'syntax-error') {
+			return `Deploy: ${chalk.gray('(errors)')}`;
+		}
+		if (this.status === 'dfx-error') {
+			return `Deploy: ${chalk.gray('(dfx not running)')}`;
+		}
+
+		return `Deploy: ${count}`;
+	}
+}

cli/commands/watch/error-checker.ts

@@ -0,0 +1,87 @@
+import {exec} from 'node:child_process';
+import {promisify} from 'node:util';
+import os from 'node:os';
+import chalk from 'chalk';
+
+import {getMocPath} from '../../helpers/get-moc-path.js';
+import {getRootDir} from '../../mops.js';
+import {sources} from '../sources.js';
+import {parallel} from '../../parallel.js';
+import {globMoFiles} from './globMoFiles.js';
+
+export class ErrorChecker {
+	verbose = false;
+	canisters : Record<string, string> = {};
+	status : 'pending' | 'running' | 'error' | 'success' = 'pending';
+	errors : string[] = [];
+
+	constructor({verbose, canisters} : {verbose : boolean, canisters : Record<string, string>}) {
+		this.verbose = verbose;
+		this.canisters = canisters;
+	}
+
+	reset() {
+		this.status = 'pending';
+		this.errors = [];
+	}
+
+	async run(onProgress : () => void) {
+		this.reset();
+
+		this.status = 'running';
+		onProgress();
+
+		let rootDir = getRootDir();
+		let mocPath = getMocPath();
+		let deps = await sources({cwd: rootDir});
+
+		let paths = [...Object.values(this.canisters)];
+		if (!paths.length) {
+			paths = globMoFiles(rootDir);
+		}
+
+		await parallel(os.cpus().length, paths, async (file) => {
+			try {
+				await promisify(exec)(`${mocPath} --check ${deps.join(' ')} ${file}`, {cwd: rootDir});
+			}
+			catch (error : any) {
+				error.message.split('\n').forEach((line : string) => {
+					if (line.match(/: \w+ error \[/)) {
+						// better formatting
+						let str = line
+							.replace(/: (\w+ error) \[/, (_, m1) => `: ${chalk.red(m1)} [`)
+							.replace(/unbound type (\w+)/, `unbound type ${chalk.bold('$1')}`)
+							.replace(/unbound variable (\w+)/, `unbound variable ${chalk.bold('$1')}`)
+							.trim();
+						this.errors.push(str);
+					}
+					else if (line.startsWith('  ') && this.errors.length) {
+						this.errors[this.errors.length - 1] += '\n  ' + line;
+					}
+					else {
+						// console.log('UNKNOWN ERROR', line);
+					}
+				});
+				onProgress();
+			}
+		});
+
+		this.status = this.errors.length ? 'error' : 'success';
+		onProgress();
+	}
+
+	getOutput() : string {
+		if (this.status === 'pending') {
+			return `Errors: ${chalk.gray('(pending)')}`;
+		}
+		if (this.status === 'running') {
+			return `Errors: ${chalk.gray('(running)')}`;
+		}
+		let output = '';
+		output += `Errors: ${chalk.bold[this.errors.length ? 'redBright' : 'green'](this.errors.length)}`;
+		if (this.verbose && this.errors.length) {
+			output += `\n  ${this.errors.join('\n  ')}`;
+		}
+		return output;
+	}
+}