@vernikr/size-report 1.1.1

package/src/git.js

@@ -0,0 +1,221 @@
+import { execFileSync, spawnSync } from 'child_process';
+import { EXIT, refuse } from './refusal.js';
+
+/* Единственная граница вызова git: закрепления настроек, блобы пачкой, история и
+ * сверка с диском. Всё, что инструмент знает о содержимом репозитория, приходит
+ * отсюда, — поэтому и закрепления задаются здесь, а не в каждом вызове. */
+
+export const MAX_BUF = 256 * 1024 * 1024;
+const FIELD = '\u0001'; // разделитель полей в формате git log
+
+/* Всё, что движок читает у git, читается с явно заданными настройками: их
+ * значения по умолчанию берутся из настроек машины и меняют то, что попадает в
+ * разбор. Без `core.quotePath=false` не-английские пути приходят закавыченными и
+ * экранированными (`"docs/\320\267..."`): колонка с таким путём не находит файла,
+ * а коммит, у которого она была единственным изменением объёма, теряет строку.
+ * Остальные закрепления закрывают тот же класс — раскраска и блок подписи
+ * подмешались бы в разбираемый поток, а перекодировка подписей — в подписи строк
+ * отчёта. Закрепление задаётся здесь, а не в каждом вызове: иначе его забудет
+ * следующий вызов.
+ *
+ * Локаль закрепляется заодно: разбор не должен зависеть от того, какие переводы
+ * стоят на машине. Цена — сообщения самого git в неожиданных отказах идут
+ * по-английски; сообщения инструмента остаются русскими. */
+export const GIT_PINS = [
+  'core.quotePath=false',
+  'color.ui=never',
+  'log.showSignature=false',
+  'i18n.logOutputEncoding=UTF-8'
+];
+
+export function gitArgv(args) {
+  const out = ['--no-pager'];
+  GIT_PINS.forEach((pin) => { out.push('-c', pin); });
+  return out.concat(args);
+}
+
+export function gitEnv() {
+  return Object.assign({}, process.env, { LC_ALL: 'C', LANG: 'C' });
+}
+
+export function git(root, args) {
+  return execFileSync('git', gitArgv(args), {
+    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv()
+  });
+}
+
+/* То же чтение, но с кодом возврата: там, где ненулевой код — ожидаемый ответ, а не
+ * отказ (`git diff --quiet` отвечает 1 на расхождение). Исключение здесь означало бы
+ * отказ инструмента там, где задан простой вопрос. `env` досыпается к окружению
+ * границы — им хук собирает коммит отчёта в отдельном индексе, не трогая
+ * настоящий (см. `src/hook.js`). */
+export function gitTry(root, args, env) {
+  const res = spawnSync('git', gitArgv(args), {
+    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF,
+    env: Object.assign(gitEnv(), env || {})
+  });
+  return { status: res.status, stdout: res.stdout || '', stderr: res.stderr || '' };
+}
+
+/* Чтение блобов пачкой. `git cat-file --batch-check` отвечает про список пар
+ * `ревизия:путь` (sha объекта и размер), `--batch` отдаёт содержимое. Один-два
+ * процесса на всю историю вместо спавна `git show` на каждый файл — на тысячах
+ * коммитов это разница между минутами и секундой. Побочно размер объекта
+ * оказывается дешевле его чтения: метрике `raw` содержимое не нужно вовсе.
+ *
+ * Ответы позиционные (строка на запрос), поэтому запросы и ответы сопоставляются
+ * по порядку — `ревизия:путь` git в ответе не повторяет. */
+const BLOB_CHUNK = 1000; // спек на пачку: ограничивает и stdin, и память
+
+function catFileCheck(root, specs) {
+  const out = execFileSync('git', gitArgv(['cat-file', '--batch-check=%(objectname) %(objecttype) %(objectsize)']), {
+    cwd: root, encoding: 'utf8', input: specs.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
+  });
+  return out.split('\n');
+}
+
+function catFileBatch(root, shas) {
+  const buf = execFileSync('git', gitArgv(['cat-file', '--batch']), {
+    cwd: root, input: shas.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
+  });
+  const out = new Map();
+  let i = 0;
+  while (i < buf.length) {
+    const nl = buf.indexOf(10, i);
+    if (nl < 0) break;
+    const f = buf.toString('utf8', i, nl).split(' ');
+    i = nl + 1;
+    if (f.length < 3) continue; // «<спека> missing»
+    const size = Number(f[2]);
+    out.set(f[0], { size: size, text: buf.toString('utf8', i, i + size) });
+    i += size + 1; // перевод строки после содержимого
+  }
+  return out;
+}
+
+/* Блобы для списка пар «ревизия:путь». `needText` — читать ли содержимое: метрике
+ * `raw` хватает размера объекта, и тогда `--batch` не вызывается вовсе.
+ * Одинаковые спеки и одинаковые блобы запрашиваются один раз (кэш по sha). */
+export function readBlobs(root, specs, needText) {
+  const uniq = [...new Set(specs)];
+  const out = new Map();
+  const texts = new Map(); // sha блоба → содержимое
+  for (let start = 0; start < uniq.length; start += BLOB_CHUNK) {
+    const part = uniq.slice(start, start + BLOB_CHUNK);
+    const lines = catFileCheck(root, part);
+    const want = [];
+    part.forEach((spec, i) => {
+      const line = lines[i] === undefined ? '' : lines[i];
+      if (line === '' || line.slice(-8) === ' missing') return;
+      const f = line.split(' ');
+      if (f.length < 3 || f[1] !== 'blob') return;
+      out.set(spec, { sha: f[0], size: Number(f[2]), text: null });
+      if (texts.has(f[0])) return;
+      want.push(f[0]);
+    });
+    if (!needText || want.length === 0) continue;
+    catFileBatch(root, [...new Set(want)]).forEach((b, sha) => { texts.set(sha, b.text); });
+  }
+  if (needText) out.forEach((b) => { if (texts.has(b.sha)) b.text = texts.get(b.sha); });
+  return out;
+}
+
+/* Дерево HEAD: sha блобов всех файлов коммита. Это правда о содержимом HEAD,
+ * добытая не тем же способом, что состояние движка (то читает блобы пачкой),
+ * поэтому расхождение с ней и означает потерянную при переносе правку. Один вызов
+ * на прогон; разбор идёт по NUL (`-z`), иначе пути с пробелами пришлось бы
+ * раскодировать. */
+export function headTree(root) {
+  const out = new Map();
+  const tree = execFileSync('git', gitArgv(['ls-tree', '-r', '-z', 'HEAD']), {
+    cwd: root, encoding: 'utf8', maxBuffer: MAX_BUF, env: gitEnv()
+  });
+  tree.split('\u0000').forEach((rec) => {
+    const tab = rec.indexOf('\t');
+    if (tab < 0) return;
+    out.set(rec.slice(tab + 1), rec.slice(0, tab).split(' ')[2]);
+  });
+  return out;
+}
+
+/* Файлы на диске — такими, какими их видит git: `hash-object` пропускает каждый
+ * файл через те же переводы строк и фильтры, что и `git add` (`.gitattributes`,
+ * `core.autocrlf`). Поэтому «файл на диске соответствует коммиту» — это сравнение
+ * хешей, а не размеров: размер зависит от выкладки (при `core.autocrlf=true` на
+ * диске CRLF, в git LF). Пути приходят списком, ответы позиционные — как у
+ * `cat-file`. */
+export function diskHashes(root, paths) {
+  const out = new Map();
+  const lines = execFileSync('git', gitArgv(['hash-object', '--stdin-paths']), {
+    cwd: root, encoding: 'utf8', input: paths.join('\n') + '\n', maxBuffer: MAX_BUF, env: gitEnv()
+  }).split('\n');
+  paths.forEach((p, i) => { out.set(p, lines[i] === undefined ? '' : lines[i].trim()); });
+  return out;
+}
+
+/* Обратный перевод: то, что git выложил бы на диск для блоба этой ревизии и пути
+ * (`--filters` применяет фильтры выкладки). Нужен там, где переводы строк git не
+ * возвращает обратно: файл, в котором CRLF лежат в самом коммите, при
+ * `core.autocrlf=true` выкладывается как есть, а «очистка» вернула бы LF, — сам
+ * git про такие файлы предупреждает, а на диск кладёт именно это. */
+export function diskForm(root, rev, p) {
+  return execFileSync('git', gitArgv(['cat-file', '--filters', rev + ':' + p]), {
+    cwd: root, maxBuffer: MAX_BUF, env: gitEnv()
+  });
+}
+
+// Содержимое файла в ревизии или null, если файла там нет.
+export function blobAt(root, rev, p) {
+  const blobs = readBlobs(root, [rev + ':' + p], true);
+  const blob = blobs.get(rev + ':' + p);
+  return blob === undefined ? null : blob.text;
+}
+
+/* Имя ревизии → sha коммита: `HEAD`, ветка, тег, `HEAD~1`, короткий или полный
+ * sha. Правила имён остаются за git, а не переписываются здесь: свои разошлись бы
+ * с ним на первом же `main~2` или `HEAD@{1}`, а `^{commit}` отсекает имена, ведущие
+ * не к коммиту (тег на блоб, путь в дереве). Имя, начинающееся с дефиса, к git не
+ * идёт вовсе: в `rev-parse` оно было бы ключом, а не ревизией.
+ * Не разрешилось — `null`: «имени нет» и «имя неоднозначно» разбирает вызывающий,
+ * у которого для этого есть список коммитов. */
+export function resolveCommit(root, name) {
+  if (name === '' || name.charAt(0) === '-') return null;
+  const res = gitTry(root, ['rev-parse', '--verify', '--quiet', name + '^{commit}']);
+  const sha = res.stdout.trim();
+  return res.status === 0 && /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+}
+
+/* История одним вызовом: заголовок коммита и список изменённых им путей.
+ * `%ad` — дата автора в его собственной зоне (не в зоне машины), иначе таблица
+ * собиралась бы в CI по UTC и расходилась бы с локальной сборкой.
+ * `--diff-merges=first-parent` — иначе у merge-коммита списка путей нет вовсе
+ * (git не показывает дифф слияния, пока не попросишь): правки разрешения
+ * конфликта выпали бы и из строки, и из переноса состояния, а состояние на HEAD
+ * разошлось бы с содержимым файла в дереве. С первым родителем у слияния видно
+ * ровно то, что оно привнесло поверх своей ветки. */
+export function readHistory(root) {
+  const log = git(root, [
+    'log', '--reverse', '--name-only', '--diff-merges=first-parent', '--date=format:%Y-%m-%d %H:%M',
+    '--pretty=format:commit' + FIELD + '%H' + FIELD + '%ad' + FIELD + '%P' + FIELD + '%s'
+  ]);
+  const commits = [];
+  let cur = null;
+  log.split('\n').forEach((line) => {
+    if (line.indexOf('commit' + FIELD) === 0) {
+      const f = line.split(FIELD);
+      cur = { sha: f[1], when: f[2], parents: f[3] ? f[3].split(' ') : [], subject: f[4], files: [] };
+      commits.push(cur);
+      return;
+    }
+    if (line !== '' && cur) cur.files.push(line);
+  });
+  return commits;
+}
+
+export function assertFullHistory(root) {
+  if (git(root, ['rev-parse', '--is-shallow-repository']).trim() === 'true') {
+    refuse(EXIT.SHALLOW, 'история обрезана (shallow clone): таблица строится по всей истории коммитов.\n'
+      + '  локально: git fetch --unshallow\n'
+      + '  в CI: actions/checkout с fetch-depth: 0');
+  }
+}

