Build: ein paralleler Ordnergrößen-Bericht

// Sums the sizes per top-level entry: a folder such as docs/, or a file at the top.
// Largest first; equal sizes by name, so the report is the same on every run.
export function sumByTop(records) {
  return records.map(({path, size}) => ({name: path, size, files: 1}));
}

console.log(sumByTop([
  {path: 'docs/a.txt', size: 1200},
  {path: 'img/logo.svg', size: 2048},
  {path: 'docs/guide/b.txt', size: 300},
  {path: 'notes.txt', size: 10}
]));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {sumByTop} from './main.js';

const records = [
  {path: 'docs/a.txt', size: 1200},
  {path: 'img/logo.svg', size: 2048},
  {path: 'docs/guide/b.txt', size: 300},
  {path: 'notes.txt', size: 10}
];

test('Dateien unter demselben obersten Ordner werden addiert, größte Zeile zuerst', () => {
  const got = sumByTop(records);
  const want = [
    {name: 'img/', size: 2048, files: 1},
    {name: 'docs/', size: 1500, files: 2},
    {name: 'notes.txt', size: 10, files: 1}
  ];
  assert.deepEqual(got, want, `sumByTop lieferte ${JSON.stringify(got)}`);
});

test('Gleiche Größen werden nach Name sortiert', () => {
  const got = sumByTop([{path: 'b.txt', size: 5}, {path: 'c/x.txt', size: 9}, {path: 'a/y.txt', size: 5}]).map((row) => row.name);
  assert.deepEqual(got, ['c/', 'a/', 'b.txt'], `die Zeilen kamen in der Reihenfolge ${JSON.stringify(got)}`);
});

test('Keine Datensätze ergeben keine Zeilen', () => {
  assert.deepEqual(sumByTop([]), [], `sumByTop([]) lieferte ${JSON.stringify(sumByTop([]))}`);
});

test('Die übergebenen Datensätze bleiben unverändert', () => {
  const copy = records.map((record) => ({...record}));
  sumByTop(copy);
  assert.deepEqual(copy, records, 'sumByTop hat die übergebenen Datensätze verändert');
});

{
  "type": "module"
}

// 512 B, 1.5 KiB, 2.0 MiB: steps of 1024, one decimal from KiB on.
export function formatSize(bytes) {
  return bytes + ' B';
}

// One line per row, then a total line.
export function formatReport(rows) {
  return rows.map((row) => row.name + '  ' + formatSize(row.size)).join('\n');
}

console.log(formatReport([
  {name: 'img/', size: 2048, files: 1},
  {name: 'docs/', size: 1500, files: 2},
  {name: 'notes.txt', size: 10, files: 1}
]));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {formatReport, formatSize} from './main.js';

test('Unter 1024 Bytes: die Zahl und B', () => {
  for (const [bytes, want] of [[0, '0 B'], [10, '10 B'], [1023, '1023 B']]) {
    assert.equal(formatSize(bytes), want, `formatSize(${bytes}) lieferte ${JSON.stringify(formatSize(bytes))}`);
  }
});

test('KiB und MiB mit einer Nachkommastelle', () => {
  for (const [bytes, want] of [[1024, '1.0 KiB'], [1536, '1.5 KiB'], [1048576, '1.0 MiB'], [3407872, '3.3 MiB']]) {
    assert.equal(formatSize(bytes), want, `formatSize(${bytes}) lieferte ${JSON.stringify(formatSize(bytes))}`);
  }
});

test('Eine Zeile pro Eintrag, dann die Summe', () => {
  const got = formatReport([{name: 'img/', size: 2048, files: 1}, {name: 'docs/', size: 1500, files: 2}]);
  assert.equal(got, 'img/  2.0 KiB  (1 file)\ndocs/  1.5 KiB  (2 files)\ntotal  3.5 KiB  (3 files)\n', `formatReport lieferte ${JSON.stringify(got)}`);
});

test('Ohne Einträge bleibt nur die Summe', () => {
  assert.equal(formatReport([]), 'total  0 B  (0 files)\n', `formatReport([]) lieferte ${JSON.stringify(formatReport([]))}`);
});

{
  "type": "module"
}

