add initial macOS support #40

src/application/Parser/Script/Compiler/ILCode.ts

@@ -0,0 +1,73 @@
+export interface IILCode {
+    compile(): string;
+    getUniqueParameterNames(): string[];
+    substituteParameter(parameterName: string, parameterValue: string): IILCode;
+}
+
+export function generateIlCode(rawText: string): IILCode {
+    const ilCode = generateIl(rawText);
+    return new ILCode(ilCode);
+}
+
+class ILCode implements IILCode {
+    private readonly ilCode: string;
+
+    constructor(ilCode: string) {
+        this.ilCode = ilCode;
+    }
+
+    public substituteParameter(parameterName: string, parameterValue: string): IILCode {
+        const newCode = substituteParameter(this.ilCode, parameterName, parameterValue);
+        return new ILCode(newCode);
+    }
+
+    public getUniqueParameterNames(): string[] {
+        return getUniqueParameterNames(this.ilCode);
+    }
+
+    public compile(): string {
+        ensureNoExpressionLeft(this.ilCode);
+        return this.ilCode;
+    }
+}
+
+// Trim each expression and put them inside "{{exp|}}" e.g. "{{ $hello }}" becomes "{{exp|$hello}}"
+function generateIl(rawText: string): string {
+    return rawText.replace(/\{\{([\s]*[^;\s\{]+[\s]*)\}\}/g, (_, match) => {
+        return `\{\{exp|${match.trim()}\}\}`;
+    });
+}
+
+// finds all "{{exp|..}} left"
+function ensureNoExpressionLeft(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|(.*?)\}\}/g);
+    const allMatches = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueExpressions = getDistinctValues(allMatches);
+    if (uniqueExpressions.length > 0) {
+        throw new Error(`unknown expression: ${printList(uniqueExpressions)}`);
+    }
+}
+
+// Parses all distinct usages of {{exp|$parameterName}}
+function getUniqueParameterNames(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|\$([^;\s\{]+[\s]*)\}\}/g);
+    const allParameters = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueParameterNames = getDistinctValues(allParameters);
+    return uniqueParameterNames;
+}
+
+// substitutes {{exp|$parameterName}} to value of the parameter
+function substituteParameter(ilCode: string, parameterName: string, parameterValue: string) {
+    const pattern = `{{exp|$${parameterName}}}`;
+    return ilCode.split(pattern).join(parameterValue); // as .replaceAll() is not yet supported by TS
+}
+
+function getDistinctValues(values: readonly string[]): string[] {
+    return values.filter((value, index, self) => {
+        return self.indexOf(value) === index;
+      });
+}
+
+function printList(list: readonly string[]): string {
+    return `"${list.join('","')}"`;
+}

src/application/Parser/Script/Compiler/IScriptCompiler.ts

@@ -0,0 +1,7 @@
+import { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptData } from 'js-yaml-loader!@/*';
+
+export interface IScriptCompiler {
+    canCompile(script: ScriptData): boolean;
+    compile(script: ScriptData): IScriptCode;
+}

src/application/Parser/Script/Compiler/ScriptCompiler.ts

