@taqueria/plugin-ligo 0.40.0 → 0.40.4

package/common.ts

@@ -38,8 +38,29 @@ export const getInputFilenameAbsPath = (parsedArgs: UnionOpts, sourceFile: strin
 export const getInputFilenameRelPath = (parsedArgs: UnionOpts, sourceFile: string): string =>
 	join(parsedArgs.config.contractsDir ?? 'contracts', sourceFile);
 
-export const emitExternalError = (err: unknown, sourceFile: string): void => {
+export const formatLigoError = (err: Error): Error => {
+	let result = err.message.replace(/Command failed.+?\n/, '');
+	if (
+		result.includes('An internal error ocurred. Please, contact the developers.')
+		&& result.includes('Module Contract not found with last Contract.')
+	) {
+		result =
+			`The contract must be imported with "Contract" as the namespace: #import "path/to/contract.ligo" "Contract"`;
+	}
+
+	err.message = result.replace(
+		'An internal error ocurred. Please, contact the developers.',
+		'The LIGO compiler experienced an internal error. Please contact the LIGO developers.',
+	);
+
+	return err;
+};
+
+export const emitExternalError = (errs: unknown[] | unknown, sourceFile: string): void => {
 	sendErr(`\n=== Error messages for ${sourceFile} ===`);
-	err instanceof Error ? sendErr(err.message.replace(/Command failed.+?\n/, '')) : sendErr(err as any);
-	sendErr(`\n===`);
+	const errors = Array.isArray(errs) ? errs : [errs];
+	errors.map(err => {
+		err instanceof Error ? sendErr(err.message) : sendErr(err as any);
+	});
+	sendErr(`===`);
 };

package/compile.ts

@@ -8,26 +8,31 @@ import {
 	sendRes,
 	sendWarn,
 } from '@taqueria/node-sdk';
+import { createReadStream } from 'fs';
 import { access, readFile, writeFile } from 'fs/promises';
 import { basename, extname, join } from 'path';
+import * as readline from 'readline';
 import {
 	CompileOpts as Opts,
 	emitExternalError,
+	formatLigoError,
 	getInputFilenameAbsPath,
 	getInputFilenameRelPath,
 	getLigoDockerImage,
 	UnionOpts,
 } from './common';
 
-export type TableRow = { source: string; artifact: string };
+export type TableRow = { source: string; artifact: string; err?: unknown };
 
 export type ExprKind = 'storage' | 'default_storage' | 'parameter';
 
+export type Syntax = 'mligo' | 'jsligo' | 'religo' | 'ligo';
+
 export type ModuleInfo = {
 	moduleName: string;
 	sourceName: string;
 	sourceFile: string;
-	syntax: 'mligo' | 'jsligo' | 'religo' | 'ligo';
+	syntax: Syntax;
 	type: 'file-main' | 'file-entry' | 'module-main' | 'module-entry';
 };
 
@@ -215,259 +220,152 @@ const compileExpr =
 				};
 			})
 			.catch(err => {
-				emitExternalError(err, sourceFile);
 				return {
 					source: module.sourceName,
-					artifact: `${sourceFile} not compiled`,
+					artifact: `${exprName} in ${sourceFile} not compiled`,
+					err,
 				};
 			});
 	};
 
