feat: statistics per directory

Author: Simon Renoult

README.md

@@ -21,7 +21,7 @@ While imperfect, this measure gives a good enough idea of what's going on.
 ## Usage
 
 ```sh
-$ npx code-complexity <path-to-git-directory or URL>
+$ npx code-complexity <path-to-git-directory or URL> [options]
 ```
 
 ## Help
@@ -50,6 +50,7 @@ $ npx code-complexity <path-to-git-directory or URL>
     $ code-complexity ../foo --sort score
     $ code-complexity /foo/bar --filter 'src/**,!src/front/**'
     $ code-complexity . --limit 10 --sort score
+    $ code-complexity . --limit 10 --modules 
     $ code-complexity . --limit 10 --sort score -cs halstead
     $ code-complexity . --since=2021-06-01 --limit 100
     $ code-complexity . --since=2021-04-01 --until=2021-07-01

src/io/cli.ts

@@ -74,6 +74,10 @@ function getRawCli(
       "sort results (allowed valued: score, churn, complexity or file)",
       /^(score|churn|complexity|file)$/i
     )
+    .option(
+      "-d, --directories",
+      "Display values for directories instead of files"
+    )
     .on("--help", () => {
       console.log();
       console.log("Examples:");
@@ -83,9 +87,12 @@ function getRawCli(
         "$ code-complexity https://github.com/simonrenoult/code-complexity",
         "$ code-complexity foo --limit 3",
         "$ code-complexity ../foo --sort score",
-        "$ code-complexity . -cs halstead",
         "$ code-complexity /foo/bar --filter 'src/**,!src/front/**'",
         "$ code-complexity . --limit 10 --sort score",
+        "$ code-complexity . --limit 10 --modules",
+        "$ code-complexity . --limit 10 --sort score -cs halstead",
+        "$ code-complexity . --since=2021-06-01 --limit 100",
+        "$ code-complexity . --since=2021-04-01 --until=2021-07-01",
       ].forEach((example) => console.log(example.padStart(2)));
     });
 }
