cleaning the modules and seperate main modules

package.json

@@ -11,10 +11,12 @@
     "prettier": "^1.16.4",
     "prettier-tslint": "^0.4.2",
     "ts-jest": "^23.10.4",
+    "tslint-config-prettier": "^1.18.0",
     "typescript": "^3.1.3"
   },
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "perrty": "prettier-tslint"
   },
   "husky": {
     "hooks": {

src/mathString.test.ts

@@ -1,4 +1,13 @@
-import MathString from "./mathString";
+import solve from "./mathString";
+import {
+  selectNumbers,
+  selectParantheses,
+  selectMultiplicationOrDivisionePhrase
+} from "./selectModules";
+import {
+  solveMultiplicationOrDivision,
+  solveMathPhrases
+} from "./solveModules";
 const operator = ["+", "-", "*", "/"];
 let input: string[] = [
   "1+11+       +9-11e23",
@@ -13,45 +22,38 @@ let input: string[] = [
 ];
 
 describe("test Regex for inputs", () => {
-  const mathString = new MathString();
   it("select numbers", () => {
-    expect(mathString.selectNumbers(input[0])).toEqual([
-      "1",
-      "+11",
-      "+9",
-      "-11e23"
-    ]);
+    expect(selectNumbers(input[0])).toEqual(["1", "+11", "+9", "-11e23"]);
   });
   it("select parantesses and numbers between them", () => {
-    expect(mathString.selectParantheses(input[1])).toEqual([
+    expect(selectParantheses(input[1])).toEqual([
       "(1+1)",
       "(1111)",
       "(1*1/2/5-1+1)"
     ]);
   });
   it("select multiple or divide two numbers", () => {
-    expect(mathString.selectMultiplicationOrDivisionePhrase(input[1])).toEqual([
+    expect(selectMultiplicationOrDivisionePhrase(input[1])).toEqual([
       "1*1",
       "2/5"
     ]);
   });
 });
 xdescribe("solve phrases math", () => {
-  const mathString = new MathString();
   it("solve multiplication and return possitive", () => {
-    expect(mathString.solveMultiplicationOrDivision(input[2])).toBe("+9");
+    expect(solveMultiplicationOrDivision(input[2])).toBe("+9");
   });
   it("solve multiplication and return negative", () => {
-    expect(mathString.solveMultiplicationOrDivision(input[3])).toBe("-9");
+    expect(solveMultiplicationOrDivision(input[3])).toBe("-9");
   });
   it("solve division", () => {
-    expect(mathString.solveMultiplicationOrDivision(input[4])).toBe("+2");
+    expect(solveMultiplicationOrDivision(input[4])).toBe("+2");
   });
   it("solve a phrase without parantheses", () => {
-    expect(mathString.solveMathPhrases(input[5])).toBe("-3");
+    expect(solveMathPhrases(input[5])).toBe("-3");
   });
   it("solve a phrase with parantheses", () => {
-    expect(mathString.solve(input[7])).toBe("+97.5");
-    expect(mathString.solve(input[8])).toBe("+15");
+    expect(solve(input[7])).toBe("+97.5");
+    expect(solve(input[8])).toBe("+15");
   });
 });

src/mathString.ts

@@ -1,134 +1,9 @@
-class MathStrign {
-  mathSigns = {
-    multiplication: "*",
-    divisin: "/",
-    summation: "+",
-    subtraction: "-"
-  };
-  numRegString: string = "[+-]?\\d*\\.?\\d+(e[+-]?\\d+)?";
-  numberRegExp: RegExp = new RegExp(`${this.numRegString}`, "g");
-  betweenParenthesesRegExp: RegExp = new RegExp(
-    `\\(${this.numRegString}([\\${this.mathSigns.summation}\\${
-      this.mathSigns.subtraction
-    }\\${this.mathSigns.multiplication}\\${this.mathSigns.divisin}]${
-      this.numRegString
-    })*\\)`,
-    "g"
-  );
-  multiplicationOrDivisionRegExp: RegExp = new RegExp(
-    `${this.numRegString}[\\${this.mathSigns.multiplication}\\${
-      this.mathSigns.divisin
-    }]${this.numRegString}`,
-    "g"
-  );
-  summationOrSubtractionRegExp: RegExp = new RegExp(
-    `${this.numRegString}[\\${this.mathSigns.summation}\\${
-      this.mathSigns.subtraction
-    }]${this.numRegString}`,
-    "g"
-  );
-  selectNumbers = (input: string) => {
-    const inp = this.removeSpacesFromInput(input);
-    return inp.match(this.numberRegExp);
-  };
-  selectParantheses = (input: string) => {
-    const inp = this.removeSpacesFromInput(input);
-    return inp.match(this.betweenParenthesesRegExp);
-  };
-  selectMultiplicationOrDivisionePhrase = (input: string) => {
-    const inp = this.removeSpacesFromInput(input);
-    return inp.match(this.multiplicationOrDivisionRegExp);
-  };
-  selectSummationOrSubtractionPhrase = (input: string) => {
-    return input.match(this.summationOrSubtractionRegExp);
-  };
-  converSpecialChar = (inp: string) => {
-    return `${inp
-      .replace(/\(/g, "\\(")
-      .replace(/\)/g, "\\)")
-      .replace(/\\/g, "\\/")
-      .replace(/\+/g, "\\+")
-      .replace(/\-/g, "\\-")
-      .replace(/\*/g, "\\*")}`;
-  };
-  solveBetweenParantheses = (input: string): string => {
-    let result: string = input;
-    let betweenParantes = this.selectParantheses(result);
-    if (!betweenParantes) {
-      return result;
-    }
-    betweenParantes.forEach(inp => {
-      const resultPhrase = this.solveMathPhrases(inp);
-      result = result.replace(inp, resultPhrase);
-    });
-    return this.solveBetweenParantheses(result);
-  };
-  solveMathPhrases = (phrase: string) => {
-    let result: string = this.solveMultiplicationOrDivisionPhrase(phrase);
-    result = this.solveSummationOrSubtractionPhrase(result);
-    result = result.replace(/[()]/g, "");
-    return result;
-  };
-  solveMultiplicationOrDivisionPhrase = (phrase: string): string => {
-    const multiplicationOrDivisionPhrase = this.selectMultiplicationOrDivisionePhrase(
-      phrase
-    );
-    if (!multiplicationOrDivisionPhrase) return phrase;
-    multiplicationOrDivisionPhrase.forEach(phr => {
-      const _result = this.solveMultiplicationOrDivision(phr);
-      phrase = phrase.replace(phr, _result);
-    });
-    return this.solveMultiplicationOrDivisionPhrase(phrase);
-  };
-  solveSummationOrSubtractionPhrase = (phrase: string): string => {
-    phrase = phrase
-      .replace(/(\-\+)|(\+\-)/g, "-")
-      .replace(/(\+\+)|(\-\-)/g, "+");
-    const summationOrSubtractionPhrase = this.selectSummationOrSubtractionPhrase(
-      phrase
-    );
-    if (!summationOrSubtractionPhrase) {
-      return phrase;
-    }
-    summationOrSubtractionPhrase.forEach(phr => {
-      const _result = this.solveSummationOrSubtraction(phr);
-      phrase = phrase.replace(phr, _result);
-    });
-    return this.solveSummationOrSubtractionPhrase(phrase);
-  };
-  solveMultiplicationOrDivision = (phrase: string) => {
-    const numbers = this.selectNumbers(phrase)!;
-    const num1 = numbers[0];
-    const num2 = numbers[1];
-    const result = phrase.includes(this.mathSigns.multiplication)
-      ? +num1 * +num2
-      : +num1 / +num2;
-    return result >= 0 ? `+${result.toString()}` : result.toString();
-  };
-  solveSummationOrSubtraction = (phrase: string) => {
-    const numbers = this.selectNumbers(phrase)!;
-    const num1 = numbers[0];
-    const num2 = numbers[1];
-    const mathOperator = phrase.replace(
-      new RegExp(
-        `(${this.converSpecialChar(num1)}|${this.converSpecialChar(num2)})`,
-        "g"
-      ),
-      ""
-    );
-    const result =
-      mathOperator && mathOperator == this.mathSigns.subtraction
-        ? +num1 - +num2
-        : +num1 + +num2;
-    return result >= 0 ? `+${result.toString()}` : result.toString();
-  };
-  removeSpacesFromInput = (inp: string) => {
-    return inp.replace(/\s*/g, "");
-  };
-  solve = (input: string) => {
-    let result = this.solveBetweenParantheses(input);
-    result = this.solveMathPhrases(result);
-    return result;
-  };
-}
-export default MathStrign;
+import { solveBetweenParantheses, solveMathPhrases } from "./solveModules";
+
+const solve = (input: string) => {
+  let result = solveBetweenParantheses(input);
+  result = solveMathPhrases(result);
+  return result;
+};
+
+export default solve;

src/regulaExpersions.ts

@@ -0,0 +1,26 @@
+export const mathSigns = {
+  multiplication: "*",
+  divisin: "/",
+  summation: "+",
+  subtraction: "-"
+};
+const numRegString: string = "[+-]?\\d*\\.?\\d+(e[+-]?\\d+)?";
+export const numberRegExp: RegExp = new RegExp(`${numRegString}`, "g");
+export const betweenParenthesesRegExp: RegExp = new RegExp(
+  `\\(${numRegString}([\\${mathSigns.summation}\\${mathSigns.subtraction}\\${
+    mathSigns.multiplication
+  }\\${mathSigns.divisin}]${numRegString})*\\)`,
+  "g"
+);
+export const multiplicationOrDivisionRegExp: RegExp = new RegExp(
+  `${numRegString}[\\${mathSigns.multiplication}\\${
+    mathSigns.divisin
+  }]${numRegString}`,
+  "g"
+);
+export const summationOrSubtractionRegExp: RegExp = new RegExp(
+  `${numRegString}[\\${mathSigns.summation}\\${
+    mathSigns.subtraction
+  }]${numRegString}`,
+  "g"
+);

src/selectModules.ts

@@ -0,0 +1,23 @@
+import { removeSpacesFromInput } from "./utility";
+import {
+  numberRegExp,
+  betweenParenthesesRegExp,
+  multiplicationOrDivisionRegExp,
+  summationOrSubtractionRegExp
+} from "./regulaExpersions";
+
+export const selectNumbers = (input: string) => {
+  const inp = removeSpacesFromInput(input);
+  return inp.match(numberRegExp);
+};
+export const selectParantheses = (input: string) => {
+  const inp = removeSpacesFromInput(input);
+  return inp.match(betweenParenthesesRegExp);
+};
+export const selectMultiplicationOrDivisionePhrase = (input: string) => {
+  const inp = removeSpacesFromInput(input);
+  return inp.match(multiplicationOrDivisionRegExp);
+};
+export const selectSummationOrSubtractionPhrase = (input: string) => {
+  return input.match(summationOrSubtractionRegExp);
+};

src/solveModules.ts

@@ -0,0 +1,75 @@
+import {
+  selectParantheses,
+  selectMultiplicationOrDivisionePhrase,
+  selectSummationOrSubtractionPhrase,
+  selectNumbers
+} from "./selectModules";
+import { mathSigns } from "./regulaExpersions";
+import { converSpecialChar } from "./utility";
+
+export const solveBetweenParantheses = (input: string): string => {
+  let result: string = input;
+  let betweenParantes = selectParantheses(result);
+  if (!betweenParantes) {
+    return result;
+  }
+  betweenParantes.forEach(inp => {
+    const resultPhrase = solveMathPhrases(inp);
+    result = result.replace(inp, resultPhrase);
+  });
+  return solveBetweenParantheses(result);
+};
+export const solveMathPhrases = (phrase: string) => {
+  let result: string = solveMultiplicationOrDivisionPhrase(phrase);
+  result = solveSummationOrSubtractionPhrase(result);
+  result = result.replace(/[()]/g, "");
+  return result;
+};
+export const solveMultiplicationOrDivisionPhrase = (phrase: string): string => {
+  const multiplicationOrDivisionPhrase = selectMultiplicationOrDivisionePhrase(
+    phrase
+  );
+  if (!multiplicationOrDivisionPhrase) return phrase;
+  multiplicationOrDivisionPhrase.forEach(phr => {
+    const _result = solveMultiplicationOrDivision(phr);
+    phrase = phrase.replace(phr, _result);
+  });
+  return solveMultiplicationOrDivisionPhrase(phrase);
+};
+export const solveSummationOrSubtractionPhrase = (phrase: string): string => {
+  phrase = phrase.replace(/(\-\+)|(\+\-)/g, "-").replace(/(\+\+)|(\-\-)/g, "+");
+  const summationOrSubtractionPhrase = selectSummationOrSubtractionPhrase(
+    phrase
+  );
+  if (!summationOrSubtractionPhrase) {
+    return phrase;
+  }
+  summationOrSubtractionPhrase.forEach(phr => {
+    const _result = solveSummationOrSubtraction(phr);
+    phrase = phrase.replace(phr, _result);
+  });
+  return solveSummationOrSubtractionPhrase(phrase);
+};
+export const solveMultiplicationOrDivision = (phrase: string) => {
+  const numbers = selectNumbers(phrase)!;
+  const num1 = numbers[0];
+  const num2 = numbers[1];
+  const result = phrase.includes(mathSigns.multiplication)
+    ? +num1 * +num2
+    : +num1 / +num2;
+  return result >= 0 ? `+${result.toString()}` : result.toString();
+};
+export const solveSummationOrSubtraction = (phrase: string) => {
+  const numbers = selectNumbers(phrase)!;
+  const num1 = numbers[0];
+  const num2 = numbers[1];
+  const mathOperator = phrase.replace(
+    new RegExp(`(${converSpecialChar(num1)}|${converSpecialChar(num2)})`, "g"),
+    ""
+  );
+  const result =
+    mathOperator && mathOperator == mathSigns.subtraction
+      ? +num1 - +num2
+      : +num1 + +num2;
+  return result >= 0 ? `+${result.toString()}` : result.toString();
+};

src/utility.ts

@@ -0,0 +1,13 @@
+export const removeSpacesFromInput = (inp: string) => {
+  return inp.replace(/\s*/g, "");
+};
+
+export const converSpecialChar = (inp: string) => {
+  return `${inp
+    .replace(/\(/g, "\\(")
+    .replace(/\)/g, "\\)")
+    .replace(/\\/g, "\\/")
+    .replace(/\+/g, "\\+")
+    .replace(/\-/g, "\\-")
+    .replace(/\*/g, "\\*")}`;
+};

tslint.json

@@ -0,0 +1,10 @@
+{
+    "defaultSeverity": "error",
+    "extends": [
+        "tslint:recommended",
+        "tslint-config-prettier"
+    ],
+    "jsRules": {},
+    "rules": {},
+    "rulesDirectory": []
+}