code-complexity/dist/src/lib/statistics/statistics.js

Measure the churn/complexity score. Higher values mean hotspots where refactorings should happen.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("../../utils");
const churns_1 = require("../churn/churns");
const complexities_1 = require("../complexity/complexities");
const githistory_1 = require("../githistory/githistory");
const statistic_1 = require("./statistic");
const internal = { debug: (0, utils_1.buildDebugger)("statistics") };
class Statistics {
    statistics = [];
    static async compute(options) {
        internal.debug(`invoked with options: ${JSON.stringify(options)}`);
        internal.debug(`using cwd: ${process.cwd()}`);
        const gitHistory = githistory_1.default.build(options);
        const churns = churns_1.default.from(gitHistory.history, options);
        const complexities = await complexities_1.default.computeFor(gitHistory.files, options);
        return new Statistics(gitHistory.files, churns, complexities, options);
    }
    list() {
        return this.statistics.map((s) => s.toState());
    }
    constructor(files, churns, complexities, options) {
        const statisticsForFiles = files.map((path) => {
            const churn = churns.getByPath(path);
            const complexity = complexities.getByPath(path);
            return statistic_1.default.build(path, churn.getValue(), complexity.getValue());
        });
        const result = options.directories
            ? Statistics.buildDirectoriesStatistics(statisticsForFiles)
            : statisticsForFiles;
        this.statistics = result
            .sort(sort(options.sort))
            .filter(limit(options.limit));
    }
    static buildDirectoriesStatistics(statisticsForFiles) {
        const map = statisticsForFiles.reduce((map, statisticsForFile) => {
            statisticsForFile.directories.forEach((directoryForFile) => {
                computeStatisticsForDirectory(map, directoryForFile, statisticsForFile);
            });
            return map;
        }, new Map());
        return [...map.values()];
        function computeStatisticsForDirectory(map, dir, statisticsForFile) {
            const statisticsForDir = map.get(dir);
            const churn = statisticsForFile.churn +
                (statisticsForDir ? statisticsForDir.churn : 0);
            const complexity = statisticsForFile.complexity +
                (statisticsForDir ? statisticsForDir.complexity : 0);
            map.set(dir, statistic_1.default.build(dir, churn, complexity));
        }
    }
}
exports.default = Statistics;
function limit(limit) {
    return (statistics, i) => !limit || i < limit;
}
function sort(sort) {
    return (statisticsA, statisticsB) => {
        if (sort === "score" || sort === "ratio") {
            return statisticsB.score - statisticsA.score;
        }
        if (sort === "churn") {
            return statisticsB.churn - statisticsA.churn;
        }
        if (sort === "complexity") {
            return statisticsB.complexity - statisticsA.complexity;
        }
        if (sort === "file") {
            const fileAPath = statisticsA.path;
            const fileBPath = statisticsB.path;
            return fileAPath.localeCompare(fileBPath);
        }
        return 0;
    };
}