// Calls fn(item) for every item, with at most limit calls running at once.
// Never rejects: one {status, value} or {status, reason} per item, in the
// order of items, as Promise.allSettled gives them.
export async function settleLimit(items, limit, fn) {
  return Promise.allSettled(items.map(fn)); // starts every call at once
}

// A stand-in for stat: waits, then gives a size, or fails for a file that is gone.
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const fakeStat = async (name) => {
  await sleep(10);
  if (name === 'gone.txt') throw new Error('ENOENT: ' + name);
  return {size: name.length};
};

const results = await settleLimit(['a.txt', 'gone.txt', 'bb.txt'], 2, fakeStat);
console.log(results.map((r) => (r.status === 'fulfilled' ? r.value.size : r.reason.message)));

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {settleLimit} from './main.js';

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// fn for the tests: counts the calls running at once; fails for negative numbers.
function counter() {
  const seen = {active: 0, most: 0, calls: 0};
  seen.fn = async (ms) => {
    seen.calls++;
    seen.active++;
    seen.most = Math.max(seen.most, seen.active);
    await sleep(Math.abs(ms));
    seen.active--;
    if (ms < 0) throw new Error('failed ' + ms);
    return ms * 2;
  };
  return seen;
}

test('Ein Ergebnis pro Element, in der Reihenfolge der Elemente', async () => {
  const got = await settleLimit([30, 10, 20], 2, counter().fn);
  const want = [{status: 'fulfilled', value: 60}, {status: 'fulfilled', value: 20}, {status: 'fulfilled', value: 40}];
  assert.deepEqual(got, want, `settleLimit lieferte ${JSON.stringify(got)}`);
});

test('Nie mehr als limit Aufrufe gleichzeitig', async () => {
  const seen = counter();
  await settleLimit([20, 10, 30, 10, 20, 10], 2, seen.fn);
  assert.equal(seen.most, 2, `höchstens ${seen.most} Aufrufe liefen gleichzeitig; erwartet waren 2`);
});

test('Ein scheiternder Aufruf ist ein abgelehntes Ergebnis, und jedes Element wird trotzdem bearbeitet', async () => {
  const seen = counter();
  const got = await settleLimit([10, -10, 10, 10], 2, seen.fn);
  assert.deepEqual(got.map((r) => r.status), ['fulfilled', 'rejected', 'fulfilled', 'fulfilled'], `die Status waren ${JSON.stringify(got.map((r) => r.status))}`);
  assert.equal(got[1].reason.message, 'failed -10', 'das abgelehnte Ergebnis sollte den Fehler als reason behalten');
  assert.equal(seen.calls, 4, `fn wurde ${seen.calls}-mal aufgerufen; erwartet war 4-mal`);
});

test('Eine leere Liste ergibt ein leeres Array', async () => {
  const got = await settleLimit([], 3, counter().fn);
  assert.deepEqual(got, [], `settleLimit lieferte ${JSON.stringify(got)}`);
});

{
  "type": "module"
}

import {readdir, stat} from 'node:fs/promises';
import {join, relative, sep} from 'node:path';
import {parseArgs} from 'node:util';
import {formatReport, settleLimit, sumByTop} from './report.js';

const USAGE = 'Usage: node main.js [folder] [--limit <n>]';

// Every entry below root that is not a folder, as a path relative to root with / between parts.
async function listFiles(root) {
  return readdir(root); // only the top level, and folders too
}

// Stats every path, at most limit at once. A path that fails is a problem, not the end of the run.
async function statAll(root, paths, limit) {
  const infos = await Promise.all(paths.map((path) => stat(join(root, path))));
  return {records: paths.map((path, i) => ({path, size: infos[i].size})), problems: []};
}

// What to print, and the exit code: 0 = all read, 1 = something could not be read, 2 = wrong usage.
async function run(args) {
  let values, positionals;
  try {
    ({values, positionals} = parseArgs({
      args,
      options: {limit: {type: 'string', default: '8'}},
      allowPositionals: true
    }));
  } catch (error) {
    return {out: '', err: error.message + '\n' + USAGE + '\n', code: 2};
  }
  const limit = Number(values.limit);
  if (positionals.length > 1 || !Number.isInteger(limit) || limit < 1) return {out: '', err: USAGE + '\n', code: 2};
  const root = positionals[0] ?? '.';
  let paths;
  try {
    paths = await listFiles(root);
  } catch (error) {
    return {out: '', err: 'cannot read ' + root + ': ' + error.code + '\n', code: 1};
  }
  const {records, problems} = await statAll(root, paths, limit);
  return {out: formatReport(sumByTop(records)), err: problems.sort().join(''), code: problems.length > 0 ? 1 : 0};
}

