allow functions to call other functions #53

tests/unit/application/Parser/Script/CategoryCollectionParseContext.spec.ts

@@ -29,7 +29,7 @@ describe('CategoryCollectionParseContext', () => {
             // arrange
             const expectedError = 'undefined scripting';
             const scripting = undefined;
-            const functionsData = [ new FunctionDataStub() ];
+            const functionsData = [ FunctionDataStub.createWithCode() ];
             // act
             const act = () => new CategoryCollectionParseContext(functionsData, scripting);
             // assert
@@ -39,7 +39,7 @@ describe('CategoryCollectionParseContext', () => {
     describe('compiler', () => {
         it('constructed as expected', () => {
             // arrange
-            const functionsData = [ new FunctionDataStub() ];
+            const functionsData = [ FunctionDataStub.createWithCode() ];
             const syntax = new LanguageSyntaxStub();
             const expected = new ScriptCompiler(functionsData, syntax);
             const language = ScriptingLanguage.shellscript;

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

@@ -0,0 +1,99 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/ExpressionsCompiler';
+
+describe('ExpressionsCompiler', () => {
+    describe('parameter substitution', () => {
+        describe('substitutes as expected', () => {
+            // arrange
+            const testCases = [ {
+                name: 'with different parameters',
+                code: 'He{{ $firstParameter }} {{ $secondParameter }}!',
+                parameters: {
+                    firstParameter: 'llo',
+                    secondParameter: 'world',
+                },
+                expected: 'Hello world!',
+            }, {
+                name: 'with single parameter',
+                code: '{{ $parameter }}!',
+                parameters: {
+                    parameter: 'Hodor',
+                },
+                expected: 'Hodor!',
+
+            }];
+            for (const testCase of testCases) {
+                it(testCase.name, () => {
+                    const sut = new MockableExpressionsCompiler();
+                    // act
+                    const actual = sut.compileExpressions(testCase.code, testCase.parameters);
+                    // assert
+                    expect(actual).to.equal(testCase.expected);
+                });
+            }
+        });
+        describe('throws when expected value is not provided', () => {
+            // arrange
+            const noParameterTestCases = [
+                {
+                    name: 'empty parameters',
+                    code: '{{ $parameter }}!',
+                    parameters: {},
+                    expectedError: 'parameter value(s) not provided for: "parameter"',
+                },
+                {
+                    name: 'undefined parameters',
+                    code: '{{ $parameter }}!',
+                    parameters: undefined,
+                    expectedError: 'parameter value(s) not provided for: "parameter"',
+                },
+                {
+                    name: 'unnecessary parameter provided',
+                    code: '{{ $parameter }}!',
+                    parameters: {
+                        unnecessaryParameter: 'unnecessaryValue',
+                    },
+                    expectedError: 'parameter value(s) not provided for: "parameter"',
+                },
+                {
+                    name: 'undefined value',
+                    code: '{{ $parameter }}!',
+                    parameters: {
+                        parameter: undefined,
+                    },
+                    expectedError: 'parameter value(s) not provided for: "parameter"',
+                },
+                {
+                    name: 'multiple values are not',
+                    code: '{{ $parameter1 }}, {{ $parameter2 }}, {{ $parameter3 }}',
+                    parameters: {},
+                    expectedError: 'parameter value(s) not provided for: "parameter1", "parameter2", "parameter3"',
+                },
+                {
+                    name: 'some values are provided',
+                    code: '{{ $parameter1 }}, {{ $parameter2 }}, {{ $parameter3 }}',
+                    parameters: {
+                        parameter2: 'value',
+                    },
+                    expectedError: 'parameter value(s) not provided for: "parameter1", "parameter3"',
+                },
+            ];
+            for (const testCase of noParameterTestCases) {
+                it(testCase.name, () => {
+                    const sut = new MockableExpressionsCompiler();
+                    // act
+                    const act = () => sut.compileExpressions(testCase.code, testCase.parameters);
+                    // assert
+                    expect(act).to.throw(testCase.expectedError);
+                });
+            }
+        });
+    });
+});
+
+class MockableExpressionsCompiler extends ExpressionsCompiler {
+    constructor() {
+        super();
+    }
+}

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

@@ -1,6 +1,6 @@
 import 'mocha';
 import { expect } from 'chai';
-import { generateIlCode } from '@/application/Parser/Script/Compiler/ILCode';
+import { generateIlCode } from '@/application/Parser/Script/Compiler/Expressions/ILCode';
 
 describe('ILCode', () => {
     describe('getUniqueParameterNames', () => {

tests/unit/application/Parser/Script/Compiler/Function/FunctionCompiler.spec.ts

@@ -0,0 +1,192 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { FunctionData } from 'js-yaml-loader!*';
+import { IFunctionCallCompiler } from '@/application/Parser/Script/Compiler/FunctionCall/IFunctionCallCompiler';
+import { FunctionCompiler } from '@/application/Parser/Script/Compiler/Function/FunctionCompiler';
+import { FunctionCallCompilerStub } from '../../../../../stubs/FunctionCallCompilerStub';
+import { FunctionDataStub } from '../../../../../stubs/FunctionDataStub';
+
+describe('FunctionsCompiler', () => {
+    describe('compileFunctions', () => {
+        describe('validates functions', () => {
+            it('throws if one of the functions is undefined', () => {
+                // arrange
+                const expectedError = `some functions are undefined`;
+                const functions = [ FunctionDataStub.createWithCode(), undefined ];
+                const sut = new MockableFunctionCompiler();
+                // act
+                const act = () => sut.compileFunctions(functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when functions have same names', () => {
+                // arrange
+                const name = 'same-func-name';
+                const expectedError = `duplicate function name: "${name}"`;
+                const functions = [
+                    FunctionDataStub.createWithCode().withName(name),
+                    FunctionDataStub.createWithCode().withName(name),
+                ];
+                const sut = new MockableFunctionCompiler();
+                // act
+                const act = () => sut.compileFunctions(functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws when function parameters have same names', () => {
+                // arrange
+                const parameterName = 'duplicate-parameter';
+                const func = FunctionDataStub.createWithCall()
+                    .withParameters(parameterName, parameterName);
+                const expectedError = `"${func.name}": duplicate parameter name: "${parameterName}"`;
+                const sut = new MockableFunctionCompiler();
+                // act
+                const act = () => sut.compileFunctions([ func ]);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            describe('throws when when function have duplicate code', () => {
+                it('code', () => {
+                    // arrange
+                    const code = 'duplicate-code';
+                    const expectedError = `duplicate "code" in functions: "${code}"`;
+                    const functions = [
+                        FunctionDataStub.createWithoutCallOrCodes().withName('func-1').withCode(code),
+                        FunctionDataStub.createWithoutCallOrCodes().withName('func-2').withCode(code),
+                    ];
+                    const sut = new MockableFunctionCompiler();
+                    // act
+                    const act = () => sut.compileFunctions(functions);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+                it('revertCode', () => {
+                    // arrange
+                    const revertCode = 'duplicate-revert-code';
+                    const expectedError = `duplicate "revertCode" in functions: "${revertCode}"`;
+                    const functions = [
+                        FunctionDataStub.createWithoutCallOrCodes()
+                            .withName('func-1').withCode('code-1').withRevertCode(revertCode),
+                        FunctionDataStub.createWithoutCallOrCodes()
+                            .withName('func-2').withCode('code-2').withRevertCode(revertCode),
+                    ];
+                    const sut = new MockableFunctionCompiler();
+                    // act
+                    const act = () => sut.compileFunctions(functions);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+            });
+            it('both code and call are defined', () => {
+                // arrange
+                const functionName = 'invalid-function';
+                const expectedError = `both "code" and "call" are defined in "${functionName}"`;
+                const invalidFunction = FunctionDataStub.createWithoutCallOrCodes()
+                    .withName(functionName)
+                    .withCode('code')
+                    .withMockCall();
+                const sut = new MockableFunctionCompiler();
+                // act
+                const act = () => sut.compileFunctions([ invalidFunction ]);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('neither code and call is defined', () => {
+                // arrange
+                const functionName = 'invalid-function';
+                const expectedError = `neither "code" or "call" is defined in "${functionName}"`;
+                const invalidFunction = FunctionDataStub.createWithoutCallOrCodes()
+                    .withName(functionName);
+                const sut = new MockableFunctionCompiler();
+                // act
+                const act = () => sut.compileFunctions([ invalidFunction ]);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+        it('returns empty with empty functions', () => {
+            // arrange
+            const emptyValues = [ [], undefined ];
+            const sut = new MockableFunctionCompiler();
+            for (const emptyFunctions of emptyValues) {
+                // act
+                const actual = sut.compileFunctions(emptyFunctions);
+                // assert
+                expect(actual).to.not.equal(undefined);
+            }
+        });
+        it('parses single function with code as expected', () => {
+            // arrange
+            const name = 'function-name';
+            const expected = FunctionDataStub
+                .createWithoutCallOrCodes()
+                .withName(name)
+                .withCode('expected-code')
+                .withRevertCode('expected-revert-code')
+                .withParameters('expected-parameter-1', 'expected-parameter-2');
+            const sut = new MockableFunctionCompiler();
+            // act
+            const collection = sut.compileFunctions([ expected ]);
+            // expect
+            const actual = collection.getFunctionByName(name);
+            expectEqualFunctions(expected, actual);
+        });
+        it('parses function with call as expected', () => {
+            // arrange
+            const calleeName = 'callee-function';
+            const caller = FunctionDataStub.createWithoutCallOrCodes()
+                .withName('caller-function')
+                .withCall({ function: calleeName });
+            const callee = FunctionDataStub.createWithoutCallOrCodes()
+                .withName(calleeName)
+                .withCode('expected-code')
+                .withRevertCode('expected-revert-code');
+            const sut = new MockableFunctionCompiler();
+            // act
+            const collection = sut.compileFunctions([ caller, callee ]);
+            // expect
+            const actual = collection.getFunctionByName(caller.name);
+            expectEqualFunctionCode(callee, actual);
+        });
+        it('parses multiple functions with call as expected', () => {
+            // arrange
+            const calleeName = 'callee-function';
+            const caller1 = FunctionDataStub.createWithoutCallOrCodes()
+                .withName('caller-function')
+                .withCall({ function: calleeName });
+            const caller2 = FunctionDataStub.createWithoutCallOrCodes()
+                .withName('caller-function-2')
+                .withCall({ function: calleeName });
+            const callee = FunctionDataStub.createWithoutCallOrCodes()
+                .withName(calleeName)
+                .withCode('expected-code')
+                .withRevertCode('expected-revert-code');
+            const sut = new MockableFunctionCompiler();
+            // act
+            const collection = sut.compileFunctions([ caller1, caller2, callee ]);
+            // expect
+            const compiledCaller1 = collection.getFunctionByName(caller1.name);
+            const compiledCaller2 = collection.getFunctionByName(caller2.name);
+            expectEqualFunctionCode(callee, compiledCaller1);
+            expectEqualFunctionCode(callee, compiledCaller2);
+        });
+    });
+});
+
+function expectEqualFunctions(expected: FunctionData, actual: ISharedFunction) {
+    expect(actual.name).to.equal(expected.name);
+    expect(actual.parameters).to.deep.equal(expected.parameters);
+    expectEqualFunctionCode(expected, actual);
+}
+
+function expectEqualFunctionCode(expected: FunctionData, actual: ISharedFunction) {
+    expect(actual.code).to.equal(expected.code);
+    expect(actual.revertCode).to.equal(expected.revertCode);
+}
+
+class MockableFunctionCompiler extends FunctionCompiler {
+    constructor(functionCallCompiler: IFunctionCallCompiler = new FunctionCallCompilerStub()) {
+        super(functionCallCompiler);
+    }
+}

tests/unit/application/Parser/Script/Compiler/Function/SharedFunction.spec.ts

@@ -0,0 +1,128 @@
+import 'mocha';
+import { expect } from 'chai';
+import { SharedFunction } from '@/application/Parser/Script/Compiler/Function/SharedFunction';
+
+describe('SharedFunction', () => {
+    describe('name', () => {
+        it('sets as expected', () => {
+            // arrange
+            const expected = 'expected-function-name';
+            // act
+            const sut = new SharedFunctionBuilder()
+                .withName(expected)
+                .build();
+            // assert
+            expect(sut.name).equal(expected);
+        });
+        it('throws if empty or undefined', () => {
+            // arrange
+            const expectedError = 'undefined function name';
+            const invalidValues = [ undefined, '' ];
+            for (const invalidValue of invalidValues) {
+                // act
+                const act = () => new SharedFunctionBuilder()
+                    .withName(invalidValue)
+                    .build();
+                // assert
+                expect(act).to.throw(expectedError);
+            }
+        });
+    });
+    describe('parameters', () => {
+        it('sets as expected', () => {
+            // arrange
+            const expected = [ 'expected-parameter' ];
+            // act
+            const sut = new SharedFunctionBuilder()
+                .withParameters(expected)
+                .build();
+            // assert
+            expect(sut.parameters).to.deep.equal(expected);
+        });
+        it('returns empty array if undefined', () => {
+            // arrange
+            const expected = [ ];
+            const value = undefined;
+            // act
+            const sut = new SharedFunctionBuilder()
+                .withParameters(value)
+                .build();
+            // assert
+            expect(sut.parameters).to.not.equal(undefined);
+            expect(sut.parameters).to.deep.equal(expected);
+        });
+    });
+    describe('code', () => {
+        it('sets as expected', () => {
+            // arrange
+            const expected = 'expected-code';
+            // act
+            const sut = new SharedFunctionBuilder()
+                .withCode(expected)
+                .build();
+            // assert
+            expect(sut.code).equal(expected);
+        });
+        it('throws if empty or undefined', () => {
+            // arrange
+            const functionName = 'expected-function-name';
+            const expectedError = `undefined function ("${functionName}") code`;
+            const invalidValues = [ undefined, '' ];
+            for (const invalidValue of invalidValues) {
+                // act
+                const act = () => new SharedFunctionBuilder()
+                    .withName(functionName)
+                    .withCode(invalidValue)
+                    .build();
+                // assert
+                expect(act).to.throw(expectedError);
+            }
+        });
+    });
+    describe('revertCode', () => {
+        it('sets as expected', () => {
+            // arrange
+            const testData = [ 'expected-revert-code', undefined, '' ];
+            for (const data of testData) {
+                // act
+                const sut = new SharedFunctionBuilder()
+                    .withRevertCode(data)
+                    .build();
+                // assert
+                expect(sut.revertCode).equal(data);
+            }
+        });
+    });
+});
+
+class SharedFunctionBuilder {
+    private name = 'name';
+    private parameters: readonly string[] = [ 'parameter' ];
+    private code = 'code';
+    private revertCode = 'revert-code';
+
+    public build(): SharedFunction {
+        return new SharedFunction(
+            this.name,
+            this.parameters,
+            this.code,
+            this.revertCode,
+        );
+    }
+    public withName(name: string) {
+        this.name = name;
+        return this;
+    }
+    public withParameters(parameters: readonly string[]) {
+        this.parameters = parameters;
+        return this;
+    }
+    public withCode(code: string) {
+        this.code = code;
+        return this;
+    }
+    public withRevertCode(revertCode: string) {
+        this.revertCode = revertCode;
+        return this;
+    }
+}

tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionCollection.spec.ts

@@ -0,0 +1,74 @@
+import 'mocha';
+import { expect } from 'chai';
+import { SharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/SharedFunctionCollection';
+import { SharedFunctionStub } from '../../../../../stubs/SharedFunctionStub';
+
+describe('SharedFunctionCollection', () => {
+    describe('addFunction', () => {
+        it('throws if function is undefined', () => {
+            // arrange
+            const expectedError = 'undefined function';
+            const func = undefined;
+            const sut = new SharedFunctionCollection();
+            // act
+            const act = () => sut.addFunction(func);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        it('throws if function with same name already exists', () => {
+            // arrange
+            const functionName = 'duplicate-function';
+            const expectedError = `function with name ${functionName} already exists`;
+            const func = new SharedFunctionStub()
+                .withName('duplicate-function');
+            const sut = new SharedFunctionCollection();
+            sut.addFunction(func);
+            // act
+            const act = () => sut.addFunction(func);
+            // assert
+            expect(act).to.throw(expectedError);
+
+        });
+    });
+    describe('getFunctionByName', () => {
+        it('throws if name is undefined', () => {
+            // arrange
+            const expectedError = 'undefined function name';
+            const invalidValues = [ undefined, '' ];
+            const sut = new SharedFunctionCollection();
+            for (const invalidValue of invalidValues) {
+                const name = invalidValue;
+                // act
+                const act = () => sut.getFunctionByName(name);
+                // assert
+                expect(act).to.throw(expectedError);
+            }
+        });
+        it('throws if function does not exist', () => {
+            // arrange
+            const name = 'unique-name';
+            const expectedError = `called function is not defined "${name}"`;
+            const func = new SharedFunctionStub()
+                .withName('unexpected-name');
+            const sut = new SharedFunctionCollection();
+            sut.addFunction(func);
+            // act
+            const act = () => sut.getFunctionByName(name);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        it('returns existing function', () => {
+            // arrange
+            const name = 'expected-function-name';
+            const expected = new SharedFunctionStub()
+                .withName(name);
+            const sut = new SharedFunctionCollection();
+            sut.addFunction(new SharedFunctionStub().withName('another-function-name'));
+            sut.addFunction(expected);
+            // act
+            const actual = sut.getFunctionByName(name);
+            // assert
+            expect(actual).to.equal(expected);
+        });
+    });
+});

tests/unit/application/Parser/Script/Compiler/FunctionCall/FunctionCallCompiler.spec.ts

@@ -0,0 +1,191 @@
+import 'mocha';
+import { expect } from 'chai';
+import { FunctionCallData, FunctionCallParametersData } from 'js-yaml-loader!*';
+import { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/FunctionCall/FunctionCallCompiler';
+import { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
+import { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import { ExpressionsCompilerStub } from '../../../../../stubs/ExpressionsCompilerStub';
+import { SharedFunctionCollectionStub } from '../../../../../stubs/SharedFunctionCollectionStub';
+import { SharedFunctionStub } from '../../../../../stubs/SharedFunctionStub';
+
+describe('FunctionCallCompiler', () => {
+    describe('compileCall', () => {
+        describe('call', () => {
+            it('throws with undefined call', () => {
+                // arrange
+                const expectedError = 'undefined call';
+                const call = undefined;
+                const functions = new SharedFunctionCollectionStub();
+                const sut = new MockableFunctionCallCompiler();
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws if call is not an object', () => {
+                // arrange
+                const expectedError = 'called function(s) must be an object';
+                const invalidCalls: readonly any[] = ['string', 33];
+                const sut = new MockableFunctionCallCompiler();
+                const functions = new SharedFunctionCollectionStub();
+                invalidCalls.forEach((invalidCall) => {
+                    // act
+                    const act = () => sut.compileCall(invalidCall, functions);
+                    // assert
+                    expect(act).to.throw(expectedError);
+                });
+            });
+            it('throws if call sequence has undefined call', () => {
+                // arrange
+                const expectedError = 'undefined function call';
+                const call: FunctionCallData[] = [
+                    { function: 'function-name' },
+                    undefined,
+                ];
+                const functions = new SharedFunctionCollectionStub();
+                const sut = new MockableFunctionCallCompiler();
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws if call sequence has undefined function name', () => {
+                // arrange
+                const expectedError = 'empty function name called';
+                const call: FunctionCallData[] = [
+                    { function: 'function-name' },
+                    { function: undefined },
+                ];
+                const functions = new SharedFunctionCollectionStub();
+                const sut = new MockableFunctionCallCompiler();
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws if call parameters does not match function parameters', () => {
+                // arrange
+                const unexpectedCallParameterName = 'unexpected-parameter-name';
+                const func = new SharedFunctionStub()
+                    .withName('test-function-name')
+                    .withParameters('another-parameter');
+                const expectedError = `function "${func.name}" has unexpected parameter(s) provided: "${unexpectedCallParameterName}"`;
+                const sut = new MockableFunctionCallCompiler();
+                const params: FunctionCallParametersData = {
+                    [`${unexpectedCallParameterName}`]: 'unexpected-parameter-value',
+                };
+                const call: FunctionCallData = { function: func.name, parameters: params };
+                const functions = new SharedFunctionCollectionStub().withFunction(func);
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+        describe('functions', () => {
+            it('throws with undefined functions', () => {
+                // arrange
+                const expectedError = 'undefined functions';
+                const call: FunctionCallData = { function: 'function-call' };
+                const functions = undefined;
+                const sut = new MockableFunctionCallCompiler();
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+            it('throws if function does not exist', () => {
+                // arrange
+                const expectedError = 'function does not exist';
+                const call: FunctionCallData = { function: 'function-call' };
+                const functions: ISharedFunctionCollection = {
+                    getFunctionByName: () => { throw new Error(expectedError); },
+                };
+                const sut = new MockableFunctionCallCompiler();
+                // act
+                const act = () => sut.compileCall(call, functions);
+                // assert
+                expect(act).to.throw(expectedError);
+            });
+        });
+        describe('builds code as expected', () => {
+            describe('builds single call as expected', () => {
+                // arrange
+                const parametersTestCases = [
+                    {
+                        name: 'undefined parameters',
+                        parameters: undefined,
+                        parameterValues: undefined,
+                    },
+                    {
+                        name: 'empty parameters',
+                        parameters: [],
+                        parameterValues: { },
+                    },
+                    {
+                        name: 'non-empty parameters',
+                        parameters: [ 'param1', 'param2' ],
+                        parameterValues: { param1: 'value1', param2: 'value2' },
+                    },
+                ];
+                for (const testCase of parametersTestCases) {
+                    it(testCase.name, () => {
+                        const expectedExecute = `expected-execute`;
+                        const expectedRevert = `expected-revert`;
+                        const func = new SharedFunctionStub().withParameters(...testCase.parameters);
+                        const functions = new SharedFunctionCollectionStub().withFunction(func);
+                        const call: FunctionCallData = { function: func.name, parameters: testCase.parameterValues };
+                        const expressionsCompilerMock = new ExpressionsCompilerStub()
+                            .setup(func.code, testCase.parameterValues, expectedExecute)
+                            .setup(func.revertCode, testCase.parameterValues, expectedRevert);
+                        const sut = new MockableFunctionCallCompiler(expressionsCompilerMock);
+                        // act
+                        const actual = sut.compileCall(call, functions);
+                        // assert
+                        expect(actual.code).to.equal(expectedExecute);
+                        expect(actual.revertCode).to.equal(expectedRevert);
+                    });
+                }
+            });
+            it('builds call sequence as expected', () => {
+                // arrange
+                const firstFunction = new SharedFunctionStub()
+                    .withName('first-function-name')
+                    .withCode('first-function-code')
+                    .withRevertCode('first-function-revert-code');
+                const secondFunction = new SharedFunctionStub()
+                    .withName('second-function-name')
+                    .withParameters('testParameter')
+                    .withCode('second-function-code')
+                    .withRevertCode('second-function-revert-code');
+                const secondCallArguments = { testParameter: 'testValue' };
+                const call: FunctionCallData[] = [
+                    { function: firstFunction.name },
+                    { function: secondFunction.name, parameters: secondCallArguments },
+                ];
+                const expressionsCompilerMock = new ExpressionsCompilerStub()
+                    .setup(firstFunction.code, {}, firstFunction.code)
+                    .setup(firstFunction.revertCode, {}, firstFunction.revertCode)
+                    .setup(secondFunction.code, secondCallArguments, secondFunction.code)
+                    .setup(secondFunction.revertCode, secondCallArguments, secondFunction.revertCode);
+                const expectedExecute = `${firstFunction.code}\n${secondFunction.code}`;
+                const expectedRevert = `${firstFunction.revertCode}\n${secondFunction.revertCode}`;
+                const functions = new SharedFunctionCollectionStub()
+                    .withFunction(firstFunction)
+                    .withFunction(secondFunction);
+                const sut = new MockableFunctionCallCompiler(expressionsCompilerMock);
+                // act
+                const actual = sut.compileCall(call, functions);
+                // assert
+                expect(actual.code).to.equal(expectedExecute);
+                expect(actual.revertCode).to.equal(expectedRevert);
+            });
+        });
+    });
+});
+
+class MockableFunctionCallCompiler extends FunctionCallCompiler {
+    constructor(expressionsCompiler: IExpressionsCompiler = new ExpressionsCompilerStub()) {
+        super(expressionsCompiler);
+    }
+}

tests/unit/application/Parser/Script/Compiler/ScriptCompiler.spec.ts

@@ -1,13 +1,17 @@
 import 'mocha';
 import { expect } from 'chai';
 import { ScriptCompiler } from '@/application/Parser/Script/Compiler/ScriptCompiler';
-import { FunctionData, ScriptData, FunctionCallData, ScriptFunctionCallData, FunctionCallParametersData } from 'js-yaml-loader!@/*';
-import { IScriptCode } from '@/domain/IScriptCode';
+import { FunctionData } from 'js-yaml-loader!@/*';
 import { ILanguageSyntax } from '@/domain/ScriptCode';
-import { IScriptCompiler } from '@/application/Parser/Script/Compiler/IScriptCompiler';
+import { IFunctionCompiler } from '@/application/Parser/Script/Compiler/Function/IFunctionCompiler';
+import { IFunctionCallCompiler } from '@/application/Parser/Script/Compiler/FunctionCall/IFunctionCallCompiler';
+import { ICompiledCode } from '@/application/Parser/Script/Compiler/FunctionCall/ICompiledCode';
 import { LanguageSyntaxStub } from '../../../../stubs/LanguageSyntaxStub';
 import { ScriptDataStub } from '../../../../stubs/ScriptDataStub';
 import { FunctionDataStub } from '../../../../stubs/FunctionDataStub';
+import { FunctionCallCompilerStub } from '../../../../stubs/FunctionCallCompilerStub';
+import { FunctionCompilerStub } from '../../../../stubs/FunctionCompilerStub';
+import { SharedFunctionCollectionStub } from '../../../../stubs/SharedFunctionCollectionStub';
 
 describe('ScriptCompiler', () => {
     describe('ctor', () => {
@@ -22,88 +26,20 @@ describe('ScriptCompiler', () => {
             // assert
             expect(act).to.throw(expectedError);
         });
-        it('throws if one of the functions is undefined', () => {
-            // arrange
-            const expectedError = `some functions are undefined`;
-            const functions = [ new FunctionDataStub(), undefined ];
-            // act
-            const act = () => new ScriptCompilerBuilder()
-                .withFunctions(...functions)
-                .build();
-            // assert
-            expect(act).to.throw(expectedError);
-        });
-        it('throws when functions have same names', () => {
-            // arrange
-            const name = 'same-func-name';
-            const expectedError = `duplicate function name: "${name}"`;
-            const functions = [
-                new FunctionDataStub().withName(name),
-                new FunctionDataStub().withName(name),
-            ];
-            // act
-            const act = () => new ScriptCompilerBuilder()
-                .withFunctions(...functions)
-                .build();
-            // assert
-            expect(act).to.throw(expectedError);
-        });
-        it('throws when function parameters have same names', () => {
-            // arrange
-            const parameterName = 'duplicate-parameter';
-            const func = new FunctionDataStub()
-                .withParameters(parameterName, parameterName);
-            const expectedError = `"${func.name}": duplicate parameter name: "${parameterName}"`;
-            // act
-            const act = () => new ScriptCompilerBuilder()
-                .withFunctions(func)
-                .build();
-            // assert
-            expect(act).to.throw(expectedError);
-        });
-        describe('throws when when function have duplicate code', () => {
-            it('code', () => {
-                // arrange
-                const code = 'duplicate-code';
-                const expectedError = `duplicate "code" in functions: "${code}"`;
-                const functions = [
-                    new FunctionDataStub().withName('func-1').withCode(code),
-                    new FunctionDataStub().withName('func-2').withCode(code),
-                ];
-                // act
-                const act = () => new ScriptCompilerBuilder()
-                    .withFunctions(...functions)
-                    .build();
-                // assert
-                expect(act).to.throw(expectedError);
-            });
-            it('revertCode', () => {
-                // arrange
-                const revertCode = 'duplicate-revert-code';
-                const expectedError = `duplicate "revertCode" in functions: "${revertCode}"`;
-                const functions = [
-                    new FunctionDataStub().withName('func-1').withCode('code-1').withRevertCode(revertCode),
-                    new FunctionDataStub().withName('func-2').withCode('code-2').withRevertCode(revertCode),
-                ];
-                // act
-                const act = () => new ScriptCompilerBuilder()
-                    .withFunctions(...functions)
-                    .build();
-                // assert
-                expect(act).to.throw(expectedError);
-            });
-        });
-        it('can construct with empty functions', () => {
-            // arrange
-            const builder = new ScriptCompilerBuilder()
-                .withEmptyFunctions();
-            // act
-            const act = () => builder.build();
-            // assert
-            expect(act).to.not.throw();
-        });
     });
     describe('canCompile', () => {
+        it('throws if script is undefined', () => {
+            // arrange
+            const expectedError = 'undefined script';
+            const argument = undefined;
+            const builder = new ScriptCompilerBuilder()
+                .withEmptyFunctions()
+                .build();
+            // act
+            const act = () => builder.canCompile(argument);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
         it('returns true if "call" is defined', () => {
             // arrange
             const sut = new ScriptCompilerBuilder()
@@ -128,274 +64,97 @@ describe('ScriptCompiler', () => {
         });
     });
     describe('compile', () => {
-        describe('invalid state', () => {
-            it('throws if functions are empty', () => {
-                // arrange
-                const expectedError = 'cannot compile without shared functions';
-                const sut = new ScriptCompilerBuilder()
-                    .withEmptyFunctions()
-                    .build();
-                const script = ScriptDataStub.createWithCall();
-                // act
-                const act = () => sut.compile(script);
-                // assert
-                expect(act).to.throw(expectedError);
-            });
-            it('throws if call is not an object', () => {
-                // arrange
-                const expectedError = 'called function(s) must be an object';
-                const invalidValues = [undefined, 'string', 33];
-                const sut = new ScriptCompilerBuilder()
-                    .withSomeFunctions()
-                    .build();
-                invalidValues.forEach((invalidValue) => {
-                    const script = ScriptDataStub.createWithoutCallOrCodes() // because call ctor overwrites "undefined"
-                        .withCall(invalidValue as any);
-                    // act
-                    const act = () => sut.compile(script);
-                    // assert
-                    expect(act).to.throw(expectedError);
-                });
-            });
-            describe('invalid function reference', () => {
-                it('throws if function does not exist', () => {
-                    // arrange
-                    const sut = new ScriptCompilerBuilder()
-                        .withSomeFunctions()
-                        .build();
-                    const nonExistingFunctionName = 'non-existing-func';
-                    const expectedError = `called function is not defined "${nonExistingFunctionName}"`;
-                    const call: ScriptFunctionCallData = { function: nonExistingFunctionName };
-                    const script = ScriptDataStub.createWithCall(call);
-                    // act
-                    const act = () => sut.compile(script);
-                    // assert
-                    expect(act).to.throw(expectedError);
-                });
-                it('throws if function is undefined', () => {
-                    // arrange
-                    const existingFunctionName = 'existing-func';
-                    const sut = new ScriptCompilerBuilder()
-                        .withFunctionNames(existingFunctionName)
-                        .build();
-                    const call: ScriptFunctionCallData = [
-                        { function: existingFunctionName },
-                        undefined,
-                    ];
-                    const script = ScriptDataStub.createWithCall(call);
-                    const expectedError = `undefined function call in script "${script.name}"`;
-                    // act
-                    const act = () => sut.compile(script);
-                    // assert
-                    expect(act).to.throw(expectedError);
-                });
-                it('throws if function name is not given', () => {
-                    // arrange
-                    const existingFunctionName = 'existing-func';
-                    const sut = new ScriptCompilerBuilder()
-                        .withFunctionNames(existingFunctionName)
-                        .build();
-                    const call: FunctionCallData[] = [
-                        { function: existingFunctionName },
-                        { function: undefined }];
-                    const script = ScriptDataStub.createWithCall(call);
-                    const expectedError = `empty function name called in script "${script.name}"`;
-                    // act
-                    const act = () => sut.compile(script);
-                    // assert
-                    expect(act).to.throw(expectedError);
-                });
-            });
-            it('throws if provided parameters does not match given ones', () => {
-                // arrange
-                const unexpectedParameterName = 'unexpected-parameter-name';
-                const functionName = 'test-function-name';
-                const expectedError = `function "${functionName}" has unexpected parameter(s) provided: "${unexpectedParameterName}"`;
-                const sut = new ScriptCompilerBuilder()
-                    .withFunctions(
-                        new FunctionDataStub()
-                            .withName(functionName)
-                            .withParameters('another-parameter'))
-                    .build();
-                const params: FunctionCallParametersData = {};
-                params[unexpectedParameterName] = 'unexpected-parameter-value';
-                const call: ScriptFunctionCallData = { function: functionName, parameters: params };
-                const script = ScriptDataStub.createWithCall(call);
-                // act
-                const act = () => sut.compile(script);
-                // assert
-                expect(act).to.throw(expectedError);
-            });
+        it('throws if script is undefined', () => {
+            // arrange
+            const expectedError = 'undefined script';
+            const argument = undefined;
+            const builder = new ScriptCompilerBuilder()
+                .withEmptyFunctions()
+                .build();
+            // act
+            const act = () => builder.compile(argument);
+            // assert
+            expect(act).to.throw(expectedError);
         });
-        describe('builds code as expected', () => {
-            it('creates code with expected syntax', () => { // test through script validation logic
-                // act
-                const commentDelimiter = 'should not throw';
-                const syntax = new LanguageSyntaxStub().withCommentDelimiters(commentDelimiter);
-                const func = new FunctionDataStub()
-                    .withCode(`${commentDelimiter} duplicate-line\n${commentDelimiter} duplicate-line`);
-                const sut = new ScriptCompilerBuilder()
-                    .withFunctions(func)
-                    .withSyntax(syntax)
-                    .build();
-                const call: FunctionCallData = { function: func.name };
-                const script = ScriptDataStub.createWithCall(call);
-                // act
-                const act = () => sut.compile(script);
-                // assert
-                expect(act).to.not.throw();
-            });
-            it('builds single call as expected', () => {
-                // arrange
-                const functionName = 'testSharedFunction';
-                const expectedExecute = `expected-execute`;
-                const expectedRevert = `expected-revert`;
-                const func = new FunctionDataStub()
-                    .withName(functionName)
-                    .withCode(expectedExecute)
-                    .withRevertCode(expectedRevert);
-                const sut = new ScriptCompilerBuilder()
-                    .withFunctions(func)
-                    .build();
-                const call: FunctionCallData = { function: functionName };
-                const script = ScriptDataStub.createWithCall(call);
-                // act
-                const actual = sut.compile(script);
-                // assert
-                expect(actual.execute).to.equal(expectedExecute);
-                expect(actual.revert).to.equal(expectedRevert);
-            });
-            it('builds call sequence as expected', () => {
-                // arrange
-                const firstFunction = new FunctionDataStub()
-                    .withName('first-function-name')
-                    .withCode('first-function-code')
-                    .withRevertCode('first-function-revert-code');
-                const secondFunction = new FunctionDataStub()
-                    .withName('second-function-name')
-                    .withCode('second-function-code')
-                    .withRevertCode('second-function-revert-code');
-                const expectedExecute = `${firstFunction.code}\n${secondFunction.code}`;
-                const expectedRevert = `${firstFunction.revertCode}\n${secondFunction.revertCode}`;
-                const sut = new ScriptCompilerBuilder()
-                    .withFunctions(firstFunction, secondFunction)
-                    .build();
-                const call: FunctionCallData[] = [
-                    { function: firstFunction.name },
-                    { function: secondFunction.name },
-                ];
-                const script = ScriptDataStub.createWithCall(call);
-                // act
-                const actual = sut.compile(script);
-                // assert
-                expect(actual.execute).to.equal(expectedExecute);
-                expect(actual.revert).to.equal(expectedRevert);
-            });
+        it('returns code as expected', () => {
+            // arrange
+            const expected: ICompiledCode = {
+                code: 'expected-code',
+                revertCode: 'expected-revert-code',
+            };
+            const script = ScriptDataStub.createWithCall();
+            const functions = [ FunctionDataStub.createWithCode().withName('existing-func') ];
+            const compiledFunctions = new SharedFunctionCollectionStub();
+            const compilerMock = new FunctionCompilerStub();
+            compilerMock.setup(functions, compiledFunctions);
+            const callCompilerMock = new FunctionCallCompilerStub();
+            callCompilerMock.setup(script.call, compiledFunctions, expected);
+            const sut = new ScriptCompilerBuilder()
+                .withFunctions(...functions)
+                .withFunctionCompiler(compilerMock)
+                .withFunctionCallCompiler(callCompilerMock)
+                .build();
+            // act
+            const code = sut.compile(script);
+            // assert
+            expect(code.execute).to.equal(expected.code);
+            expect(code.revert).to.equal(expected.revertCode);
         });
-        describe('parameter substitution', () => {
-            describe('substitutes as expected', () => {
-                it('with different parameters', () => {
-                    // arrange
-                    const env = new TestEnvironment({
-                        code: 'He{{ $firstParameter }} {{ $secondParameter }}!',
-                        parameters: {
-                            firstParameter: 'llo',
-                            secondParameter: 'world',
-                        },
-                    });
-                    const expected = env.expect('Hello world!');
-                    // act
-                    const actual = env.sut.compile(env.script);
-                    // assert
-                    expect(actual).to.deep.equal(expected);
-                });
-                it('with single parameter', () => {
-                    // arrange
-                    const env = new TestEnvironment({
-                        code: '{{ $parameter }}!',
-                        parameters: {
-                            parameter: 'Hodor',
-                        },
-                    });
-                    const expected = env.expect('Hodor!');
-                    // act
-                    const actual = env.sut.compile(env.script);
-                    // assert
-                    expect(actual).to.deep.equal(expected);
-                });
-            });
-            it('throws when parameters are undefined', () => {
-                // arrange
-                const env = new TestEnvironment({
-                    code: '{{ $parameter }} {{ $parameter }}!',
-                });
-                const expectedError = 'no parameters defined, expected: "parameter"';
-                // act
-                const act = () => env.sut.compile(env.script);
-                // assert
-                expect(act).to.throw(expectedError);
-            });
-            it('throws when parameter value is not provided', () => {
-                // arrange
-                const env = new TestEnvironment({
-                    code: '{{ $parameter }} {{ $parameter }}!',
-                    parameters: {
-                        parameter: undefined,
-                    },
-                });
-                const expectedError = 'parameter value is not provided for "parameter" in function call';
-                // act
-                const act = () => env.sut.compile(env.script);
-                // assert
-                expect(act).to.throw(expectedError);
-            });
+        it('creates with expected syntax', () => {
+            // arrange
+            let isUsed = false;
+            const syntax: ILanguageSyntax = {
+                get commentDelimiters() {
+                    isUsed = true;
+                    return [];
+                },
+                get commonCodeParts() {
+                    isUsed = true;
+                    return [];
+                },
+            };
+            const sut = new ScriptCompilerBuilder()
+                .withSomeFunctions()
+                .withSyntax(syntax)
+                .build();
+            const scriptData = ScriptDataStub.createWithCall();
+            // act
+            sut.compile(scriptData);
+            // assert
+            expect(isUsed).to.equal(true);
+        });
+        it('rethrows error from ScriptCode with script name', () => {
+            // arrange
+            const scriptName = 'scriptName';            // // arrange
+            const innerError = 'innerError';
+            const expectedError = `Script "${scriptName}" ${innerError}`;
+            const callCompiler: IFunctionCallCompiler = {
+                compileCall: () => { throw new Error(innerError); },
+            };
+            const scriptData = ScriptDataStub.createWithCall()
+                .withName(scriptName);
+            const sut = new ScriptCompilerBuilder()
+                .withSomeFunctions()
+                .withFunctionCallCompiler(callCompiler)
+                .build();
+            // act
+            const act = () => sut.compile(scriptData);
+            // assert
+            expect(act).to.throw(expectedError);
         });
-        interface ITestCase {
-            code: string;
-            parameters?: FunctionCallParametersData;
-        }
-        class TestEnvironment {
-            public readonly sut: IScriptCompiler;
-            public readonly script: ScriptData;
-            constructor(testCase: ITestCase) {
-                const functionName = 'testFunction';
-                const parameters = testCase.parameters ? Object.keys(testCase.parameters) : [];
-                const func = new FunctionDataStub()
-                    .withName(functionName)
-                    .withParameters(...parameters)
-                    .withCode(this.getCode(testCase.code, 'execute'))
-                    .withRevertCode(this.getCode(testCase.code, 'revert'));
-                const syntax = new LanguageSyntaxStub();
-                this.sut = new ScriptCompiler([func], syntax);
-                const call: FunctionCallData = {
-                    function: functionName,
-                    parameters: testCase.parameters,
-                };
-                this.script = ScriptDataStub.createWithCall(call);
-            }
-            public expect(code: string): IScriptCode {
-                return {
-                    execute: this.getCode(code, 'execute'),
-                    revert: this.getCode(code, 'revert'),
-                };
-            }
-            private getCode(text: string, type: 'execute' | 'revert'): string {
-                return `${text} (${type})`;
-            }
-        }
     });
 });
 
-
-// tslint:disable-next-line:max-classes-per-file
 class ScriptCompilerBuilder {
     private static createFunctions(...names: string[]): FunctionData[] {
         return names.map((functionName) => {
-            return new FunctionDataStub().withName(functionName);
+            return FunctionDataStub.createWithCode().withName(functionName);
         });
     }
     private functions: FunctionData[];
     private syntax: ILanguageSyntax = new LanguageSyntaxStub();
+    private functionCompiler: IFunctionCompiler = new FunctionCompilerStub();
+    private callCompiler: IFunctionCallCompiler = new FunctionCallCompilerStub();
     public withFunctions(...functions: FunctionData[]): ScriptCompilerBuilder {
         this.functions = functions;
         return this;
@@ -416,10 +175,18 @@ class ScriptCompilerBuilder {
         this.syntax = syntax;
         return this;
     }
+    public withFunctionCompiler(functionCompiler: IFunctionCompiler): ScriptCompilerBuilder {
+        this.functionCompiler = functionCompiler;
+        return this;
+    }
+    public withFunctionCallCompiler(callCompiler: IFunctionCallCompiler): ScriptCompilerBuilder {
+        this.callCompiler = callCompiler;
+        return this;
+    }
     public build(): ScriptCompiler {
         if (!this.functions) {
             throw new Error('Function behavior not defined');
         }
-        return new ScriptCompiler(this.functions, this.syntax);
+        return new ScriptCompiler(this.functions, this.syntax, this.functionCompiler, this.callCompiler);
     }
 }

tests/unit/application/Parser/Script/ScriptParser.spec.ts

@@ -112,7 +112,7 @@ describe('ScriptParser', () => {
             });
         });
         describe('code', () => {
-            it('parses code as expected', () => {
+            it('parses "execute" as expected', () => {
                 // arrange
                 const expected = 'expected-code';
                 const script = ScriptDataStub
@@ -125,7 +125,7 @@ describe('ScriptParser', () => {
                 const actual = parsed.code.execute;
                 expect(actual).to.equal(expected);
             });
-            it('parses revertCode as expected', () => {
+            it('parses "revert" as expected', () => {
                 // arrange
                 const expected = 'expected-revert-code';
                 const script = ScriptDataStub