-const getExprNames = (parsedArgs: Opts, sourceFile: string): Promise<string[]> =>
-	readFile(getInputFilenameAbsPath(parsedArgs, sourceFile), 'utf8')
-		.then(data => data.match(/(?<=\n\s*(let|const)\s+)[a-zA-Z0-9_]+/g) ?? []);
+const getExprNames = (parsedArgs: Opts, sourceFile: string): Promise<string[]> => {
+	return new Promise((resolve, reject) => {
+		const inputFilePath = getInputFilenameAbsPath(parsedArgs, sourceFile);
+		const readInterface = readline.createInterface({
+			input: createReadStream(inputFilePath),
+			output: process.stdout,
+		});
+
+		const variableNames: string[] = [];
+
+		readInterface.on('line', function(line) {
+			// Skip lines that start with a comment
+			if (!line.trim().startsWith('//')) {
+				const matches = line.match(/(?<=\s*(let|const)\s+)[a-zA-Z0-9_]+/g);
+				if (matches) {
+					variableNames.push(...matches);
+				}
+			}
+		});
 
-const compileExprs = (
+		readInterface.on('close', function() {
+			resolve(variableNames);
+		});
+	});
+};
+
+const compileExprs = async (
 	parsedArgs: Opts,
 	sourceFile: string,
 	module: ModuleInfo,
 	exprKind: ExprKind,
-): Promise<TableRow[]> =>
-	getExprNames(parsedArgs, sourceFile)
-		.then(exprNames => {
-			if (exprNames.length === 0) return [];
-			const firstExprName = exprNames.slice(0, 1)[0];
-			const restExprNames = exprNames.slice(1, exprNames.length);
-			const firstExprKind = isStorageKind(exprKind) ? 'default_storage' : 'parameter';
-			const restExprKind = isStorageKind(exprKind) ? 'storage' : 'parameter';
-			const firstExprResult = compileExpr(parsedArgs, sourceFile, module, firstExprKind)(firstExprName);
-			const restExprResults = restExprNames.map(compileExpr(parsedArgs, sourceFile, module, restExprKind));
-			return Promise.all([firstExprResult].concat(restExprResults));
-		})
-		.catch(err => {
-			emitExternalError(err, sourceFile);
-			return [{
-				source: module.sourceName,
-				artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} expressions compiled`,
-			}];
-		})
-		.then(results =>
-			results.length > 0 ? results : [{
-				source: module.sourceName,
-				artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} expressions found`,
-			}]
-		);
+): Promise<TableRow[]> => {
+	// Get expressions from file
+	let exprs = [];
+	try {
+		exprs = await getExprNames(parsedArgs, sourceFile);
+	} catch (err) {
+		emitExternalError(err, sourceFile);
+		return [{
+			source: module.sourceName,
+			artifact: `No ${isStorageKind(exprKind) ? 'storage' : 'parameter'} expressions compiled`,
+		}];
+	}
 
-const initContentForStorage = (module: ModuleInfo): string => {
-	const linkToContract = `#import "${module.sourceFile}" "Contract"\n\n`;
-	const instruction =
-		'// Define your initial storage values as a list of LIGO variable definitions, the first of which will be considered the default value to be used for origination later on\n';
-
-	const syntax = (() => {
-		const pair = [module.syntax, module.type].join('-');
-		switch (pair) {
-			case 'mligo-file-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. let storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract',
-					'// E.g. let storage : Contract.storage = 10',
-				];
-				break;
-			case 'mligo-file-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. let storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract',
-					'// E.g. let storage : Contract.storage = 10',
-				];
-				break;
-			case 'mligo-module-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. let storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract',
-					`// E.g. let storage : Contract.${module.moduleName}.storage = 10`,
-				];
-				break;
-			case 'mligo-module-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. let storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract',
-					`// E.g. let storage : Contract.${module.moduleName}.storage = 10`,
-				];
-				break;
-			case 'jsligo-file-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.',
-					`// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. const storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.',
-					'// E.g. const storage : Contract.storage = 10',
-				];
-				break;
-			case 'jsligo-file-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a namespace. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. const storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.',
-					'// E.g. const storage : Contract.storage = 10',
-				];
-				break;
-			case 'jsligo-module-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.',
-					`// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. const storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.',
-					`// E.g. const storage : Contract.${module.moduleName}.storage = 10`,
-				];
-				break;
-			case 'jsligo-module-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a namespace. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your storage is a simple value, you can define it directly',
-					'// E.g. const storage = 10',
-					'',
-					'// For added type-safety, you can reference the type of your storage from the contract. This assumes that you have exported your `storage` type from the contract file.',
-					`// E.g. const storage : Contract.${module.moduleName}.storage = 10`,
-				];
-				break;
-			default:
-				return [];
-		}
-	})();
-	return linkToContract + instruction + syntax.join('\n');
+	const results = await Promise.all(exprs.map(async (exprName, index) => {
+		const compileResult = await compileExpr(
+			parsedArgs,
+			sourceFile,
+			module,
+			exprKind === 'storage' && index === 0 ? 'default_storage' : exprKind,
+		)(exprName);
+		return compileResult;
+	}));
+
+	// Collect errors
+	const errors = results.reduce(
+		(acc, result) => {
+			if (result.err) {
+				// If its not an Error object, then just add it to the list
+				if (!(result.err instanceof Error)) return [...acc, result.err];
+
+				// Otherwise, get all ligo errors and ensure that the list is unique
+				const ligoErrs = (acc
+					.filter(err => err instanceof Error) as Error[])
+					.map(err => err.message);
+
+				const formattedError = formatLigoError(result.err);
+
+				return (ligoErrs.includes(formattedError.message)) ? acc : [...acc, formattedError];
+			}
+			return acc;
+		},
+		[] as unknown[],
+	);
+
+	// Collect table rows
+	const retval = results.map(({ source, artifact }) => ({ source, artifact }));
+
+	if (errors.length) emitExternalError(errors, sourceFile);
+
+	return retval;
 };
 
