wehub-resource-sync
131 lines
3.5 KiB
JavaScript
Executable File
131 lines
3.5 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
/**
|
|
* Extract a release-notes block from CHANGELOG.md for a given version
|
|
* (or unwrap text supplied on stdin), then join hard-wrapped paragraphs.
|
|
*
|
|
* Why: GitHub renders release-note Markdown with GFM hard breaks, so
|
|
* every `\n` becomes `<br>`. The CHANGELOG is hard-wrapped at ~75
|
|
* chars for readable diffs, which then renders as awkward visible
|
|
* line breaks on the release page. This script joins indented
|
|
* continuation lines into a single line per bullet so the GFM
|
|
* renderer produces clean paragraphs.
|
|
*
|
|
* Repo-level CHANGELOG.md viewing is unaffected (CommonMark treats
|
|
* newlines as spaces there).
|
|
*
|
|
* Usage:
|
|
* extract-release-notes.mjs <version> # read CHANGELOG.md
|
|
* extract-release-notes.mjs --stdin # read from stdin (any text)
|
|
*/
|
|
|
|
import { readFileSync } from 'fs';
|
|
|
|
const arg = process.argv[2];
|
|
if (!arg) {
|
|
console.error('usage: extract-release-notes.mjs <version> | --stdin');
|
|
process.exit(1);
|
|
}
|
|
|
|
let block;
|
|
if (arg === '--stdin') {
|
|
block = readFileSync(0, 'utf8').replace(/\r\n?/g, '\n').split('\n');
|
|
} else {
|
|
const version = arg;
|
|
const escaped = version.replace(/\./g, '\\.');
|
|
const headerRe = new RegExp(`^## \\[${escaped}\\]`);
|
|
const anyHeaderRe = /^## \[/;
|
|
const lines = readFileSync('CHANGELOG.md', 'utf8').split('\n');
|
|
const start = lines.findIndex((l) => headerRe.test(l));
|
|
if (start === -1) {
|
|
console.error(`no '## [${version}]' entry found in CHANGELOG.md`);
|
|
process.exit(1);
|
|
}
|
|
const after = lines.findIndex((l, i) => i > start && anyHeaderRe.test(l));
|
|
block = lines.slice(start, after === -1 ? lines.length : after);
|
|
}
|
|
|
|
// Track a stack of `{ indent: number }` frames so a continuation line
|
|
// can attach to the right ancestor. Handles the post-nested-list
|
|
// continuation pattern:
|
|
//
|
|
// - top-level
|
|
// - nested
|
|
// back to top-level <- 2-space indent, joins the top-level bullet
|
|
const out = [];
|
|
let buf = '';
|
|
let stack = [];
|
|
|
|
function flushBuf() {
|
|
if (buf !== '') {
|
|
out.push(buf);
|
|
buf = '';
|
|
}
|
|
}
|
|
|
|
function leadingSpaces(s) {
|
|
const m = s.match(/^(\s*)/);
|
|
return m ? m[1].length : 0;
|
|
}
|
|
|
|
// Bullets: `-`, `*`, `digit.` only. `+` is intentionally excluded — the
|
|
// CHANGELOG uses literal `+` inline (`config + instructions`) and we
|
|
// don't want to misread those as nested bullets.
|
|
const listItemRe = /^(\s*)([-*]|\d+\.)\s+/;
|
|
const fenceRe = /^\s*```/;
|
|
|
|
let inFence = false;
|
|
|
|
for (const line of block) {
|
|
// Fenced code blocks: pass through verbatim, no joining.
|
|
if (fenceRe.test(line)) {
|
|
flushBuf();
|
|
stack = [];
|
|
out.push(line);
|
|
inFence = !inFence;
|
|
continue;
|
|
}
|
|
if (inFence) {
|
|
out.push(line);
|
|
continue;
|
|
}
|
|
if (/^\s*$/.test(line)) {
|
|
flushBuf();
|
|
out.push('');
|
|
continue;
|
|
}
|
|
if (/^#/.test(line)) {
|
|
flushBuf();
|
|
stack = [];
|
|
out.push(line);
|
|
continue;
|
|
}
|
|
const itemMatch = line.match(listItemRe);
|
|
if (itemMatch) {
|
|
flushBuf();
|
|
const indent = itemMatch[1].length;
|
|
while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {
|
|
stack.pop();
|
|
}
|
|
stack.push({ indent });
|
|
buf = line;
|
|
continue;
|
|
}
|
|
if (/^\s/.test(line)) {
|
|
const indent = leadingSpaces(line);
|
|
while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
|
|
flushBuf();
|
|
stack.pop();
|
|
}
|
|
const trimmed = line.replace(/^\s+/, '');
|
|
buf = buf === '' ? trimmed : `${buf} ${trimmed}`;
|
|
continue;
|
|
}
|
|
flushBuf();
|
|
stack = [];
|
|
out.push(line);
|
|
}
|
|
flushBuf();
|
|
|
|
process.stdout.write(out.join('\n'));
|
|
if (!out[out.length - 1]?.endsWith('\n')) process.stdout.write('\n');
|