Add optionality for parameters

This commit allows for parameters that does not require any arguments to
be provided in function calls. It changes collection syntax where
parameters are list of objects instead of primitive strings. A
parameter has now 'name' and 'optional' properties. 'name' is required
and used in same way as older strings as parameter definitions.
'Optional' property is optional, 'false' is the default behavior if
undefined. It also adds additional validation to restrict parameter
names to alphanumeric strings to have a clear syntax in expressions.

tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter.spec.ts

@@ -0,0 +1,47 @@
+import 'mocha';
+import { expect } from 'chai';
+import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
+import { testParameterName } from '../../ParameterNameTestRunner';
+
+describe('FunctionParameter', () => {
+    describe('name', () => {
+        testParameterName(
+            (parameterName) => new FunctionParameterBuilder()
+                .withName(parameterName)
+                .build()
+                .name,
+        );
+    });
+    describe('isOptional', () => {
+        describe('sets as expected', () => {
+            // arrange
+            const expectedValues = [ true, false];
+            for (const expected of expectedValues) {
+                it(expected.toString(), () => {
+                    // act
+                    const sut = new FunctionParameterBuilder()
+                        .withIsOptional(expected)
+                        .build();
+                    // expect
+                    expect(sut.isOptional).to.equal(expected);
+                });
+            }
+        });
+    });
+});
+
+class FunctionParameterBuilder {
+    private name = 'parameterFromParameterBuilder';
+    private isOptional = false;
+    public withName(name: string) {
+        this.name = name;
+        return this;
+    }
+    public withIsOptional(isOptional: boolean) {
+        this.isOptional = isOptional;
+        return this;
+    }
+    public build() {
+        return new FunctionParameter(this.name, this.isOptional);
+    }
+}

tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts

@@ -0,0 +1,47 @@
+import 'mocha';
+import { expect } from 'chai';
+import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
+import { FunctionParameterStub } from '@tests/unit/stubs/FunctionParameterStub';
+
+describe('FunctionParameterCollection', () => {
+    it('all returns added parameters as expected', () => {
+        // arrange
+        const expected = [
+            new FunctionParameterStub().withName('1'),
+            new FunctionParameterStub().withName('2').withOptionality(true),
+            new FunctionParameterStub().withName('3').withOptionality(false),
+        ];
+        const sut = new FunctionParameterCollection();
+        for (const parameter of expected) {
+            sut.addParameter(parameter);
+        }
+        // act
+        const actual = sut.all;
+        // assert
+        expect(expected).to.deep.equal(actual);
+    });
+    it('throws when function parameters have same names', () => {
+        // arrange
+        const parameterName = 'duplicate-parameter';
+        const expectedError = `duplicate parameter name: "${parameterName}"`;
+        const sut = new FunctionParameterCollection();
+        sut.addParameter(new FunctionParameterStub().withName(parameterName));
+        // act
+        const act = () =>
+            sut.addParameter(new FunctionParameterStub().withName(parameterName));
+        // assert
+        expect(act).to.throw(expectedError);
+    });
+    describe('addParameter', () => {
+        it('throws if parameter is undefined', () => {
+            // arrange
+            const expectedError = 'undefined parameter';
+            const value = undefined;
+            const sut = new FunctionParameterCollection();
+            // act
+            const act = () => sut.addParameter(value);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+    });
+});