@testgorilla/tgo-coding-test 0.0.1

package/src/lib/components/code-editor/code-editor.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import {
+  CodeEditorCHelper,
+  CodeEditorCppHelper,
+  CodeEditorCSharpHelper,
+  CodeEditorGoHelper,
+  CodeEditorJavaHelper,
+  CodeEditorJavascriptHelper,
+  CodeEditorKotlinHelper,
+  CodeEditorPhpHelper,
+  CodeEditorPythonHelper,
+  CodeEditorRHelper,
+  CodeEditorRubyHelper,
+  CodeEditorScalaHelper,
+  CodeEditorSqlHelper,
+  CodeEditorSwiftHelper,
+  CodeEditorTypescriptHelper,
+} from './helpers';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+} from './helpers/code-editor-helper.model';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CodeEditorService {
+  private helper: CodeEditorHelper;
+
+  setHelper(language: string, funcParams: CodeEditorFuncOptions): void {
+    this.helper = this.createHelper(language, funcParams);
+  }
+
+  getInitCode(): string {
+    return this.helper.getInitCode();
+  }
+
+  getEditorLang(): string {
+    return this.helper.getEditorLang();
+  }
+
+  private createHelper(lang: string, funcParams: CodeEditorFuncOptions): CodeEditorHelper {
+    // todo: review this logic according to new TAT, remove generated init code if not needed ?
+    switch (lang as CodeEditorLanguages) {
+      case CodeEditorLanguages.Javascript:
+        return new CodeEditorJavascriptHelper(funcParams);
+      case CodeEditorLanguages.Typescript:
+        return new CodeEditorTypescriptHelper(funcParams);
+      case CodeEditorLanguages.Php:
+        return new CodeEditorPhpHelper(funcParams);
+      case CodeEditorLanguages.Python:
+        return new CodeEditorPythonHelper(funcParams);
+      case CodeEditorLanguages.Java:
+        return new CodeEditorJavaHelper(funcParams);
+      case CodeEditorLanguages.Ruby:
+        return new CodeEditorRubyHelper(funcParams);
+      case CodeEditorLanguages.C:
+        return new CodeEditorCHelper(funcParams);
+      case CodeEditorLanguages.Cpp:
+        return new CodeEditorCppHelper(funcParams);
+      case CodeEditorLanguages.R:
+        return new CodeEditorRHelper(funcParams);
+      case CodeEditorLanguages.Scala:
+        return new CodeEditorScalaHelper(funcParams);
+      case CodeEditorLanguages.CSharp:
+      case CodeEditorLanguages.CSharpLegacy:
+        return new CodeEditorCSharpHelper(funcParams);
+      case CodeEditorLanguages.Go:
+        return new CodeEditorGoHelper(funcParams);
+      case CodeEditorLanguages.Sql:
+      case CodeEditorLanguages.Sqlite:
+        return new CodeEditorSqlHelper(funcParams);
+      default: {
+        const versionedHelper = lang && this.getVersionedHelper(lang, funcParams);
+
+        if (!versionedHelper) {
+          throw new Error(`language ${lang} is not supported`);
+        }
+
+        return versionedHelper;
+      }
+    }
+  }
+
+  private getVersionedHelper(lang: string, funcParams: CodeEditorFuncOptions): CodeEditorHelper {
+    if (lang.startsWith(CodeEditorLanguages.Kotlin)) {
+      return new CodeEditorKotlinHelper(funcParams);
+    }
+    if (lang.startsWith(CodeEditorLanguages.Swift)) {
+      return new CodeEditorSwiftHelper(funcParams);
+    }
+  }
+}

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

