Refactor code to comply with ESLint rules

Major refactoring using ESLint with rules from AirBnb and Vue.

Enable most of the ESLint rules and do necessary linting in the code.
Also add more information for rules that are disabled to describe what
they are and why they are disabled.

Allow logging (`console.log`) in test files, and in development mode
(e.g. when working with `npm run serve`), but disable it when
environment is production (as pre-configured by Vue). Also add flag
(`--mode production`) in `lint:eslint` command so production linting is
executed earlier in lifecycle.

Disable rules that requires a separate work. Such as ESLint rules that
are broken in TypeScript: no-useless-constructor (eslint/eslint#14118)
and no-shadow (eslint/eslint#13014).

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

@@ -4,43 +4,47 @@ import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Funct
 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);
-        });
+  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);
-    }
+  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

@@ -4,140 +4,140 @@ import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Comp
 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('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);
     });
-    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);
-                });
-            }
-        });
+    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('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('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('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);
-                });
-            }
-        });
+  });
+  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);
+        });
+      }
+    });
+  });
 });