@@ -0,0 +1,171 @@
+import { generateIlCode, IILCode } from './ILCode';
+import { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode } from '@/domain/ScriptCode';
+import { ScriptData, FunctionData, FunctionCallData, ScriptFunctionCallData, FunctionCallParametersData } from 'js-yaml-loader!@/*';
+import { IScriptCompiler } from './IScriptCompiler';
+import { ILanguageSyntax } from '@/domain/ScriptCode';
+
+interface ICompiledCode {
+    readonly code: string;
+    readonly revertCode: string;
+}
+
+export class ScriptCompiler implements IScriptCompiler {
+    constructor(
+        private readonly functions: readonly FunctionData[] | undefined,
+        private syntax: ILanguageSyntax) {
+        ensureValidFunctions(functions);
+        if (!syntax) { throw new Error('undefined syntax'); }
+    }
+    public canCompile(script: ScriptData): boolean {
+        if (!script.call) {
+            return false;
+        }
+        return true;
+    }
+    public compile(script: ScriptData): IScriptCode {
+        this.ensureCompilable(script.call);
+        const compiledCodes = new Array<ICompiledCode>();
+        const calls = getCallSequence(script.call);
+        calls.forEach((currentCall, currentCallIndex) => {
+            ensureValidCall(currentCall, script.name);
+            const commonFunction = this.getFunctionByName(currentCall.function);
+            let functionCode = compileCode(commonFunction, currentCall.parameters);
+            if (currentCallIndex !== calls.length - 1) {
+                functionCode = appendLine(functionCode);
+            }
+            compiledCodes.push(functionCode);
+        });
+        const scriptCode = merge(compiledCodes);
+        return new ScriptCode(scriptCode.code, scriptCode.revertCode, script.name, this.syntax);
+    }
+
+    private getFunctionByName(name: string): FunctionData {
+        const func = this.functions.find((f) => f.name === name);
+        if (!func) {
+            throw new Error(`called function is not defined "${name}"`);
+        }
+        return func;
+    }
+    private ensureCompilable(call: ScriptFunctionCallData) {
+        if (!this.functions || this.functions.length === 0) {
+            throw new Error('cannot compile without shared functions');
+        }
+        if (typeof call !== 'object') {
+            throw new Error('called function(s) must be an object');
+        }
+    }
+}
+
+function getDuplicates(texts: readonly string[]): string[] {
+    return texts.filter((item, index) => texts.indexOf(item) !== index);
+}
+
+function printList(list: readonly string[]): string {
+    return `"${list.join('","')}"`;
+}
+
+function ensureNoDuplicatesInFunctionNames(functions: readonly FunctionData[]) {
+    const duplicateFunctionNames = getDuplicates(functions
+        .map((func) => func.name.toLowerCase()));
+    if (duplicateFunctionNames.length) {
+        throw new Error(`duplicate function name: ${printList(duplicateFunctionNames)}`);
+    }
+}
+function ensureNoUndefinedItem(functions: readonly FunctionData[]) {
+    if (functions.some((func) => !func)) {
+        throw new Error(`some functions are undefined`);
+    }
+}
+function ensureNoDuplicatesInParameterNames(functions: readonly FunctionData[]) {
+    const functionsWithParameters = functions
+        .filter((func) => func.parameters && func.parameters.length > 0);
+    for (const func of functionsWithParameters) {
+        const duplicateParameterNames = getDuplicates(func.parameters);
+        if (duplicateParameterNames.length) {
+            throw new Error(`"${func.name}": duplicate parameter name: ${printList(duplicateParameterNames)}`);
+        }
+    }
+}
+
+function ensureNoDuplicateCode(functions: readonly FunctionData[]) {
+    const duplicateCodes = getDuplicates(functions.map((func) => func.code));
+    if (duplicateCodes.length > 0) {
+        throw new Error(`duplicate "code" in functions: ${printList(duplicateCodes)}`);
+    }
+    const duplicateRevertCodes = getDuplicates(functions
+        .filter((func) => func.revertCode)
+        .map((func) => func.revertCode));
+    if (duplicateRevertCodes.length > 0) {
+        throw new Error(`duplicate "revertCode" in functions: ${printList(duplicateRevertCodes)}`);
+    }
+}
+
+function ensureValidFunctions(functions: readonly FunctionData[]) {
+    if (!functions || functions.length === 0) {
+        return;
+    }
+    ensureNoUndefinedItem(functions);
+    ensureNoDuplicatesInFunctionNames(functions);
+    ensureNoDuplicatesInParameterNames(functions);
+    ensureNoDuplicateCode(functions);
+}
+
+function appendLine(code: ICompiledCode): ICompiledCode {
+    const appendLineIfNotEmpty = (str: string) => str ? `${str}\n` : str;
+    return {
+        code: appendLineIfNotEmpty(code.code),
+        revertCode: appendLineIfNotEmpty(code.revertCode),
+    };
+}
+
+function merge(codes: readonly ICompiledCode[]): ICompiledCode {
+    return {
+        code: codes.map((code) => code.code).join(''),
+        revertCode: codes.map((code) => code.revertCode).join(''),
+    };
+}
+
+function compileCode(func: FunctionData, parameters: FunctionCallParametersData): ICompiledCode {
+    return {
+        code: compileExpressions(func.code, parameters),
+        revertCode: compileExpressions(func.revertCode, parameters),
+    };
+}
+
+function compileExpressions(code: string, parameters: FunctionCallParametersData): string {
+    let intermediateCode = generateIlCode(code);
+    intermediateCode = substituteParameters(intermediateCode, parameters);
+    return intermediateCode.compile();
+}
+
+function substituteParameters(intermediateCode: IILCode, parameters: FunctionCallParametersData): IILCode {
+    const parameterNames = intermediateCode.getUniqueParameterNames();
+    if (parameterNames.length && !parameters) {
+        throw new Error(`no parameters defined, expected: ${printList(parameterNames)}`);
+    }
+    for (const parameterName of parameterNames) {
+        const parameterValue = parameters[parameterName];
+        if (!parameterValue) {
+            throw Error(`parameter value is not provided for "${parameterName}" in function call`);
+        }
+        intermediateCode = intermediateCode.substituteParameter(parameterName, parameterValue);
+    }
+    return intermediateCode;
+}
+
+function ensureValidCall(call: FunctionCallData, scriptName: string) {
+    if (!call) {
+        throw new Error(`undefined function call in script "${scriptName}"`);
+    }
+    if (!call.function) {
+        throw new Error(`empty function name called in script "${scriptName}"`);
+    }
+}
+
+function getCallSequence(call: ScriptFunctionCallData): FunctionCallData[] {
+    if (call instanceof Array) {
+        return call as FunctionCallData[];
+    }
+    return [ call as FunctionCallData ];
+}