@@ -95,6 +102,7 @@ function buildOptions(args: string[], options: any): Options {
   return {
     target,
     directory: parseDirectory(target),
+    directories: options.directories,
     format: options.format ? (String(options.format) as Format) : "table",
     filter: options.filter || [],
     limit: options.limit ? Number(options.limit) : undefined,

src/io/output.ts

@@ -35,7 +35,7 @@ function render(
 }
 
 function toJson(statistics: Statistics[]): string {
-  return JSON.stringify(statistics);
+  return JSON.stringify(statistics.map((s) => s.toState()));
 }
 
 function toTable(statistics: Statistics[]): string {

src/lib/statistics.ts

@@ -2,24 +2,27 @@ import Churn from "./churn/churn";
 import Complexity from "./complexity";
 import { Options, Path, Sort } from "./types";
 import { buildDebugger } from "../utils";
+import * as NodePath from "path";
 
 const DEFAULT_CHURN = 1;
 const DEFAULT_COMPLEXITY = 1;
 
 const internal = { debug: buildDebugger("statistics") };
 
+export interface IStatistics {
+  path: Path;
+  churn: number;
+  complexity: number;
+  score: number;
+}
+
 export default class Statistics {
   public readonly path: Path;
   public readonly churn: number;
   public readonly complexity: number;
   public readonly score: number;
 
-  constructor(path: Path, churn: number, complexity: number) {
-    this.path = path;
-    this.churn = churn;
-    this.complexity = complexity;
-    this.score = this.churn * this.complexity;
-  }
+  private readonly directories: string[];
 
   public static async compute(
     options: Options
@@ -31,24 +34,92 @@ export default class Statistics {
     const paths = Array.from(churns.keys());
     const complexities = await Complexity.compute(paths, options);
 
-    const statistics = paths
-      .map(toStatistics(churns, complexities))
-      .sort(sort(options.sort))
-      .filter(limit(options.limit));
+    const statistics = paths.map(Statistics.toStatistics(churns, complexities));
 
-    return toMap(statistics);
+    const mapOfStatistics = options.directories
+      ? Statistics.toDirectoryMap(statistics)
+      : Statistics.toFileMap(statistics);
+
+    return new Map(
+      [...mapOfStatistics.entries()]
+        .sort(([, v1], [, v2]) => sort(options.sort)(v1, v2))
+        .filter(([, v], index) => limit(options.limit)(v, index))
+    );
   }
-}
 
-function toStatistics(
-  churns: Map<Path, number>,
-  complexities: Map<Path, number>
-): (path: Path) => Statistics {
-  return (path): Statistics => {
-    const churn = churns.get(path) || DEFAULT_CHURN;
-    const complexity = complexities.get(path) || DEFAULT_COMPLEXITY;
-    return new Statistics(path, churn, complexity);
-  };
+  public static toStatistics(
+    churns: Map<Path, number>,
+    complexities: Map<Path, number>
+  ): (path: Path) => Statistics {
+    return (path): Statistics => {
+      const churn = churns.get(path) || DEFAULT_CHURN;
+      const complexity = complexities.get(path) || DEFAULT_COMPLEXITY;
+      return new Statistics(path, churn, complexity);
+    };
+  }
+
+  private constructor(path: Path, churn: number, complexity: number) {
+    this.path = path;
+    this.churn = churn;
+    this.complexity = complexity;
+    this.directories = this.findDirectoriesForFile(path);
+    this.score = this.churn * this.complexity;
+  }
+
+  private findDirectoriesForFile(path: string): string[] {
+    const directories: string[] = [];
+    const pathChunks = NodePath.parse(path).dir.split(NodePath.sep);
+    pathChunks.forEach((chunk) => {
+      const parentDir = directories.slice(-1);
+      const directory = parentDir.length
+        ? parentDir + NodePath.sep + chunk
+        : chunk;
+      directories.push(directory);
+    });
+    return directories.filter((d) => d.length > 0);
+  }
+
+  private static toFileMap(statistics: Statistics[]): Map<Path, Statistics> {
+    return statistics.reduce((map: Map<Path, Statistics>, statistics) => {
+      map.set(statistics.path, statistics);
+      return map;
+    }, new Map());
+  }
+
+  private static toDirectoryMap(
+    allStatistics: Statistics[]
+  ): Map<string, Statistics> {
+    return allStatistics.reduce((map, statisticsForFile) => {
+      statisticsForFile.directories.forEach((directoryForFile) => {
+        computeStatisticsForDirectory(map, directoryForFile, statisticsForFile);
+      });
+      return map;
+    }, new Map<string, Statistics>());
+
+    function computeStatisticsForDirectory(
+      map: Map<string, Statistics>,
+      dir: string,
+      statisticsForFile: Statistics
+    ) {
+      const statisticsForDir = map.get(dir);
+      const churn =
+        statisticsForFile.churn +
+        (statisticsForDir ? statisticsForDir.churn : 0);
+      const complexity =
+        statisticsForFile.complexity +
+        (statisticsForDir ? statisticsForDir.complexity : 0);
+      map.set(dir, new Statistics(dir, churn, complexity));
+    }
+  }
+
+  public toState(): IStatistics {
+    return {
+      path: this.path,
+      churn: this.churn,
+      complexity: this.complexity,
+      score: this.score,
+    };
+  }
 }
 
 function limit(
@@ -80,10 +151,3 @@ function sort(sort: Sort | undefined) {
     return 0;
   };
 }
-
-function toMap(statistics: Statistics[]): Map<Path, Statistics> {
-  return statistics.reduce((map: Map<Path, Statistics>, statistics) => {
-    map.set(statistics.path, statistics);
-    return map;
-  }, new Map());
-}

src/lib/types.d.ts

@@ -7,6 +7,7 @@ export type ComplexityStrategy = "sloc" | "halstead" | "cyclomatic";
 export type Options = {
   target: string | URL;
   directory: string;
+  directories?: boolean;
   limit?: number;
   since?: string;
   until?: string;

test/fixtures/versioned-file.fixture.ts

@@ -1,6 +1,6 @@
 import { execSync } from "child_process";
-import { appendFileSync, writeFileSync } from "fs";
-import { sep } from "path";
+import { appendFileSync, mkdirSync, writeFileSync } from "fs";
+import * as NodePath from "path";
 
 export default class VersionedFileFixture {
   constructor(private readonly repositoryLocation: string) {}
@@ -81,7 +81,8 @@ export default class VersionedFileFixture {
         .map((value, index) => `console.log(${index});`)
         .join("\n");
 
-    writeFileSync(`${this.getFileLocation()}`, fileContent);
+    mkdirSync(NodePath.parse(this.getFileLocation()).dir, { recursive: true });
+    writeFileSync(this.getFileLocation(), fileContent);
   }
 
   private addFileToRepository(): void {
@@ -103,6 +104,6 @@ export default class VersionedFileFixture {
   }
 
   private getFileLocation(): string {
-    return `${this.repositoryLocation}${sep}${this.name}`;
+    return `${this.repositoryLocation}${NodePath.sep}${this.name}`;
   }
 }