refactor script compilation to make it easy to add new expressions #41 #53

src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts

@@ -0,0 +1,35 @@
+import { ExpressionPosition } from './ExpressionPosition';
+import { ExpressionArguments, IExpression } from './IExpression';
+
+export type ExpressionEvaluator = (args?: ExpressionArguments) => string;
+export class Expression implements IExpression {
+    constructor(
+        public readonly position: ExpressionPosition,
+        public readonly evaluator: ExpressionEvaluator,
+        public readonly parameters: readonly string[] = new Array<string>()) {
+        if (!position) {
+            throw new Error('undefined position');
+        }
+        if (!evaluator) {
+            throw new Error('undefined evaluator');
+        }
+    }
+    public evaluate(args?: ExpressionArguments): string {
+        args = filterUnusedArguments(this.parameters, args);
+        return this.evaluator(args);
+    }
+}
+
+function filterUnusedArguments(
+    parameters: readonly string[], args: ExpressionArguments): ExpressionArguments {
+    let result: ExpressionArguments = {};
+    for (const parameter of Object.keys(args)) {
+        if (parameters.includes(parameter)) {
+            result = {
+                ...result,
+                [parameter]: args[parameter],
+            };
+        }
+    }
+    return result;
+}

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition.ts

@@ -0,0 +1,15 @@
+export class ExpressionPosition {
+    constructor(
+        public readonly start: number,
+        public readonly end: number) {
+        if (start === end) {
+            throw new Error(`no length (start = end = ${start})`);
+        }
+        if (start > end) {
+            throw Error(`start (${start}) after end (${end})`);
+        }
+        if (start < 0) {
+            throw Error(`negative start position: ${start}`);
+        }
+    }
+}

src/application/Parser/Script/Compiler/Expressions/Expression/IExpression.ts

@@ -0,0 +1,12 @@
+import { ExpressionPosition } from './ExpressionPosition';
+
+export interface IExpression {
+    readonly position: ExpressionPosition;
+    readonly parameters?: readonly string[];
+    evaluate(args?: ExpressionArguments): string;
+}
+
+export interface ExpressionArguments {
+    readonly [parameter: string]: string;
+}
+