refactor: make internal structure clearer

Author: Simon Renoult

.eslintrc.json

@@ -12,10 +12,6 @@
     "prettier/prettier": "error",
     "no-console": "off",
     "@typescript-eslint/no-use-before-define": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-    "sort-imports": [
-      "error",
-      { "ignoreCase":  true, "allowSeparatedGroups":  true }
-    ]
+    "@typescript-eslint/no-explicit-any": "off"
   }
 }

src/io/index.ts

@@ -15,7 +15,7 @@ export default async function main(): Promise<void> {
 
   const statistics = await Statistics.compute(options);
   Cli.cleanup(options);
-  Output.render(statistics, options);
+  Output.render(statistics.list(), options);
 }
 
 function warnIfUsingComplexityWithIncompatibleFileTypes(options: Options) {

src/io/output.ts

@@ -1,16 +1,16 @@
 import * as Table from "cli-table3";
+import { IStatistic } from "../../dist/src/lib/statistics";
+import { Options } from "../lib/types";
 
 import { buildDebugger, withDuration } from "../utils";
-import { Options } from "../lib/types";
-import Statistics from "../lib/statistics";
 
 const internal = { debug: buildDebugger("output") };
 
 export default {
   render: (...args: any[]): void => withDuration(render, args, internal.debug),
 };
 
-function render(statistics: Statistics[], options: Options): void {
+function render(statistics: IStatistic[], options: Options): void {
   let stdout;
   switch (options.format) {
     case "table":
@@ -29,11 +29,11 @@ function render(statistics: Statistics[], options: Options): void {
   console.log(stdout);
 }
 
-function toJson(statistics: Statistics[]): string {
-  return JSON.stringify(statistics.map((s) => s.toState()));
+function toJson(statistics: IStatistic[]): string {
+  return JSON.stringify(statistics);
 }
 
-function toTable(statistics: Statistics[]): string {
+function toTable(statistics: IStatistic[]): string {
   const table = new Table({
     head: ["file", "complexity", "churn", "score"],
   });
@@ -49,7 +49,7 @@ function toTable(statistics: Statistics[]): string {
   return table.toString();
 }
 
-function toCSV(statistics: Statistics[]): string {
+function toCSV(statistics: IStatistic[]): string {
   let csv = "file,complexity,churn,score\n";
   statistics.forEach((stat) => {
     csv +=

src/lib/churn/churn.ts

@@ -1,95 +1,20 @@
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { Path } from "../types";
 
-import * as micromatch from "micromatch";
+export default class Churn {
+  private path: Path;
+  private changes: number;
 
-import { buildDebugger, withDuration } from "../../utils";
-import { Options, Path } from "../types";
-
-const internal = { debug: buildDebugger("churn") };
-const PER_LINE = "\n";
-
-export default {
-  compute: (...args: any[]): Promise<Map<Path, number>> =>
-    withDuration(compute, args, internal.debug),
-};
-
-async function compute(options: Options): Promise<Map<Path, number>> {
-  const gitLogCommand = buildGitLogCommand(options);
-  const singleStringWithAllChurns = executeGitLogCommand(gitLogCommand);
-  return computeChurnsPerFiles(
-    singleStringWithAllChurns,
-    options.directory,
-    options.filter
-  );
-}
-
-function executeGitLogCommand(gitLogCommand: string): string {
-  return execSync(gitLogCommand, { encoding: "utf8", maxBuffer: 32_000_000 });
-}
-
-function buildGitLogCommand(options: Options): string {
-  const isWindows = process.platform === "win32";
-
-  return [
-    "git",
-    `-C ${options.directory}`,
-    `log`,
-    `--follow`,
-
-    // Windows CMD handle quotes differently than linux, this is why we should put empty string as said in:
-    // https://github.com/git-for-windows/git/issues/3131
-    `--format=${isWindows ? "" : "''"}`,
-    `--name-only`,
-    options.since ? `--since="${options.since}"` : "",
-    options.until ? `--until="${options.until}"` : "",
-
-    // Windows CMD handle quotes differently
-    isWindows ? "*" : "'*'",
-  ]
-    .filter((s) => s.length > 0)
-    .join(" ");
-}
-
-function computeChurnsPerFiles(
-  gitLogOutput: string,
-  directory: string,
-  filters: string[] | undefined
-): Map<Path, number> {
-  const changedFiles = gitLogOutput
-    .split(PER_LINE)
-    .filter((line) => line !== "")
-    .sort();
-
-  return changedFiles.reduce((map: Map<Path, number>, path) => {
-    applyFiltersAndExcludeObsoletePath(path, map);
-    return map;
-  }, new Map());
-
-  function applyFiltersAndExcludeObsoletePath(
-    path: string,
-    map: Map<Path, number>
-  ) {
-    if (!filters || !filters.length) {
-      if (pathStillExists(path)) {
-        addOrIncrement(map, path);
-      }
-    } else {
-      const pathHasAMatch = filters.every((f) => micromatch.isMatch(path, f));
-      if (pathHasAMatch) {
-        if (pathStillExists(path)) {
-          addOrIncrement(map, path);
-        }
-      }
-    }
+  constructor(path: Path) {
+    this.path = path;
+    this.changes = 0;
   }
 
-  function addOrIncrement(map: Map<Path, number>, path: string) {
-    map.set(path, (map.get(path) ?? 0) + 1);
+  public increment(): this {
+    this.changes += 1;
+    return this;
   }
 
-  function pathStillExists(fileName: string) {
-    return existsSync(resolve(directory, fileName));
+  public getValue(): number {
+    return this.changes;
   }
 }

src/lib/churn/churns.ts

@@ -0,0 +1,49 @@
+import { History } from "../githistory/githistory";
+
+import { Options, Path } from "../types";
+import Churn from "./churn";
+
+// FIXME: add commits
+
+export default class Churns {
+  private readonly churnByPath: Map<Path, Churn>;
+  private readonly options: Options;
+
+  public static from(history: History, options: Options) {
+    return new Churns(history, options);
+  }
+
+  private constructor(history: History, options: Options) {
+    this.options = options;
+    this.churnByPath = this.computeChurnsPerFiles(history);
+  }
+
+  public get files(): Path[] {
+    return [...this.churnByPath.keys()];
+  }
+
+  public getByPath(path: Path): Churn {
+    const churn = this.churnByPath.get(path);
+    if (!churn) {
+      throw new Error("churn not found for path: " + path);
+    }
+    return churn;
+  }
+
+  private computeChurnsPerFiles(history: History): Map<Path, Churn> {
+    return history.reduce((map: Map<Path, Churn>, path) => {
+      if (map.has(path)) {
+        const actualChurn = map.get(path);
+        if (actualChurn) {
+          actualChurn.increment();
+        } else {
+          throw new Error("A churn should have existed for path: " + path);
+        }
+      } else {
+        const churn = new Churn(path).increment();
+        map.set(path, churn);
+      }
+      return map;
+    }, new Map());
+  }
+}

src/lib/complexity/complexities.ts

@@ -0,0 +1,38 @@
+import { buildDebugger } from "../../utils";
+import { Options, Path } from "../types";
+import Complexity from "./complexity";
+
+const internal = { debug: buildDebugger("complexity") };
+
+export default class Complexities {
+  private readonly complexityByPath: Map<Path, Complexity>;
+
+  public static async computeFor(
+    paths: Path[],
+    options: Options
+  ): Promise<Complexities> {
+    internal.debug(`${paths.length} files to compute complexity on`);
+    const complexities = await Promise.all(
+      paths.map(async (p) => await Complexity.compute(p, options))
+    );
+
+    return new Complexities(complexities);
+  }
+
+  public getByPath(path: Path): Complexity {
+    const complexity = this.complexityByPath.get(path);
+    if (!complexity) throw new Error("Complexity not found for path: " + path);
+    return complexity;
+  }
+
+  private constructor(complexities: Complexity[]) {
+    this.complexityByPath = this.computeComplexitiesPerPath(complexities);
+  }
+
+  private computeComplexitiesPerPath(complexities: Complexity[]) {
+    return complexities.reduce((map, complexity) => {
+      map.set(complexity.path, complexity);
+      return map;
+    }, new Map());
+  }
+}

src/lib/complexity/complexity.ts

@@ -0,0 +1,52 @@
+import { Options, Path } from "../types";
+import computeSloc from "./strategies/sloc";
+import { calculate as calculateCyclomatic } from "./strategies/cyclomatic";
+import { calculate as calculateHalstead } from "./strategies/halstead";
+import { resolve } from "node:path";
+import { UnsupportedExtension } from "../../utils";
+
+// FIXME: add modules
+
+export default class Complexity {
+  public static async compute(path: Path, options: Options) {
+    const complexity = await Complexity.computeComplexity(path, options);
+    return new Complexity(path, complexity);
+  }
+
+  private constructor(
+    public readonly path: Path,
+    public readonly complexity: number
+  ) {}
+
+  private static async computeComplexity(
+    path: Path,
+    options: Options
+  ): Promise<number> {
+    const absolutePath = resolve(options.directory, path);
+
+    let result: number | UnsupportedExtension;
+    switch (options.complexityStrategy) {
+      case "sloc":
+        result = await computeSloc(absolutePath);
+        break;
+      case "cyclomatic":
+        result = await calculateCyclomatic(absolutePath);
+        break;
+      case "halstead":
+        result = await calculateHalstead(absolutePath);
+        break;
+      default:
+        result = await computeSloc(absolutePath);
+    }
+
+    if (result instanceof UnsupportedExtension) {
+      result = await computeSloc(absolutePath);
+    }
+
+    return result as number;
+  }
+
+  getValue(): number {
+    return this.complexity;
+  }
+}

src/lib/complexity/index.ts

@@ -1,7 +1,7 @@
 import { extname } from "node:path";
 import { readFileSync } from "node:fs";
 
-import { buildDebugger, UnsupportedExtension } from "../../utils";
+import { buildDebugger, UnsupportedExtension } from "../../../utils";
 import { transformSync } from "@babel/core";
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires

src/lib/complexity/cyclomatic.ts renamed to src/lib/complexity/strategies/cyclomatic.ts

@@ -1,4 +1,4 @@
-import { buildDebugger, UnsupportedExtension } from "../../utils";
+import { buildDebugger, UnsupportedExtension } from "../../../utils";
 import { extname } from "node:path";
 import { readFileSync } from "node:fs";
 import { transformSync } from "@babel/core";