@eagleoutice/flowr 1.5.2 → 2.0.1

package/statistics/features/supported/values/values.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.values = void 0;
+const xpath = __importStar(require("xpath-ts2"));
+const post_process_1 = require("./post-process");
+const assert_1 = require("../../../../util/assert");
+const convert_values_1 = require("../../../../r-bridge/lang-4.x/convert-values");
+const statistics_file_1 = require("../../../output/statistics-file");
+const initialValueInfo = {
+    allNumerics: 0,
+    imaginaryNumbers: 0,
+    integers: 0,
+    floatHex: 0,
+    logical: 0,
+    specialConstants: 0,
+    strings: 0
+};
+const numericConstantQuery = xpath.parse('//NUM_CONST');
+const stringConstantQuery = xpath.parse('//STR_CONST');
+const specialConstantsQuery = xpath.parse('//NULL_CONST');
+const shortLogicalSymbolQuery = xpath.parse('//SYMBOL[text() = \'T\' or text() = \'F\']');
+function classifyNumericConstants(numeric, existing) {
+    if (numeric === convert_values_1.RTrue || numeric === convert_values_1.RFalse) {
+        return 'logical';
+    }
+    if (numeric === convert_values_1.RNa || numeric === 'NaN' || numeric === convert_values_1.RNull || numeric === 'Inf' || numeric === '-Inf') {
+        return 'special-constants';
+    }
+    if (numeric.includes('i')) {
+        existing.imaginaryNumbers++;
+    }
+    else if (numeric.endsWith('L')) {
+        existing.integers++;
+    }
+    else if (convert_values_1.RNumHexFloatRegex.test(numeric)) {
+        existing.floatHex++;
+    }
+    return 'allNumerics';
+}
+exports.values = {
+    name: 'Values',
+    description: 'All values used (as constants etc.)',
+    process(existing, input) {
+        const strings = stringConstantQuery.select({ node: input.parsedRAst });
+        const numerics = numericConstantQuery.select({ node: input.parsedRAst });
+        const specialConstants = specialConstantsQuery.select({ node: input.parsedRAst });
+        const specialLogicalSymbols = shortLogicalSymbolQuery.select({ node: input.parsedRAst });
+        const numbers = [];
+        numerics.map(n => [n, classifyNumericConstants(n.textContent ?? '<unknown>', existing)])
+            .forEach(([n, type]) => {
+            switch (type) {
+                case 'allNumerics':
+                    numbers.push(n);
+                    break;
+                case 'logical':
+                    specialLogicalSymbols.push(n);
+                    break;
+                case 'special-constants':
+                    specialConstants.push(n);
+                    break;
+                default:
+                    (0, assert_1.assertUnreachable)(type);
+            }
+        });
+        existing.strings += strings.length;
+        existing.allNumerics += numerics.length;
+        existing.specialConstants += specialConstants.length;
+        existing.logical += specialLogicalSymbols.length;
+        (0, statistics_file_1.appendStatisticsFile)(this.name, 'numeric', numbers, input.filepath);
+        (0, statistics_file_1.appendStatisticsFile)(this.name, 'string', strings, input.filepath);
+        (0, statistics_file_1.appendStatisticsFile)(this.name, 'specialConstant', specialConstants, input.filepath);
+        (0, statistics_file_1.appendStatisticsFile)(this.name, 'logical', specialLogicalSymbols, input.filepath);
+        return existing;
+    },
+    initialValue: initialValueInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=values.js.map

package/statistics/features/supported/variables/post-process.d.ts

@@ -0,0 +1,9 @@
+import type { FeatureStatisticsWithMeta } from '../../feature';
+import type { SummarizedWithProject } from '../../post-processing';
+import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;
+type VariableInfoMap = Map<string, SummarizedWithProject & {
+    linePercentageInFile: number[][];
+}>;
+export declare function writeVariableInfoToCsv(outputPath: string, filename: `${string}.csv`, data: VariableInfoMap): void;
+export {};

package/statistics/features/supported/variables/post-process.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeVariableInfoToCsv = exports.postProcess = void 0;
+const post_processing_1 = require("../../post-processing");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const summarizer_1 = require("../../../../util/summarizer");
+const files_1 = require("../../../../util/files");
+function collectUsedVariables(featureRoot, info, config, outputPath) {
+    const used = collectVariableInfoFor(path_1.default.join(featureRoot, 'usedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'used-variables.csv', used);
+    // we manually clear these maps to save memory
+    used.clear();
+}
+function collectDefinedVariables(featureRoot, info, config, outputPath) {
+    const defined = collectVariableInfoFor(path_1.default.join(featureRoot, 'definedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'defined-variables.csv', defined);
+    defined.clear();
+}
+function collectRedefinedVariables(featureRoot, info, config, outputPath) {
+    const redefined = collectVariableInfoFor(path_1.default.join(featureRoot, 'redefinedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'redefined-variables.csv', redefined);
+    redefined.clear();
+}
+function writeVariableCountsToCsv(outputPath, collected) {
+    const variablesOutStream = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'variable-counts.csv'));
+    variablesOutStream.write(`kind,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        if (key === 'unknownVariables') {
+            // they are for function calls etc and in hindsight not a good idea
+            continue;
+        }
+        const data = val;
+        const sum = (0, summarizer_1.summarizeMeasurement)(data.count);
+        variablesOutStream.write(`${JSON.stringify(key)},${data.uniqueProjects.size},${data.uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)(sum)}\n`);
+    }
+    variablesOutStream.close();
+}
+function collectInformation(info, config) {
+    const collected = {};
+    for (const [filepath, data] of info.entries()) {
+        const value = data.variables;
+        for (const [key, val] of Object.entries(value)) {
+            let get = collected[key];
+            if (!get) {
+                get = (0, post_processing_1.emptySummarizedWithProject)();
+                collected[key] = get;
+            }
+            get.count.push(val);
+            if (val > 0) {
+                (0, post_processing_1.recordFilePath)(get, filepath, config);
+            }
+        }
+    }
+    return collected;
+}
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = collectInformation(info, config);
+    writeVariableCountsToCsv(outputPath, collected);
+    collectUsedVariables(featureRoot, info, config, outputPath);
+    collectDefinedVariables(featureRoot, info, config, outputPath);
+    collectRedefinedVariables(featureRoot, info, config, outputPath);
+}
+exports.postProcess = postProcess;
+function writeVariableInfoToCsv(outputPath, filename, data) {
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, filename));
+    out.write(`variable,unique-projects,unique-files,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('count')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('line-frac')}\n`);
+    for (const [key, val] of data.entries()) {
+        const { count, uniqueProjects, uniqueFiles, linePercentageInFile } = val;
+        const counts = (0, summarizer_1.summarizeMeasurement)(count);
+        const lineFrac = (0, summarizer_1.summarizeMeasurement)(linePercentageInFile.flat());
+        out.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${(0, summarizer_1.summarizedMeasurement2Csv)(counts)},${(0, summarizer_1.summarizedMeasurement2Csv)(lineFrac)}\n`);
+    }
+    out.close();
+}
+exports.writeVariableInfoToCsv = writeVariableInfoToCsv;
+function collectVariableInfoFor(filepath, info, config) {
+    // variable name to summary
+    const collected = new Map();
+    (0, files_1.readLineByLineSync)(filepath, (line, lineNumber) => {
+        if (line.length === 0) {
+            return;
+        }
+        if (lineNumber % 2_500 === 0) {
+            console.log(`    Processed ${lineNumber} lines of ${filepath}`);
+        }
+        const [vars, context] = JSON.parse(line.toString());
+        const numberOfLines = info.get(context ?? '')?.stats.lines[0].length;
+        // first we have to collect what this file gives us
+        const perFile = new Map();
+        for (const [name, [line]] of vars) {
+            let get = perFile.get(name);
+            if (!get) {
+                get = { ...(0, post_processing_1.emptySummarizedWithProject)(), linePercentageInFile: [] };
+                perFile.set(name, get);
+            }
+            get.count.push(1);
+            if (numberOfLines) {
+                get.linePercentageInFile.push(line / numberOfLines);
+            }
+        }
+        // now we merge it into the global map (oh gosh this is so horrible
+        for (const [name, data] of perFile.entries()) {
+            let get = collected.get(name);
+            if (!get) {
+                get = { ...(0, post_processing_1.emptySummarizedWithProject)(), linePercentageInFile: [] };
+                collected.set(name, get);
+            }
+            get.count.push(data.count.length);
+            get.linePercentageInFile.push(data.linePercentageInFile);
+            if (data.count.length > 0) {
+                (0, post_processing_1.recordFilePath)(get, context, config);
+            }
+        }
+    });
+    return collected;
+}
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/variables/variables.d.ts

@@ -0,0 +1,15 @@
+import type { Feature } from '../../feature';
+import type { Writable } from 'ts-essentials';
+declare const initialVariableInfo: {
+    numberOfVariableUses: number;
+    numberOfDefinitions: number;
+    numberOfRedefinitions: number;
+    unknownVariables: number;
+};
+export type VariableInfo = Writable<typeof initialVariableInfo>;
+export type DefinedVariableInformation = [
+    name: string,
+    location: [line: number, character: number]
+];
+export declare const variables: Feature<VariableInfo>;
+export {};

package/statistics/features/supported/variables/variables.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variables = void 0;
+const post_process_1 = require("./post-process");
+const range_1 = require("../../../../util/range");
+const visitor_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const r_symbol_1 = require("../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
+const statistics_file_1 = require("../../../output/statistics-file");
+const initialVariableInfo = {
+    numberOfVariableUses: 0,
+    numberOfDefinitions: 0,
+    numberOfRedefinitions: 0,
+    // we failed to get the type/role, maybe for function call names etc.
+    unknownVariables: 0
+};
+function visitVariables(info, input) {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RSymbol" /* RType.Symbol */ || (0, r_symbol_1.isSpecialSymbol)(node)) {
+            return;
+        }
+        // search for the node in the DF graph
+        const mayNode = input.dataflow.graph.get(node.info.id);
+        if (mayNode === undefined) {
+            info.unknownVariables++;
+            (0, statistics_file_1.appendStatisticsFile)(exports.variables.name, 'unknown', [[
+                    node.info.fullLexeme ?? node.lexeme,
+                    (0, range_1.getRangeStart)(node.location)
+                ]], input.filepath);
+            return;
+        }
+        const [dfNode] = mayNode;
+        if (dfNode.tag === 'variable-definition') {
+            info.numberOfDefinitions++;
+            const lexeme = node.info.fullLexeme ?? node.lexeme;
+            (0, statistics_file_1.appendStatisticsFile)(exports.variables.name, 'definedVariables', [[
+                    lexeme,
+                    (0, range_1.getRangeStart)(node.location)
+                ]], input.filepath);
+            // checking for redefinitions is no longer possible in its current form!
+        }
+        else if (dfNode.tag === 'use') {
+            info.numberOfVariableUses++;
+            (0, statistics_file_1.appendStatisticsFile)(exports.variables.name, 'usedVariables', [[
+                    node.info.fullLexeme ?? node.lexeme,
+                    (0, range_1.getRangeStart)(node.location)
+                ]], input.filepath);
+        }
+    });
+}
+exports.variables = {
+    name: 'Variables',
+    description: 'Variable Usage, Assignments, and Redefinitions',
+    process(existing, input) {
+        visitVariables(existing, input);
+        return existing;
+    },
+    initialValue: initialVariableInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=variables.js.map

package/statistics/meta-statistics.d.ts

@@ -0,0 +1,33 @@
+import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge/retriever';
+/**
+ * Statistics on skipped files, the time required, and more.
+ *
+ * @see extractUsageStatistics
+ * @see initialMetaStatistics
+ */
+export interface MetaStatistics {
+    /**
+   * The number of requests that were parsed successfully
+   */
+    successfulParsed: number;
+    /**
+   * The processing time for each request
+   */
+    processingTimeMs: number[];
+    /**
+   * All failed requests (e.g., if they can not be converted to XML)
+   */
+    failedRequests: (RParseRequestFromText | RParseRequestFromFile)[];
+    /**
+   * Number of lines with each individual line length consumed for each request
+   */
+    lines: number[][];
+    /**
+     * The number of nodes in the normalized AST
+     */
+    numberOfNormalizedNodes: number[];
+}
+/**
+ * Returns an initial {@link MetaStatistics} object, using neutral defaults (like the empty list).
+ */
+export declare function initialMetaStatistics(): MetaStatistics;

package/statistics/meta-statistics.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialMetaStatistics = void 0;
+/**
+ * Returns an initial {@link MetaStatistics} object, using neutral defaults (like the empty list).
+ */
+function initialMetaStatistics() {
+    return {
+        successfulParsed: 0,
+        numberOfNormalizedNodes: [],
+        processingTimeMs: [],
+        failedRequests: [],
+        lines: []
+    };
+}
+exports.initialMetaStatistics = initialMetaStatistics;
+//# sourceMappingURL=meta-statistics.js.map

package/statistics/output/file-provider.d.ts

@@ -0,0 +1,37 @@
+export type AppendFnType = string | number | symbol;
+export interface StatisticAppendProvider {
+    append(name: string, fn: AppendFnType, content: string): void;
+}
+export type DummyAppendMemoryMap = Map<string, Map<AppendFnType, string[]>>;
+export declare class DummyAppendProvider implements StatisticAppendProvider {
+    private readonly map;
+    /**
+     * If you pass a map the dummy will log all append calls to the map, using the feature name and the appendage type as keys
+     *
+     * @param map - The map to log to
+     */
+    constructor(map?: DummyAppendMemoryMap | undefined);
+    append(name: string, fn: AppendFnType, content: string): void;
+}
+export declare const defaultStatisticsFileSuffix = ".txt";
+/**
+ * Provides cached open connections for all files to connect.
+ * allowing to append to the same file often.
+ * <p>
+ * While we could simply reopen these files, it is safer/more performant to keep the connection open.
+ */
+export declare class StatisticFileProvider implements StatisticAppendProvider {
+    readonly statisticsDirectory: string;
+    private readonly connections;
+    constructor(statisticsDirectory: string | undefined);
+    /**
+   * @param name - the name of the feature {@link Feature#name}
+   * @param fn - the name of the feature-aspect to record
+   */
+    private statisticsFile;
+    /**
+   * Append the given content to the information for a feature of the given name and function.
+   */
+    append(name: string, fn: AppendFnType, content: string): void;
+    private getHandle;
+}

package/statistics/output/file-provider.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticFileProvider = exports.defaultStatisticsFileSuffix = exports.DummyAppendProvider = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const log_1 = require("../../util/log");
+const assert_1 = require("../../util/assert");
+class DummyAppendProvider {
+    map;
+    /**
+     * If you pass a map the dummy will log all append calls to the map, using the feature name and the appendage type as keys
+     *
+     * @param map - The map to log to
+     */
+    constructor(map = undefined) {
+        this.map = map;
+    }
+    append(name, fn, content) {
+        if (log_1.log.settings.minLevel >= 1 /* LogLevel.Trace */) {
+            log_1.log.trace(`DummyAppendProvider: ${name} ${String(fn)} ${content}`);
+        }
+        if (this.map) {
+            const fnMap = this.map.get(name);
+            const contentArr = content.split('\n');
+            if (fnMap) {
+                const contentList = fnMap.get(fn);
+                if (contentList) {
+                    contentList.push(...contentArr);
+                }
+                else {
+                    // just in case that the map already had some entries
+                    fnMap.set(fn, contentArr);
+                }
+            }
+            else {
+                this.map.set(name, new Map([[fn, contentArr]]));
+            }
+        }
+    }
+}
+exports.DummyAppendProvider = DummyAppendProvider;
+exports.defaultStatisticsFileSuffix = '.txt';
+/**
+ * Provides cached open connections for all files to connect.
+ * allowing to append to the same file often.
+ * <p>
+ * While we could simply reopen these files, it is safer/more performant to keep the connection open.
+ */
+class StatisticFileProvider {
+    statisticsDirectory;
+    connections = new Map();
+    constructor(statisticsDirectory) {
+        (0, assert_1.guard)(statisticsDirectory !== undefined, 'Please supply an output directory!');
+        this.statisticsDirectory = statisticsDirectory;
+        // just to make sure that they are closed
+        process.on('beforeExit', () => {
+            this.connections.forEach(fd => {
+                fs_1.default.closeSync(fd);
+            });
+        });
+    }
+    /**
+   * @param name - the name of the feature {@link Feature#name}
+   * @param fn - the name of the feature-aspect to record
+   */
+    statisticsFile(name, fn) {
+        return path_1.default.join(this.statisticsDirectory, name, `${fn}${exports.defaultStatisticsFileSuffix}`);
+    }
+    /**
+   * Append the given content to the information for a feature of the given name and function.
+   */
+    append(name, fn, content) {
+        const descriptor = this.getHandle(name, String(fn));
+        fs_1.default.appendFileSync(descriptor, content + '\n', 'utf8');
+    }
+    getHandle(name, fn) {
+        const key = `${name}-${fn}`;
+        const fileHandle = this.connections.get(key);
+        if (fileHandle) {
+            return fileHandle;
+        }
+        // open the connection and ensure the location
+        const filepath = this.statisticsFile(name, String(fn));
+        const dirpath = path_1.default.dirname(filepath);
+        if (!fs_1.default.existsSync(dirpath)) {
+            fs_1.default.mkdirSync(dirpath, { recursive: true });
+        }
+        const fileDescriptor = fs_1.default.openSync(filepath, 'a');
+        this.connections.set(key, fileDescriptor);
+        return fileDescriptor;
+    }
+}
+exports.StatisticFileProvider = StatisticFileProvider;
+//# sourceMappingURL=file-provider.js.map

package/statistics/output/print-stats.d.ts

@@ -0,0 +1,17 @@
+import type { MetaStatistics } from '../meta-statistics';
+import type { FeatureKey, FeatureStatistics } from '../features/feature';
+interface MinMaxAvgMedian {
+    sum: number;
+    min: number;
+    max: number;
+    avg: number;
+    median: number;
+}
+export declare function minMaxAvgAndMedian(data: number[]): MinMaxAvgMedian;
+export declare function statsString(data: MinMaxAvgMedian, suffix?: string): string;
+export declare function printFeatureStatistics(statistics: {
+    features: FeatureStatistics;
+    meta: MetaStatistics;
+}, features?: 'all' | Set<FeatureKey>): void;
+export declare function printFeatureStatisticsEntry(info: Record<string, unknown>): void;
+export {};

package/statistics/output/print-stats.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFeatureStatisticsEntry = exports.printFeatureStatistics = exports.statsString = exports.minMaxAvgAndMedian = void 0;
+const ansi_1 = require("../../util/ansi");
+const json_1 = require("../../util/json");
+const feature_1 = require("../features/feature");
+function minMaxAvgAndMedian(data) {
+    data = data.sort((a, b) => a - b);
+    const sum = data.reduce((a, b) => a + b, 0);
+    return {
+        sum,
+        min: data[0],
+        max: data[data.length - 1],
+        avg: sum / data.length,
+        median: data[Math.floor(data.length / 2)]
+    };
+}
+exports.minMaxAvgAndMedian = minMaxAvgAndMedian;
+function formatStatNumber(num) {
+    return num === undefined ? '<?>' : Number(num.toFixed(3)).toLocaleString();
+}
+function statsString(data, suffix = '') {
+    return `[${formatStatNumber(data.min)}${suffix} .. ${formatStatNumber(data.max)}${suffix}] (avg: ${formatStatNumber(data.avg)}${suffix}, median: ${formatStatNumber(data.median)}${suffix})`;
+}
+exports.statsString = statsString;
+function printFeatureStatistics(statistics, features = 'all') {
+    for (const feature of Object.keys(statistics.features)) {
+        if (features !== 'all' && !features.has(feature)) {
+            continue;
+        }
+        const meta = feature_1.ALL_FEATURES[feature];
+        console.log(`\n\n-----${meta.name}-------------`);
+        console.log(ansi_1.formatter.format(meta.description, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground }));
+        printFeatureStatisticsEntry(statistics.features[feature]);
+        console.log('\n\n');
+    }
+    const linesPerFile = minMaxAvgAndMedian(statistics.meta.lines.map(l => l.length));
+    const lineLengths = minMaxAvgAndMedian(statistics.meta.lines.flat());
+    const processingTimesPerFile = minMaxAvgAndMedian(statistics.meta.processingTimeMs);
+    console.log(`processed ${statistics.meta.successfulParsed} files (skipped ${statistics.meta.failedRequests.length} due to errors):
+\ttotal processing time: ${processingTimesPerFile.sum} ms
+\t\tprocessing time range: ${statsString(processingTimesPerFile, ' ms')}
+\ttotal number of lines: ${lineLengths.sum}
+\t\tline range: ${statsString(linesPerFile)}
+\t\tline length range: ${statsString(lineLengths, ' chars')}
+  `);
+}
+exports.printFeatureStatistics = printFeatureStatistics;
+const pad = 3;
+function printFeatureStatisticsEntry(info) {
+    let longestKey = 0;
+    let longestValue = 0;
+    const out = new Map();
+    for (const [key, value] of Object.entries(info)) {
+        if (key.length > longestKey) {
+            longestKey = key.length;
+        }
+        const valueString = JSON.stringify(value, json_1.jsonReplacer);
+        out.set(key, valueString);
+        if (valueString.length > longestValue) {
+            longestValue = valueString.length;
+        }
+    }
+    for (const [key, value] of out.entries()) {
+        console.log(`${key.padEnd(longestKey + pad)} ${value.padStart(longestValue)}`);
+    }
+}
+exports.printFeatureStatisticsEntry = printFeatureStatisticsEntry;
+//# sourceMappingURL=print-stats.js.map

