Add support for more depth in function calls

It allow pipes to be used in nested functions. Before, pipes were added
to a variable before variable content was evaluated/compiled by
another function. This commit ensures that the commits are evaluted in
expected order.

The issue is solved by stopping precompiling functions. It makes code
less complex. It adds to compile time of the script file but nothing
noticable and something optimizable.

The problem was that the call trees we're not executed in expected
order. E.g. let's say we have functionA that outputs something like
"Hello {{ $name| pipe }}", and we have function B calling with "name:
dear {{ $firstName}}", and at last we have a script that's calling
function B with "firstName: undergroundwires". Before, expressions were
evaluated directly, meaning that function A would become:
"Hello Dear {{ $firstName}}", as you see the pipe in function A
is lost here after being applied to function B and not reaching
$firstTime input value. Parsing expressions in the end allows for pipes
etc. to not get lost.

The commit also does necessary name refactorings and folder refactorings
to reflect logical changes. `FunctionCompiler` is renamed to
`SharedFunctionsParser` as precompiling is removed and it just simply
parses now. `/FunctionCall/` is moved to `/Function/Call`.

Finally, it improves documentation and adds more tests.

tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts

@@ -0,0 +1,46 @@
+import 'mocha';
+import { expect } from 'chai';
+import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
+import { testParameterName } from '../../../ParameterNameTestRunner';
+
+describe('FunctionCallArgument', () => {
+    describe('ctor', () => {
+        describe('parameter name', () => {
+            testParameterName(
+                (parameterName) => new FunctionCallArgumentBuilder()
+                    .withParameterName(parameterName)
+                    .build()
+                    .parameterName,
+            );
+        });
+        it('throws if argument value is undefined', () => {
+            // arrange
+            const parameterName = 'paramName';
+            const expectedError = `undefined argument value for "${parameterName}"`;
+            const argumentValue = undefined;
+            // act
+            const act = () => new FunctionCallArgumentBuilder()
+                .withParameterName(parameterName)
+                .withArgumentValue(argumentValue)
+                .build();
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+    });
+});
+
+class FunctionCallArgumentBuilder {
+    private parameterName = 'default-parameter-name';
+    private argumentValue = 'default-argument-value';
+    public withParameterName(parameterName: string) {
+        this.parameterName = parameterName;
+        return this;
+    }
+    public withArgumentValue(argumentValue: string) {
+        this.argumentValue = argumentValue;
+        return this;
+    }
+    public build() {
+        return new FunctionCallArgument(this.parameterName, this.argumentValue);
+    }
+}

tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection.spec.ts

@@ -0,0 +1,143 @@
+import 'mocha';
+import { expect } from 'chai';
+import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
+import { FunctionCallArgumentStub } from '@tests/unit/stubs/FunctionCallArgumentStub';
+
+describe('FunctionCallArgumentCollection', () => {
+    describe('addArgument', () => {
+        it('throws if argument is undefined', () => {
+            // arrange
+            const errorMessage = 'undefined argument';
+            const arg = undefined;
+            const sut = new FunctionCallArgumentCollection();
+            // act
+            const act = () => sut.addArgument(arg);
+            // assert
+            expect(act).to.throw(errorMessage);
+        });
+        it('throws if parameter value is already provided', () => {
+            // arrange
+            const duplicateParameterName = 'duplicateParam';
+            const errorMessage = `argument value for parameter ${duplicateParameterName} is already provided`;
+            const arg1 = new FunctionCallArgumentStub().withParameterName(duplicateParameterName);
+            const arg2 = new FunctionCallArgumentStub().withParameterName(duplicateParameterName);
+            const sut = new FunctionCallArgumentCollection();
+            // act
+            sut.addArgument(arg1);
+            const act = () => sut.addArgument(arg2);
+            // assert
+            expect(act).to.throw(errorMessage);
+        });
+    });
+    describe('getAllParameterNames', () => {
+        it('returns as expected', () => {
+            // arrange
+            const testCases = [ {
+                name: 'no args',
+                args: [],
+                expected: [],
+            }, {
+                name: 'with some args',
+                args: [
+                    new FunctionCallArgumentStub().withParameterName('a-param-name'),
+                    new FunctionCallArgumentStub().withParameterName('b-param-name')],
+                expected: [ 'a-param-name', 'b-param-name'],
+            }];
+            for (const testCase of testCases) {
+                it(testCase.name, () => {
+                    const sut = new FunctionCallArgumentCollection();
+                    // act
+                    for (const arg of testCase.args) {
+                        sut.addArgument(arg);
+                    }
+                    const actual = sut.getAllParameterNames();
+                    // assert
+                    expect(actual).to.equal(testCase.expected);
+                });
+            }
+        });
+    });
+    describe('getArgument', () => {
+        it('throws if parameter name is undefined', () => {
+            // arrange
+            const expectedError = 'undefined parameter name';
+            const undefinedValues = [ '', undefined ];
+            for (const undefinedValue of undefinedValues) {
+                const sut = new FunctionCallArgumentCollection();
+                // act
+                const act = () => sut.getArgument(undefinedValue);
+                // assert
+                expect(act).to.throw(expectedError);
+            }
+        });
+        it('throws if argument does not exist', () => {
+            // arrange
+            const parameterName = 'nonExistingParam';
+            const expectedError = `parameter does not exist: ${parameterName}`;
+            const sut = new FunctionCallArgumentCollection();
+            // act
+            const act = () => sut.getArgument(parameterName);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        it('returns argument as expected', () => {
+            // arrange
+            const expected = new FunctionCallArgumentStub()
+                .withParameterName('expectedName')
+                .withArgumentValue('expectedValue');
+            const sut = new FunctionCallArgumentCollection();
+            // act
+            sut.addArgument(expected);
+            const actual = sut.getArgument(expected.parameterName);
+            // assert
+            expect(actual).to.equal(expected);
+        });
+    });
+    describe('hasArgument', () => {
+        it('throws if parameter name is undefined', () => {
+            // arrange
+            const expectedError = 'undefined parameter name';
+            const undefinedValues = [ '', undefined ];
+            for (const undefinedValue of undefinedValues) {
+                const sut = new FunctionCallArgumentCollection();
+                // act
+                const act = () => sut.hasArgument(undefinedValue);
+                // assert
+                expect(act).to.throw(expectedError);
+            }
+        });
+        describe('returns as expected', () => {
+            // arrange
+            const testCases = [ {
+                name: 'argument exists',
+                parameter: 'existing-parameter-name',
+                args: [
+                    new FunctionCallArgumentStub().withParameterName('existing-parameter-name'),
+                    new FunctionCallArgumentStub().withParameterName('unrelated-parameter-name'),
+                ],
+                expected: true,
+            },
+            {
+                name: 'argument does not exist',
+                parameter: 'not-existing-parameter-name',
+                args: [
+                    new FunctionCallArgumentStub().withParameterName('unrelated-parameter-name-b'),
+                    new FunctionCallArgumentStub().withParameterName('unrelated-parameter-name-a'),
+                ],
+                expected: false,
+            }];
+            for (const testCase of testCases) {
+                it(`"${testCase.name}" returns "${testCase.expected}"`, () => {
+                    const sut = new FunctionCallArgumentCollection();
+                    // act
+                    for (const arg of testCase.args) {
+                        sut.addArgument(arg);
+                    }
+                    const actual = sut.hasArgument(testCase.parameter);
+                    // assert
+                    expect(actual).to.equal(testCase.expected);
+                });
+            }
+        });
+    });
+});