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

tests/unit/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.spec.ts

@@ -0,0 +1,87 @@
+import 'mocha';
+import { expect } from 'chai';
+import { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
+import { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
+import { CompositeExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser';
+import { ExpressionStub } from '../../../../../../stubs/ExpressionStub';
+
+describe('CompositeExpressionParser', () => {
+    describe('ctor', () => {
+        it('throws if one of the parsers is undefined', () => {
+            // arrange
+            const expectedError = 'undefined leaf';
+            const parsers: readonly IExpressionParser[] = [ undefined, mockParser() ];
+            // act
+            const act = () => new CompositeExpressionParser(parsers);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+    });
+    describe('findExpressions', () => {
+        describe('returns result from parsers as expected', () => {
+            // arrange
+            const pool = [
+                new ExpressionStub(), new ExpressionStub(), new ExpressionStub(),
+                new ExpressionStub(), new ExpressionStub(),
+            ];
+            const testCases = [
+                {
+                    name: 'from single parsing none',
+                    parsers: [ mockParser() ],
+                    expected: [],
+                },
+                {
+                    name: 'from single parsing single',
+                    parsers: [ mockParser(pool[0]) ],
+                    expected: [ pool[0] ],
+                },
+                {
+                    name: 'from single parsing multiple',
+                    parsers: [ mockParser(pool[0], pool[1]) ],
+                    expected: [ pool[0], pool[1] ],
+                },
+                {
+                    name: 'from multiple parsers with each parsing single',
+                    parsers: [
+                        mockParser(pool[0]),
+                        mockParser(pool[1]),
+                        mockParser(pool[2]),
+                    ],
+                    expected: [ pool[0], pool[1], pool[2] ],
+                },
+                {
+                    name: 'from multiple parsers with each parsing multiple',
+                    parsers: [
+                        mockParser(pool[0], pool[1]),
+                        mockParser(pool[2], pool[3], pool[4]) ],
+                    expected: [ pool[0], pool[1], pool[2], pool[3], pool[4] ],
+                },
+                {
+                    name: 'from multiple parsers with only some parsing',
+                    parsers: [
+                        mockParser(pool[0], pool[1]),
+                        mockParser(),
+                        mockParser(pool[2]),
+                        mockParser(),
+                    ],
+                    expected: [ pool[0], pool[1], pool[2] ],
+                },
+            ];
+            for (const testCase of testCases) {
+                it(testCase.name, () => {
+                    const sut = new CompositeExpressionParser(testCase.parsers);
+                    // act
+                    const result = sut.findExpressions('non-important-code');
+                    // expect
+                    expect(result).to.deep.equal(testCase.expected);
+                });
+            }
+        });
+    });
+});
+
+function mockParser(...result: IExpression[]): IExpressionParser {
+    return {
+        findExpressions: () => result,
+    };
+}

tests/unit/application/Parser/Script/Compiler/Expressions/Parser/RegexParser.spec.ts

@@ -0,0 +1,122 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ExpressionEvaluator } from '@/application/Parser/Script/Compiler/Expressions/Expression/Expression';
+import { IPrimitiveExpression, RegexParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/RegexParser';
+import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
+
+describe('RegexParser', () => {
+    describe('findExpressions', () => {
+        describe('matches regex as expected', () => {
+            // arrange
+            const testCases = [
+                 {
+                     name: 'returns no result when regex does not match',
+                     regex: /hello/g,
+                     code: 'world',
+                 },
+                 {
+                     name: 'returns expected when regex matches single',
+                     regex: /hello/g,
+                     code: 'hello world',
+                 },
+                 {
+                     name: 'returns expected when regex matches multiple',
+                     regex: /l/g,
+                     code: 'hello world',
+                 },
+            ];
+            for (const testCase of testCases) {
+                it(testCase.name, () => {
+                    const expected = Array.from(testCase.code.matchAll(testCase.regex));
+                    const matches = new Array<RegExpMatchArray>();
+                    const builder = (m: RegExpMatchArray): IPrimitiveExpression => {
+                        matches.push(m);
+                        return mockPrimitiveExpression();
+                    };
+                    const sut = new RegexParserConcrete(testCase.regex, builder);
+                    // act
+                    const expressions = sut.findExpressions(testCase.code);
+                    // assert
+                    expect(expressions).to.have.lengthOf(matches.length);
+                    expect(matches).to.deep.equal(expected);
+                });
+            }
+        });
+        it('sets evaluator as expected', () => {
+            // arrange
+            const expected = getEvaluatorStub();
+            const regex = /hello/g;
+            const code = 'hello';
+            const builder = (): IPrimitiveExpression => ({
+                evaluator: expected,
+            });
+            const sut = new RegexParserConcrete(regex, builder);
+            // act
+            const expressions = sut.findExpressions(code);
+            // assert
+            expect(expressions).to.have.lengthOf(1);
+            expect(expressions[0].evaluate === expected);
+        });
+        it('sets parameters as expected', () => {
+            // arrange
+            const expected = [ 'parameter1', 'parameter2' ];
+            const regex = /hello/g;
+            const code = 'hello';
+            const builder = (): IPrimitiveExpression => ({
+                evaluator: getEvaluatorStub(),
+                parameters: expected,
+            });
+            const sut = new RegexParserConcrete(regex, builder);
+            // act
+            const expressions = sut.findExpressions(code);
+            // assert
+            expect(expressions).to.have.lengthOf(1);
+            expect(expressions[0].parameters).to.equal(expected);
+        });
+        it('sets expected position', () => {
+            // arrange
+            const code = 'mate date in state is fate';
+            const regex = /ate/g;
+            const expected = [
+                new ExpressionPosition(1, 4),
+                new ExpressionPosition(6, 9),
+                new ExpressionPosition(15, 18),
+                new ExpressionPosition(23, 26),
+            ];
+            const sut = new RegexParserConcrete(regex);
+            // act
+            const expressions = sut.findExpressions(code);
+            // assert
+            const actual = expressions.map((e) => e.position);
+            expect(actual).to.deep.equal(expected);
+        });
+    });
+});
+
+function mockBuilder(): (match: RegExpMatchArray) => IPrimitiveExpression {
+    return () => ({
+        evaluator: getEvaluatorStub(),
+    });
+}
+function getEvaluatorStub(): ExpressionEvaluator {
+    return () => undefined;
+}
+
+function mockPrimitiveExpression(): IPrimitiveExpression {
+    return {
+        evaluator: getEvaluatorStub(),
+    };
+}
+
+class RegexParserConcrete extends RegexParser {
+    protected regex: RegExp;
+    public constructor(
+        regex: RegExp,
+        private readonly builder = mockBuilder()) {
+        super();
+        this.regex = regex;
+    }
+    protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
+        return this.builder(match);
+    }
+}