package/statistics/output/statistics-file.d.ts

@@ -0,0 +1,37 @@
+import type { DummyAppendMemoryMap, StatisticAppendProvider } from './file-provider';
+/**
+ * Requires source information to be attached on parsing!
+ * <p>
+ * Returns the content of the node (i.e., the text content excluding the children)
+ */
+export declare function extractNodeContent(node: Node): string;
+/** by default, we do not write to anything */
+export declare let statisticsFileProvider: StatisticAppendProvider;
+/**
+ * Make the statistics write to a given output directory.
+ */
+export declare function initFileProvider(outputDirectory: string): void;
+/**
+ * Either ignore the statistics or write them to a given map (e.g., for testing).
+ *
+ * @param map - The map to write to, will not persist calls if no map is given
+ */
+export declare function initDummyFileProvider(map?: DummyAppendMemoryMap): void;
+/**
+ * Format used to dump each entry of a feature during collection.
+ */
+export type StatisticsOutputFormat<T = string> = [
+    /** the collected value (like the assignment operator lexeme, ...) */
+    value: T,
+    /** the context of the information retrieval (e.g. the name of the file that contained the R source code) */
+    context: string | undefined
+];
+/**
+ * Append the content of all nodes to the storage file for the given feature
+ * @param name    - The name of the feature {@link Feature#name}
+ * @param fn      - The name of the feature-aspect to record
+ * @param nodes   - The nodes to append, you may pass already transformed string contents
+ * @param context - The context of the information retrieval (e.g. the name of the file that contained the R source code)
+ * @param unique  - Should duplicate entries be removed on addition
+ */
+export declare function appendStatisticsFile<T>(name: string, fn: keyof T, nodes: string[] | Node[] | object[], context: string | undefined, unique?: boolean): void;