package/src/history.js

@@ -0,0 +1,206 @@
+import fs from 'fs';
+import path from 'path';
+import { assertFullHistory, diskForm, diskHashes, git, headTree, readBlobs, readHistory } from './git.js';
+import { METRICS, measureBlob, pointExact } from './metrics.js';
+import { touchedSection } from './journal.js';
+import { EXIT, refuse } from './refusal.js';
+
+/* Обход истории: измерение по коммитам, сдвиг чисел, перенос состояния между
+ * коммитами, сверка с рабочим деревом и сборка — та единственная точка, из
+ * которой состояние и строки попадают наружу. Верхний этаж чтения: ниже — git и
+ * метрики, выше — только уже собранные значения. */
+
+/* Причина, по которой коммит не получил строки, — ключ, а не текст: по нему и
+ * считается сводка, и отвечает `explain`. Слова для человека — в `skipLine`, и
+ * они те же, что были строкой раньше: «без изменения объёма» накрывает и тот
+ * случай, когда коммит не тронул ни одного файла колонок, — в отчёте эта разница
+ * не проводилась, и эталон контракта её сохраняет; отличие видно в `explain`, где
+ * оно и нужно. */
+const SKIP_WORDS = { merge: 'merge', report: 'только таблица', flat: 'без изменения объёма' };
+
+export function skipLine(dropped) {
+  return dropped.sha.slice(0, 7) + ' (' + SKIP_WORDS[dropped.reason] + ')';
+}
+
+/* Сдвинул ли коммит хотя бы одно число. Сравниваются числа, а не список файлов:
+ * правка в пробелах или комментариях размера не меняет, и строка про неё была бы
+ * пустой, а у слияния клетки выходят нулевыми всегда, когда разрешение конфликта
+ * совпало с тем, что уже дала ветка. Колонка, которой коммит не касался,
+ * остаётся тем же объектом состояния. */
+function changesVolume(state, before, columns, metrics) {
+  return columns.some((_col, i) => {
+    const a = state[i], b = before[i];
+    if (a === b) return false;
+    if (a === null || b === null) return true;
+    return metrics.some((m) => a.cells[m] !== b.cells[m]);
+  });
+}
+
+/* Проход по истории. Состояние колонки переносится вперёд, а перезамер делается
+ * только для изменившихся в коммите файлов. Читается всё сразу: сначала план
+ * «какие пары ревизия:путь понадобятся», затем один поход в git (`readBlobs`),
+ * затем собственно измерение — иначе на каждый коммит приходилось бы по
+ * git-вызову на колонку. Значения метрик кэшируются по sha блоба: ревизия с тем
+ * же содержимым (откат, повторный merge) не пересчитывается.
+ *
+ * `known` — уже прочитанная история: проходам, которым она нужна ещё и сама по
+ * себе (полнота покрытия), незачем звать `git log` второй раз. */
+export function measureHistory(cfg, root, known) {
+  const commits = known === undefined ? readHistory(root) : known;
+  const metrics = cfg.metrics;
+  // Текст журнала нужен всегда: ссылка в раздел — не метрика, но тоже чтение.
+  const needText = !!cfg.journal || metrics.some((m) => METRICS[m].needsText);
+  const skipPaths = [cfg.output].concat(cfg.skip || []);
+  const state = cfg.columns.map(() => null);
+  const rows = [];
+  const dropped = [];
+  const mixed = [];
+  let journalPrev = '';
+
+  const plan = commits.map((c) => {
+    const changed = new Set(c.files);
+    /* Псевдонимов колонки, которых коммит коснулся, может быть и два: при
+     * выключенном распознавании переименований git отдаёт в одном коммите и старое
+     * имя, и новое. Собираются все — какой из них в коммите действительно есть,
+     * решается потом, по прочитанным блобам. */
+    const picks = cfg.columns.map((col) => col.paths
+      .filter((cand) => changed.has(cand))
+      .map((path) => ({ path: path, spec: c.sha + ':' + path })));
+    const journal = cfg.journal && changed.has(cfg.journal.path) ? c.sha + ':' + cfg.journal.path : null;
+    return { picks: picks, journal: journal };
+  });
+
+  const specs = [];
+  plan.forEach((p) => {
+    p.picks.forEach((candidates) => { candidates.forEach((cand) => specs.push(cand.spec)); });
+    if (p.journal !== null) specs.push(p.journal);
+  });
+  const blobs = readBlobs(root, specs, needText);
+
+  const measured = new Map(); // sha блоба + метрика → число
+  const measure = (name, blob, file, rev) => {
+    const key = blob.sha + '\u0000' + name;
+    if (measured.has(key)) return measured.get(key);
+    const value = measureBlob(name, blob, file, cfg, rev);
+    measured.set(key, value);
+    return value;
+  };
+
+  commits.forEach((c, ci) => {
+    let section = null;
+    if (plan[ci].journal !== null) {
+      const journalBlob = blobs.get(plan[ci].journal);
+      if (journalBlob !== undefined) {
+        section = touchedSection(journalPrev, journalBlob.text, cfg.journal.pattern);
+        journalPrev = journalBlob.text;
+      }
+    }
+
+    const before = state.slice();
+    plan[ci].picks.forEach((candidates, i) => {
+      /* Из псевдонимов берётся тот, который в коммите есть, а не первый по
+       * порядку настроек: исчезнувшее имя в коммите отсутствует, и состояние,
+       * взятое по порядку, теряло файл (а сверка с деревом — отказывала). */
+      const pick = candidates.find((cand) => blobs.get(cand.spec) !== undefined);
+      if (pick === undefined) {
+        // Путь в коммите есть, а файла по нему нет — файл удалён.
+        if (candidates.length > 0) state[i] = null;
+        return;
+      }
+      const blob = blobs.get(pick.spec);
+      const cells = {};
+      /* Приближённость числа — свойство пути, а не блоба: от расширения зависит,
+       * возьмёт ли формат минификатор. Поэтому она считается здесь, вместо с
+       * замером, и в кэш содержимого не попадает. */
+      const approx = {};
+      metrics.forEach((m) => {
+        cells[m] = measure(m, blob, pick.path, c.sha);
+        approx[m] = !pointExact(m, pick.path, cfg);
+      });
+      state[i] = { path: pick.path, sha: blob.sha, cells: cells, approx: approx };
+    });
+
+    if (c.parents.length > 1 && !cfg.rows.merges) { dropped.push({ sha: c.sha, reason: 'merge' }); return; }
+    if (c.files.length > 0 && c.files.every((f) => skipPaths.indexOf(f) >= 0)) {
+      dropped.push({ sha: c.sha, reason: 'report' });
+      return;
+    }
+    if (!changesVolume(state, before, cfg.columns, metrics)) {
+      dropped.push({ sha: c.sha, reason: 'flat' });
+      return;
+    }
+    if (c.files.some((f) => f === cfg.output)) mixed.push(c.sha.slice(0, 7));
+
+    rows.push({
+      sha: c.sha,
+      when: c.when,
+      subject: c.subject,
+      section: section,
+      cells: state.map((s) => (s === null ? null : s.cells)),
+      approx: state.map((s) => (s === null ? null : s.approx))
+    });
+  });
+
+  return { rows, dropped, mixed, state };
+}
+
+/* Сверка с рабочим деревом отвечает на два вопроса, и оба обязательны: состояние
+ * движка на HEAD совпадает с деревом коммита, и файл на диске соответствует тому
+ * же содержимому. Первый ловит правку, потерянную при переносе состояния между
+ * коммитами (например, у merge-коммита, которого нет в списке изменённых путей): и
+ * потерянное создание файла (в дереве он есть, а состояние о нём не знает), и
+ * потерянное изменение (файл есть с обеих сторон, содержимое разное), и потерянное
+ * удаление (состояние о файле знает, а в дереве его нет). Сравнение при этом идёт
+ * с расхождением, а не с пустотой: колонка, чей файл жил в истории и был удалён до
+ * HEAD, пуста с обеих сторон — это не потеря, а её видно в отчёте. Второй вопрос —
+ * правка, которой в истории нет вовсе. Размеры для этого не годятся: на диске они
+ * зависят от выкладки (при `core.autocrlf=true` — значение по умолчанию в установке
+ * Git для Windows — CRLF против LF), и инструмент отказывался работать там, где всё
+ * в порядке. Файлы, изменённые в дереве, из сверки с диском выпадают: их
+ * содержимое в коммите и на диске различается законно. */
+function assertMatchesDisk(state, cfg, root) {
+  const dirty = new Set(git(root, ['status', '--porcelain']).split('\n')
+    .map((l) => l.trim()).filter((l) => l !== '').map((l) => l.replace(/^\S+\s+/, '').replace(/^.* -> /, '')));
+  const tree = headTree(root);
+  const clean = [];
+  cfg.columns.forEach((col, i) => {
+    const s = state[i];
+    const aliases = col.paths.filter((alias) => tree.has(alias));
+    const p = s === null ? aliases[0] : s.path;
+    const inTree = p === undefined ? undefined : tree.get(p);
+    const lost = s === null ? aliases.length > 0 : inTree !== s.sha;
+    if (lost) {
+      refuse(EXIT.VIOLATION, 'состояние «' + col.label + '» на HEAD не совпало с деревом коммита (в дереве '
+        + (aliases.length === 0 ? 'файла нет'
+          : aliases.map((alias) => alias + ' ' + tree.get(alias).slice(0, 7)).join(', '))
+        + ', в состоянии ' + (s === null ? 'файла нет' : s.path + ' ' + s.sha.slice(0, 7))
+        + '): перенос состояния между коммитами пропустил правку'
+        // Пересборка здесь не починка: состояние считается тем же прогоном, и
+        // устаревшей таблицы в этом расхождении нет. Поэтому совет называет не
+        // команду починки, а то, чем это можно показать.
+        + '\n  починка: пересборкой это не лечится — расхождение в самом переносе состояния,'
+        + ' а не в таблице. Разбор: git show HEAD:' + p);
+    }
+    if (p !== undefined && !dirty.has(p) && clean.indexOf(p) < 0) clean.push(p);
+  });
+  if (clean.length === 0) return;
+  const onDisk = diskHashes(root, clean);
+  clean.forEach((p) => {
+    if (onDisk.get(p) === tree.get(p)) return; // git считает файл неизменным
+    if (fs.readFileSync(path.join(root, p)).equals(diskForm(root, 'HEAD', p))) return; // переводы строк необратимы
+    refuse(EXIT.VIOLATION, 'содержимое ' + p + ' на диске разошлось с HEAD (' + onDisk.get(p).slice(0, 7)
+      + ' вместо ' + tree.get(p).slice(0, 7) + '), хотя git не считает файл изменённым: правка есть только на диске'
+      + '\n  починка: закоммитьте правку или откатите её: git checkout -- ' + p);
+  });
+}
+
+export function build(cfg, root) {
+  assertFullHistory(root);
+  const measured = measureHistory(cfg, root);
+  assertMatchesDisk(measured.state, cfg, root);
+  if (measured.mixed.length > 0) {
+    console.error('! таблицу обновляли вместе с кодом: ' + measured.mixed.join(', ')
+      + ' — так строка коммита не может попасть в сам коммит; обновляйте таблицу отдельным коммитом.');
+  }
+  return measured;
+}