@@ -0,0 +1,39 @@
+import { CodeEditorCHelper } from './c-helper';
+import { defaultFuncParams } from './code-editor-helper.mocks';
+
+describe('CodeEditorCHelper', () => {
+  let helper: CodeEditorCHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const correctFuncOpening =
+    'bool mockFunction(bool param1, int param2, double param3, float param4, char * param5, bool * param6, int * param7, float * param8) {\n';
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorCHelper(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/c-helper.ts

@@ -0,0 +1,51 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorCHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.C;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'bool',
+    int: 'int',
+    number: 'int',
+    double: 'double',
+    float: 'float',
+    str: 'char *',
+    array_boolean: 'bool *',
+    array_int: 'int *',
+    array_float: 'float *',
+    array_double: 'double *',
+  };
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${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 `${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/code-editor-helper.base.spec.ts

@@ -0,0 +1,30 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import { CodeEditorLanguages } from './code-editor-helper.model';
+
+class Helper extends CodeEditorHelperBase {
+  language = CodeEditorLanguages.Javascript;
+
+  getFunctionOpening(): string {
+    return 'func opening\n';
+  }
+}
+
+describe('CodeEditorHelperBase', () => {
+  let helper: Helper;
+
+  beforeEach(() => {
+    helper = new Helper();
+  });
+
+  describe('when getting editor language', () => {
+    let result: string;
+
+    beforeEach(() => {
+      result = helper.getEditorLang();
+    });
+
+    it('should return helper language', () => {
+      expect(result).toEqual(CodeEditorLanguages.Javascript);
+    });
+  });
+});

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

@@ -0,0 +1,16 @@
+import { CodeEditorLanguages, CodeEditorTypesMap } from './code-editor-helper.model';
+
+export abstract class CodeEditorHelperBase {
+  protected language: CodeEditorLanguages;
+  protected typesMap: CodeEditorTypesMap;
+
+  abstract getFunctionOpening(): string;
+
+  getEditorLang(): CodeEditorLanguages {
+    return this.language;
+  }
+
+  protected parseType(type: keyof CodeEditorTypesMap): string {
+    return this.typesMap[type];
+  }
+}

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

@@ -0,0 +1,24 @@
+import { CodeEditorFuncOptions } from './code-editor-helper.model';
+
+export const initCodeMock = 'export function mock(param1, param2) { return param1; }';
+
+export const defaultFuncParams: CodeEditorFuncOptions = {
+  params: [
+    {
+      name: 'param1',
+      type: 'boolean',
+    },
+    {
+      name: 'param2',
+      type: 'int',
+    },
+    { name: 'param3', type: 'double' },
+    { name: 'param4', type: 'float' },
+    { name: 'param5', type: 'str' },
+    { name: 'param6', type: 'array_boolean' },
+    { name: 'param7', type: 'array_int' },
+    { name: 'param8', type: 'array_float' },
+  ],
+  name: 'mockFunction',
+  returnType: 'boolean',
+};

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

@@ -0,0 +1,67 @@
+export interface CodeEditorHelper {
+  getInitCode?(): string;
+  getEditorLang(): string;
+}
+
+export const enum CodeEditorLanguages {
+  Javascript = 'javascript',
+  Typescript = 'typescript',
+  Elixir = 'elixir',
+  Rust = 'rust',
+  Dart = 'dart',
+  Erlang = 'erlang',
+  Julia = 'julia',
+  Perl = 'perl',
+  Php = 'php',
+  Python = 'python',
+  Java = 'java',
+  Kotlin = 'kotlin',
+  Ruby = 'ruby',
+  C = 'c',
+  Cpp = 'c++',
+  CppEditor = 'cpp',
+  R = 'r',
+  Swift = 'swift',
+  Scala = 'scala',
+  CSharp = 'c#',
+  CSharpEditor = 'csharp',
+  CSharpLegacy = 'c#_legacy',
+  Go = 'go',
+  Sql = 'sql',
+  Sqlite = 'sqlite3',
+}
+
+export const enum CodeEditorSqlOperations {
+  Select = 'SELECT',
+  Update = 'UPDATE',
+  Insert = 'INSERT',
+  Delete = 'DELETE',
+  CreateTable = 'CREATE TABLE',
+}
+
+export interface CodeEditorFuncOptions {
+  name?: string | CodeEditorSqlOperations;
+  params?: CodeEditorFuncParam[];
+  returnType?: keyof CodeEditorTypesMap;
+}
+
+export interface CodeEditorFuncParam {
+  id?: string;
+  name?: string;
+  order?: string;
+  type?: keyof CodeEditorTypesMap;
+}
+
+export interface CodeEditorTypesMap {
+  boolean: string;
+  int: string;
+  number?: string;
+  double: string;
+  float: string;
+  str: string;
+  array_boolean: string;
+  array_int: string;
+  array_float: string;
+  array_double?: string;
+  array_str?: string;
+}

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

@@ -0,0 +1,40 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorCppHelper } from './cpp-helper';
+
+describe('CodeEditorCppHelper', () => {
+  let helper: CodeEditorCppHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'bool param1, int param2, double param3, float param4, std::string param5, std::vector<bool> param6, std::vector<int> param7, std::vector<float> param8';
+  const correctFuncOpening = `bool mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorCppHelper(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/cpp-helper.ts

@@ -0,0 +1,52 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorCppHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.CppEditor;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'bool',
+    int: 'int',
+    number: 'int',
+    double: 'double',
+    float: 'float',
+    str: 'std::string',
+    array_boolean: 'std::vector<bool>',
+    array_int: 'std::vector<int>',
+    array_float: 'std::vector<float>',
+    array_double: 'std::vector<double>',
+    array_str: 'std::vector<std::string>',
+  };
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${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 `${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/csharp-helper.spec.ts

@@ -0,0 +1,42 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorCSharpHelper } from './csharp-helper';
+
+describe('CodeEditorCSharpHelper', () => {
+  let helper: CodeEditorCSharpHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'bool param1, int param2, double param3, float param4, string param5, bool[] param6, int[] param7, Float[] param8';
+  const correctFuncOpening = `\t\tpublic static bool mockFunction(${paramsList}) {\n`;
+  const importText =
+    'using System;\nusing System.Linq;\nnamespace TestTaker\n{\n\tpublic static class CustomCode\n\t{\n';
+  const correctInitCode = `${importText}${correctFuncOpening}\t\t //Insert your code here \n\t\t}\n\t}\n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorCSharpHelper(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/csharp-helper.ts

@@ -0,0 +1,55 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+import {
+  CodeEditorFuncOptions,
+  CodeEditorHelper,
+  CodeEditorLanguages,
+  CodeEditorTypesMap,
+} from './code-editor-helper.model';
+
+export class CodeEditorCSharpHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.CSharpEditor;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'bool',
+    int: 'int',
+    number: 'int',
+    double: 'double',
+    float: 'float',
+    str: 'string',
+    array_boolean: 'bool[]',
+    array_int: 'int[]',
+    array_float: 'Float[]',
+    array_double: 'double[]',
+    array_str: 'string[]',
+  };
+
+  private importText =
+    'using System;\nusing System.Linq;\nnamespace TestTaker\n{\n\tpublic static class CustomCode\n\t{\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.importText}${this.getFunctionOpening()}\t\t //Insert your code here \n\t\t}\n\t}\n}`;
+  }
+
+  getFunctionOpening(): string {
+    const { name: funcName, returnType } = this.functionOptions;
+    const params = this.getParamsString();
+    const showingReturnType = this.parseType(returnType);
+
+    return `\t\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/go-helper.spec.ts

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorGoHelper } from './go-helper';
+
+describe('CodeEditorGoHelper', () => {
+  let helper: CodeEditorGoHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'param1 bool, param2 int, param3 double, param4 float64, param5 string, param6 []bool, param7 []int, param8 []float64';
+  const correctFuncOpening = `func MockFunction(${paramsList}) bool {\n`;
+  const importPackagesText = 'package testtaker\nimport ()\n';
+  const correctInitCode = `${importPackagesText}${correctFuncOpening}\t //Insert your code here \n}`;
+
+  beforeEach(() => {
+    helper = new CodeEditorGoHelper(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/go-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 CodeEditorGoHelper extends CodeEditorHelperBase implements CodeEditorHelper {
+  language = CodeEditorLanguages.Go;
+  typesMap: CodeEditorTypesMap = {
+    boolean: 'bool',
+    int: 'int',
+    number: 'int',
+    double: 'double',
+    float: 'float64',
+    str: 'string',
+    array_boolean: '[]bool',
+    array_int: '[]int',
+    array_float: '[]float64',
+    array_str: '[]string',
+  };
+
+  private importPackagesText = 'package testtaker\nimport ()\n';
+
+  constructor(private functionOptions: CodeEditorFuncOptions) {
+    super();
+  }
+
+  getInitCode(): string {
+    return `${this.importPackagesText}${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);
+    const uppercasedFuncName = `${funcName.charAt(0).toUpperCase()}${funcName.slice(1)}`;
+
+    return `func ${uppercasedFuncName}(${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/index.ts

@@ -0,0 +1,15 @@
+export { CodeEditorCHelper } from './c-helper';
+export { CodeEditorCppHelper } from './cpp-helper';
+export { CodeEditorCSharpHelper } from './csharp-helper';
+export { CodeEditorGoHelper } from './go-helper';
+export { CodeEditorJavaHelper } from './java-helper';
+export { CodeEditorJavascriptHelper } from './javascript-helper';
+export { CodeEditorKotlinHelper } from './kotlin-helper';
+export { CodeEditorPhpHelper } from './php-helper';
+export { CodeEditorPythonHelper } from './python-helper';
+export { CodeEditorRHelper } from './r-helper';
+export { CodeEditorRubyHelper } from './ruby-helper';
+export { CodeEditorScalaHelper } from './scala-helper';
+export { CodeEditorSqlHelper } from './sql-helper';
+export { CodeEditorSwiftHelper } from './swift-helper';
+export { CodeEditorTypescriptHelper } from './typescript-helper';

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

@@ -0,0 +1,41 @@
+import { defaultFuncParams } from './code-editor-helper.mocks';
+import { CodeEditorJavaHelper } from './java-helper';
+
+describe('CodeEditorJavaHelper', () => {
+  let helper: CodeEditorJavaHelper;
+
+  const defaultParams = { ...defaultFuncParams };
+  const paramsList =
+    'Boolean param1, Integer param2, Double param3, Float param4, String param5, Boolean[] param6, Integer[] param7, Float[] param8';
+  const classOpening = 'public class TestTaker {\n';
+  const correctFuncOpening = `\tpublic static Boolean mockFunction(${paramsList}) {\n`;
+  const correctInitCode = `${classOpening}${correctFuncOpening}\t\t //Insert your code here \n\t}\n`;
+
+  beforeEach(() => {
+    helper = new CodeEditorJavaHelper(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);
+    });
+  });
+});