@testgorilla/tgo-coding-test 0.0.1

package/src/lib/components/code-editor/helpers/java-helper.ts

@@ -0,0 +1,54 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorJavaHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Java;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Integer',
+    number: 'Integer',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Boolean[]',
+    array_int: 'Integer[]',
+    array_float: 'Float[]',
+    array_double: 'Double[]',
+    array_str: 'String[]',
+  };
+
+  private classOpening = 'public class TestTaker {\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.classOpening}${this.getFunctionOpening()}\t\t //Insert your code here \n\t}\n`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName, returnType } = this.functionOptions;
+    const params = this.getParamsString();
+    const showingReturnType = this.parseType(returnType);
+
+    return `\tpublic static ${showingReturnType} ${funcName}(${params}) {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${this.parseType(values.type)} ${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/javascript-helper.spec.ts

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorJavascriptHelper } from './javascript-helper';
+
+describe('CodeEditorJavascriptHelper', () => {
+  let helper: CodeEditorJavascriptHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = 'param1, param2, param3, param4, param5, param6, param7, param8';
+  const correctFuncOpening = `export function mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorJavascriptHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/javascript-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorJavascriptHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Javascript;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t //Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `export function ${funcName}(${this.getParamsString()}) {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/kotlin-helper.spec.ts

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorKotlinHelper } from './kotlin-helper';
+
+describe('CodeEditorKotlinHelper', () => {
+  let helper: CodeEditorKotlinHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'param1: Boolean, param2: Int, param3: Double, param4: Float, param5: String, param6: Array<Boolean>, param7: Array<Int>, param8: Array<Float>';
+  const packages = 'package com.testgorilla.testtaker\n';
+  const correctFuncOpening = `fun mockFunction(${paramsList}): Boolean {\n`;
+  const correctInitCode = `${packages}${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorKotlinHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/kotlin-helper.ts

@@ -0,0 +1,54 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorKotlinHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Kotlin;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Int',
+    number: 'int',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Array<Boolean>',
+    array_int: 'Array<Int>',
+    array_float: 'Array<Float>',
+    array_double: 'Array<Double>',
+    array_str: 'Array<String>',
+  };
+
+  private packagesText = 'package com.testgorilla.testtaker\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.packagesText}${this.getFunctionOpening()}\t //Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName, returnType } = this.functionOptions;
+    const params = this.getParamsString();
+    const showingReturnType = this.parseType(returnType);
+
+    return `fun ${funcName}(${params}): ${showingReturnType} {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}: ${this.parseType(values.type)}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/php-helper.spec.ts

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorPhpHelper } from './php-helper';
+
+describe('CodeEditorPhpHelper', () => {
+  let helper: CodeEditorPhpHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = '$param1, $param2, $param3, $param4, $param5, $param6, $param7, $param8';
+  const correctFuncOpening = `<?php function mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}\n ?>`;
+
+  beforeEach(() => {
+    helper = new CodeEditorPhpHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/php-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorPhpHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Php;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t //Insert your code here \n}\n ?>`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `<?php function ${funcName}(${this.getParamsString()}) {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `$${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/python-helper.spec.ts

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorPythonHelper } from './python-helper';
+
+describe('CodeEditorPythonHelper', () => {
+  let helper: CodeEditorPythonHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = 'param1, param2, param3, param4, param5, param6, param7, param8';
+  const correctFuncOpening = `def mockFunction(${paramsList}): \n`;
+  const correctInitCode = `${correctFuncOpening}\t #Insert your code here \n`;
+
+  beforeEach(() => {
+    helper = new CodeEditorPythonHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/python-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorPythonHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Python;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \n`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `def ${funcName}(${this.getParamsString()}): \n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/r-helper.spec.ts

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorRHelper } from './r-helper';
+
+describe('CodeEditorRHelper', () => {
+  let helper: CodeEditorRHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = 'param1, param2, param3, param4, param5, param6, param7, param8';
+  const correctFuncOpening = `mockFunction <- function(${paramsList}) {\n`;
+  const correctInitCode = `${correctFuncOpening}\t #Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorRHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/r-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorRHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.R;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `${funcName} <- function(${this.getParamsString()}) {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/ruby-helper.spec.ts

@@ -0,0 +1,39 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorRubyHelper } from './ruby-helper';
+
+describe('CodeEditorRubyHelper', () => {
+  let helper: CodeEditorRubyHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList = 'param1, param2, param3, param4, param5, param6, param7, param8';
+  const correctFuncOpening = `def mockFunction(${paramsList})\n`;
+  const correctInitCode = `${correctFuncOpening}\t #Insert your code here \nend`;
+
+  beforeEach(() => {
+    helper = new CodeEditorRubyHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/ruby-helper.ts

@@ -0,0 +1,32 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorFuncOptions, CodeEditorHelper, CodeEditorLanguages } from './code-editor-helper.model';
+
+export class CodeEditorRubyHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Ruby;
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.getFunctionOpening()}\t #Insert your code here \nend`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName } = this.functionOptions;
+
+    return `def ${funcName}(${this.getParamsString()})\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}

package/src/lib/components/code-editor/helpers/scala-helper.spec.ts

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorScalaHelper } from './scala-helper';
+
+describe('CodeEditorScalaHelper', () => {
+  let helper: CodeEditorScalaHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'param1: Boolean, param2: Int, param3: Double, param4: Float, param5: String, param6: Array[Boolean], param7: Array[Integer], param8: Array[Float]';
+  const packages = 'package Testgorilla\nobject TestTaker\n';
+  const correctFuncOpening = `def mockFunction(${paramsList}) : Boolean = {\n`;
+  const correctInitCode = `${packages}${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorScalaHelper(defaultParams);
+  });
+
+  describe('when getting init code', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getInitCode();
+    });
+
+    it('should return proper init code', () => {
+      expect(result).toEqual(correctInitCode);
+    });
+  });
+
+  describe('when getting func opening', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getFunctionOpening();
+    });
+
+    it('should return proper func opening', () => {
+      expect(result).toEqual(correctFuncOpening);
+    });
+  });
+});

package/src/lib/components/code-editor/helpers/scala-helper.ts

@@ -0,0 +1,53 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorScalaHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Scala;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'Boolean',
+    int: 'Int',
+    double: 'Double',
+    float: 'Float',
+    str: 'String',
+    array_boolean: 'Array[Boolean]',
+    array_int: 'Array[Integer]',
+    array_float: 'Array[Float]',
+    array_double: 'Array[Double]',
+    array_str: 'Array[String]',
+  };
+
+  private packagesText = 'package Testgorilla\nobject TestTaker\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.packagesText}${this.getFunctionOpening()}\t //Insert your code here \n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName, returnType } = this.functionOptions;
+    const params = this.getParamsString();
+    const showingReturnType = this.parseType(returnType);
+
+    return `def ${funcName}(${params}) : ${showingReturnType} = {\n`;
+  }
+
+  private getParamsString(): string {
+    const { params } = this.functionOptions;
+    let paramsString = '';
+
+    if (params && params.length > 0) {
+      params.forEach(values => (paramsString += `${values.name}: ${this.parseType(values.type)}, `));
+      paramsString = paramsString.slice(0, -2);
+    }
+
+    return paramsString;
+  }
+}