// The only lines that touch the real process.
const {out, err, code} = await run(process.argv.slice(2));
process.stdout.write(out);
process.stderr.write(err);
process.exitCode = code;

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';

test('Der Ordner sample ergibt eine Zeile pro oberstem Eintrag, größte zuerst', async () => {
  const got = await runMain({args: ['sample']});
  assert.equal(got, "img/  2.0 KiB  (1 file)\ndocs/  1.5 KiB  (2 files)\nnotes.txt  10 B  (1 file)\ntotal  3.5 KiB  (4 files)\n", `der Bericht war ${JSON.stringify(got)}`);
});

test('Ein Limit von 1 ergibt denselben Bericht', async () => {
  const got = await runMain({args: ['sample', '--limit', '1']});
  assert.equal(got, "img/  2.0 KiB  (1 file)\ndocs/  1.5 KiB  (2 files)\nnotes.txt  10 B  (1 file)\ntotal  3.5 KiB  (4 files)\n", `mit --limit 1 war der Bericht ${JSON.stringify(got)}`);
});

test('Die Pfade sind relativ zum angegebenen Ordner', async () => {
  const got = await runMain({args: ['sample/docs']});
  assert.equal(got, 'a.txt  1.2 KiB  (1 file)\nguide/  300 B  (1 file)\ntotal  1.5 KiB  (2 files)\n', `der Bericht für sample/docs war ${JSON.stringify(got)}`);
});

test('Ein Ordner, den es nicht gibt, endet mit einem Fehlercode', async () => {
  await assert.rejects(runMain({args: ['nowhere']}), Error, 'node main.js nowhere sollte mit einem anderen Code als 0 enden');
});

test('Ein Limit von 0 ist falsche Bedienung', async () => {
  await assert.rejects(runMain({args: ['sample', '--limit', '0']}), Error, 'node main.js sample --limit 0 sollte mit einem anderen Code als 0 enden');
});

// Pure functions: no fs, no process, so they run anywhere.

// Calls fn(item) for every item, with at most limit calls running at once.
// Never rejects: one {status, value} or {status, reason} per item, in the
// order of items, as Promise.allSettled gives them.
export async function settleLimit(items, limit, fn) {
  const results = [];
  let next = 0; // the index of the next item to start
  async function worker() {
    while (next < items.length) {
      const index = next++;
      const [result] = await Promise.allSettled([fn(items[index])]);
      results[index] = result;
    }
  }
  const workers = [];
  for (let i = 0; i < Math.min(limit, items.length); i++) workers.push(worker());
  await Promise.all(workers);
  return results;
}

// Sums the sizes per top-level entry: a folder such as docs/, or a file at the top.
// Largest first; equal sizes by name, so the report is the same on every run.
export function sumByTop(records) {
  const totals = new Map();
  for (const {path, size} of records) {
    const slash = path.indexOf('/');
    const name = slash === -1 ? path : path.slice(0, slash + 1);
    const row = totals.get(name) ?? {name, size: 0, files: 0};
    row.size += size;
    row.files += 1;
    totals.set(name, row);
  }
  return [...totals.values()].sort((a, b) => b.size - a.size || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
}

// 512 B, 1.5 KiB, 2.0 MiB: steps of 1024, one decimal from KiB on.
export function formatSize(bytes) {
  if (bytes < 1024) return bytes + ' B';
  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KiB';
  return (bytes / (1024 * 1024)).toFixed(1) + ' MiB';
}

// One line per row, then a total line.
export function formatReport(rows) {
  const line = (name, size, files) => name + '  ' + formatSize(size) + '  (' + files + (files === 1 ? ' file)' : ' files)');
  const size = rows.reduce((sum, row) => sum + row.size, 0);
  const files = rows.reduce((sum, row) => sum + row.files, 0);
  return [...rows.map((row) => line(row.name, row.size, row.files)), line('total', size, files)].join('\n') + '\n';
}

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

ten bytes

{
  "type": "module"
}