-const initContentForParameter = (module: ModuleInfo): string => {
-	const linkToContract = `#import "${module.sourceFile}" "Contract"\n\n`;
-	const instruction = '// Define your parameter values as a list of LIGO variable definitions\n';
-
-	const syntax = (() => {
-		const pair = [module.syntax, module.type].join('-');
-		switch (pair) {
-			case 'mligo-file-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. let default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					'// E.g. let default_parameter : Contract.parameter = 10',
-				];
-				break;
-			case 'mligo-file-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. let default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					'// E.g. let default_parameter : parameter_of Contract = 10',
-				];
-				break;
-			case 'mligo-module-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. let default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					`// E.g. let default_parameter : Contract.${module.moduleName}.parameter = 10`,
-				];
-				break;
-			case 'mligo-module-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a named module. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. let default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					`// E.g. let default_parameter : parameter_of Contract.${module.moduleName} = 10`,
-				];
-				break;
-			case 'jsligo-file-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.',
-					`// NOTE: The "parameter" type should be exported from the contract file (${module.sourceFile})`,
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. const default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					'// E.g. const default_parameter : Contract.parameter = 10',
-				];
-				break;
-			case 'jsligo-file-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was not within a namespace. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. const default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					'// E.g. const default_parameter : parameter_of Contract = 10',
-				];
-				break;
-			case 'jsligo-module-main':
-				return [
-					'// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.',
-					`// NOTE: The "parameter" type should be exported from the contract file (${module.sourceFile})`,
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. const default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					`// E.g. const default_parameter : Contract.${module.moduleName}.parameter = 10`,
-				];
-				break;
-			case 'jsligo-module-entry':
-				return [
-					'// When this file was created, the smart contract was defined with an entrypoint using `@entry` that was within a namespace. As such, the examples below are written with that assumption in mind.',
-					'',
-					'// If your parameter is a simple value, you can define it directly',
-					'// E.g. const default_parameter = 10',
-					'',
-					'// For added type-safety, you can reference the type of your parameter from the contract',
-					`// E.g. const default_parameter : parameter_of Contract.${module.moduleName} = 10`,
-				];
-				break;
-			default:
-				return [];
-		}
-	})();
+// Helper function to get the initial message based on the pair value
+const getInitialMessage = (pair: string, module: ModuleInfo) => {
+	const messages = {
+		'mligo-file-main':
+			`// When this file was created, the smart contract was defined with a main function that was not within a named module. As such, the examples below are written with that assumption in mind.`,
+		'mligo-file-entry':
+			`// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was not within a named module. As such, the examples below are written with that assumption in mind.`,
+		'mligo-module-main':
+			`// When this file was created, the smart contract was defined with a main function that was within a named module. As such, the examples below are written with that assumption in mind.`,
+		'mligo-module-entry':
+			`// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was within a named module. As such, the examples below are written with that assumption in mind.`,
+		'jsligo-file-main':
+			`// When this file was created, the smart contract was defined with a main function that was not within a namespace. As such, the examples below are written with that assumption in mind.\n`
+			+ `// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
+		'jsligo-file-entry':
+			`// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was not within a namespace. As such, the examples below are written with that assumption in mind.`,
+		'jsligo-module-main':
+			`// When this file was created, the smart contract was defined with a main function that was within a namespace. As such, the examples below are written with that assumption in mind.\n`
+			+ `// NOTE: The "storage" type should be exported from the contract file (${module.sourceFile})`,
+		'jsligo-module-entry':
+			`// When this file was created, the smart contract was defined with an entrypoint using \`@entry\` that was within a namespace. As such, the examples below are written with that assumption in mind.`,
+		// ... any other combinations
+	} as Record<string, string>;
+
+	return messages[pair] || '// This file was created by Taqueria.';
+};
 
-	return linkToContract + instruction + syntax.join('\n');
+// Helper function to get a common message
+const getCommonMsg = (langType: Syntax, listType: ExprKind) => {
+	const varKeyword = langType === 'mligo' ? 'let' : 'const';
+	const commonMsgForStorage = `// IMPORTANT: We suggest always explicitly typing your storage values:\n`
+		+ `// E.g.: \`${varKeyword} storage: int = 10\` or \`${varKeyword} storage: Contract.storage = 10\``;
+
+	const commonMsgForParameter = `// IMPORTANT: We suggest always explicitly typing your parameter values:\n`
+		+ `// E.g.: \`${varKeyword} parameter: int = 10\` or \`${varKeyword} parameter: Contract.parameter = 10\``;
+
+	return listType === 'storage' ? commonMsgForStorage : commonMsgForParameter;
 };
 
+// Main function to get the content for storage or parameter
+const getContent = (moduleInfo: ModuleInfo, listType: ExprKind) => {
+	const linkToContract = `#import "${moduleInfo.sourceFile}" "Contract"`;
+	const pair = `${moduleInfo.syntax}-${moduleInfo.type}`;
+	const initialMsg = getInitialMessage(pair, moduleInfo);
+	const commonMsg = getCommonMsg(moduleInfo.syntax, listType);
+
+	return `${linkToContract}\n\n${initialMsg}\n\n${commonMsg}`;
+};
+
+// Usage for storage list
+const initContentForStorage = (moduleInfo: ModuleInfo) => getContent(moduleInfo, 'storage');
+
+// Usage for parameter list
+const initContentForParameter = (moduleInfo: ModuleInfo) => getContent(moduleInfo, 'parameter');
+
 export const compileContractWithStorageAndParameter = async (
 	parsedArgs: Opts,
 	sourceFile: string,
@@ -475,6 +373,7 @@ export const compileContractWithStorageAndParameter = async (
 ): Promise<TableRow[]> => {
 	const contractCompileResult = await compileContract(parsedArgs, sourceFile, module);
 	if (contractCompileResult.artifact === COMPILE_ERR_MSG) return [contractCompileResult];
+	debugger;
 
 	const storageListFile = `${module.moduleName}.storageList${extractExt(sourceFile)}`;
 	const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);