@magland/mochi 0.3.1

package/dist/diff.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDiff = renderDiff;
+const icons_1 = require("./icons");
+const render_1 = require("./render");
+// Unified diff to HTML. Two things a patch carries that a plain rendering
+// throws away are recovered here: the line numbers each side of a hunk, and
+// the shape of the change (how many lines each file gained and lost, and
+// whether it was added, deleted, or renamed). Both are what a reader uses to
+// orient in a diff, so both are rendered.
+// Lines of a patch that describe the file rather than its content. The file
+// header already says what these say - the path, the status, the counts - so
+// they are dropped from the body, as GitHub drops them.
+const HEADER_PREFIXES = [
+    '+++',
+    '---',
+    'index ',
+    'new file',
+    'deleted file',
+    'similarity',
+    'dissimilarity',
+    'rename ',
+    'copy ',
+    'old mode',
+    'new mode',
+];
+// These two do belong in the body: they say something about the content.
+const NOTE_PREFIXES = ['Binary files', '\\'];
+/** How many lines of one file's diff we render before offering the file instead. */
+const MAX_FILE_LINES = 2000;
+function parse(patch) {
+    const files = [];
+    let cur = null;
+    for (const line of patch.split('\n')) {
+        const start = line.match(/^diff --git a\/(.*) b\/(.*)$/);
+        if (line.startsWith('diff --git ')) {
+            cur = {
+                path: start ? start[2] : line.slice('diff --git '.length),
+                oldPath: start ? start[1] : '',
+                status: 'modified',
+                binary: false,
+                added: 0,
+                removed: 0,
+                lines: [],
+            };
+            files.push(cur);
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (line.startsWith('new file'))
+            cur.status = 'added';
+        else if (line.startsWith('deleted file'))
+            cur.status = 'deleted';
+        else if (line.startsWith('rename to '))
+            cur.status = 'renamed';
+        else if (line.startsWith('Binary files'))
+            cur.binary = true;
+        else if (line.startsWith('+') && !line.startsWith('+++'))
+            cur.added++;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            cur.removed++;
+        cur.lines.push(line);
+    }
+    // A patch ends with a newline, which leaves an empty last line that is not
+    // part of anyone's file.
+    for (const f of files) {
+        while (f.lines.length > 0 && f.lines[f.lines.length - 1] === '')
+            f.lines.pop();
+    }
+    return files;
+}
+/**
+ * A bar beside a file's counts, in the proportion of the change: the share
+ * that was additions, then the share that was deletions, so a glance
+ * separates a rewrite from a one-line fix. A file that changed at all gets
+ * at least a tenth of the bar for each side it changed on, since a single
+ * deletion among four hundred additions should still be visible. The widths
+ * are inline because they are the datum; only the bar's shape is style.
+ */
+function statBar(added, removed) {
+    const total = added + removed;
+    if (total === 0)
+        return '';
+    const add = added > 0 && removed > 0
+        ? Math.min(90, Math.max(10, Math.round((added / total) * 100)))
+        : added > 0
+            ? 100
+            : 0;
+    return `<span class="statbar" aria-hidden="true"><span class="add" style="width:${add}%"></span><span class="del" style="width:${100 - add}%"></span></span>`;
+}
+function counts(added, removed) {
+    return `<span class="stat-add">+${added}</span><span class="stat-del">&minus;${removed}</span>${statBar(added, removed)}`;
+}
+const STATUS_LABEL = {
+    added: 'added',
+    deleted: 'deleted',
+    renamed: 'renamed',
+    modified: 'modified',
+};
+function renderBody(file) {
+    if (file.binary)
+        return `<div class="diff-none muted">Binary file not shown.</div>`;
+    if (file.lines.length > MAX_FILE_LINES) {
+        return `<div class="diff-none muted">This diff is ${file.lines.length.toLocaleString('en-US')} lines long and is not shown.</div>`;
+    }
+    // Line numbers come from the hunk headers: a context line advances both
+    // sides, an addition only the new one, a removal only the old one.
+    let oldNo = 0;
+    let newNo = 0;
+    const rows = [];
+    for (const l of file.lines) {
+        let cls = 'ctx';
+        let left = '';
+        let right = '';
+        const hunk = l.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+        if (HEADER_PREFIXES.some((p) => l.startsWith(p))) {
+            continue;
+        }
+        else if (hunk) {
+            oldNo = parseInt(hunk[1], 10);
+            newNo = parseInt(hunk[2], 10);
+            cls = 'hunk';
+        }
+        else if (NOTE_PREFIXES.some((p) => l.startsWith(p))) {
+            cls = 'meta';
+        }
+        else if (l.startsWith('+')) {
+            cls = 'add';
+            right = String(newNo++);
+        }
+        else if (l.startsWith('-')) {
+            cls = 'del';
+            left = String(oldNo++);
+        }
+        else if (l !== '') {
+            left = String(oldNo++);
+            right = String(newNo++);
+        }
+        rows.push(`<div class="dline ${cls}"><span class="dnum">${left}</span><span class="dnum">${right}</span><span class="dtext">${(0, render_1.esc)(l) || '&nbsp;'}</span></div>`);
+    }
+    if (rows.length === 0)
+        return `<div class="diff-none muted">No changes to the file's content.</div>`;
+    return `<div class="diff-body">${rows.join('')}</div>`;
+}
+function renderDiff(patch, opts = {}) {
+    const files = parse(patch);
+    if (files.length === 0)
+        return '<p class="muted">No changes.</p>';
+    const added = files.reduce((n, f) => n + f.added, 0);
+    const removed = files.reduce((n, f) => n + f.removed, 0);
+    const summary = `<div class="diff-summary"><b>${files.length} changed file${files.length === 1 ? '' : 's'}</b>${counts(added, removed)}</div>`;
+    const boxes = files
+        .map((f, i) => {
+        const view = opts.blobBase
+            ? `<a class="btn" href="${opts.blobBase}/${f.path
+                .split('/')
+                .map(encodeURIComponent)
+                .join('/')}" title="View the whole file at this revision">View file</a>`
+            : '';
+        const renamed = f.status === 'renamed' && f.oldPath ? `<span class="muted small">${(0, render_1.esc)(f.oldPath)} &rarr;</span>` : '';
+        // Each file is a <details>, so a reader can fold away what they have
+        // read; the summary keeps the name, the counts, and the way to the file.
+        return `<details class="diff-file" id="diff-${i}" open>
+<summary class="diff-file-header">${(0, icons_1.icon)('chevron-down', 'fold')}${renamed}<span class="diff-path mono">${(0, render_1.esc)(f.path)}</span><span class="chip">${STATUS_LABEL[f.status]}</span><span class="diff-file-stat">${counts(f.added, f.removed)}</span>${view}</summary>
+${renderBody(f)}
+</details>`;
+    })
+        .join('');
+    return `${summary}${boxes}`;
+}

package/dist/discussion.js

@@ -0,0 +1,253 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BODY = exports.MAX_TITLE = void 0;
+exports.itemDir = itemDir;
+exports.numericDirs = numericDirs;
+exports.readDoc = readDoc;
+exports.writeDoc = writeDoc;
+exports.str = str;
+exports.countComments = countComments;
+exports.touch = touch;
+exports.readComments = readComments;
+exports.checkTitle = checkTitle;
+exports.checkBody = checkBody;
+exports.openFor = openFor;
+exports.addComment = addComment;
+exports.allocate = allocate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const YAML = __importStar(require("yaml"));
+const atomic_1 = require("./atomic");
+const ops_1 = require("./ops");
+// What issues and pull requests have in common.
+//
+// The two are stored the same way on purpose: a numbered directory holding a
+// markdown file with a YAML frontmatter header, and a `comments/` directory of
+// further markdown files beside it. A pull request is a discussion with a
+// branch pair attached, so everything about the discussion half was written
+// twice, and the copies had begun to drift in the small ways copies do. The
+// bodies of `touch` differed only in a comment; `addComment` differed only in
+// the noun in one message and the name of the header file.
+//
+// What is left in issues.ts and pulls.ts is what genuinely differs: labels and
+// four sort orders on one side, base and head and merging on the other. What
+// moved here is the storage shape, which neither owns.
+//
+// A `DiscussionKind` is how the caller says which of the two it is. It carries
+// the header file's name, the directory the numbered ones sit in, and the noun
+// to use in a message, because a person reading "That is longer than a
+// discussion may be" would rightly wonder what a discussion is.
+exports.MAX_TITLE = 200;
+exports.MAX_BODY = 64 * 1024;
+/** The directory for one numbered issue or pull request. */
+function itemDir(kind, root, collection, repo, n) {
+    const dir = kind.dirFor(root, collection, repo);
+    if (!dir || !Number.isInteger(n) || n < 1)
+        return null;
+    return path.join(dir, String(n));
+}
+/** The numbered subdirectories of `dir`, in order. */
+function numericDirs(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isDirectory() && /^[1-9][0-9]*$/.test(e.name))
+        .map((e) => parseInt(e.name, 10))
+        .sort((a, b) => a - b);
+}
+/**
+ * A markdown file with a YAML frontmatter header, which is the shape of every
+ * file here. A file without a header is not one of ours and is skipped rather
+ * than guessed at.
+ */
+function readDoc(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m)
+        return null;
+    let meta;
+    try {
+        meta = YAML.parse(m[1]);
+    }
+    catch {
+        return null;
+    }
+    if (typeof meta !== 'object' || meta === null)
+        return null;
+    return { meta: meta, body: m[2] };
+}
+function writeDoc(file, meta, body) {
+    const text = `---\n${YAML.stringify(meta).trimEnd()}\n---\n${body.replace(/\s+$/, '')}\n`;
+    (0, atomic_1.writeFileAtomic)(file, text, { mode: 0o600 });
+}
+function str(v, fallback = '') {
+    return typeof v === 'string' ? v : fallback;
+}
+function countComments(dir) {
+    try {
+        return fs.readdirSync(path.join(dir, 'comments')).filter((f) => /^[1-9][0-9]*\.md$/.test(f)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Move a directory's timestamp, which is what invalidates the memoized open and
+ * closed counts shown on every repository page. Every write calls it.
+ */
+function touch(dir) {
+    const now = new Date();
+    try {
+        fs.utimesSync(dir, now, now);
+    }
+    catch {
+        // The directory may not exist yet; the next read simply misses the cache.
+    }
+}
+/** Every comment on one issue or pull request, oldest first. */
+function readComments(dir) {
+    let files = [];
+    try {
+        files = fs.readdirSync(path.join(dir, 'comments'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files.filter((x) => /^[1-9][0-9]*\.md$/.test(x)).sort((a, b) => parseInt(a, 10) - parseInt(b, 10))) {
+        const c = readDoc(path.join(dir, 'comments', f));
+        if (!c)
+            continue;
+        out.push({
+            id: parseInt(f, 10),
+            author: str(c.meta.author, 'unknown'),
+            created: str(c.meta.created),
+            body: c.body,
+        });
+    }
+    return out;
+}
+function checkTitle(kind, title) {
+    const t = title.trim().replace(/\s+/g, ' ');
+    if (t === '')
+        throw new ops_1.OpError(`${kind.Indefinite} needs a title.`);
+    if (t.length > exports.MAX_TITLE)
+        throw new ops_1.OpError(`A title may be at most ${exports.MAX_TITLE} characters.`);
+    return t;
+}
+function checkBody(kind, body) {
+    const b = body.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    if (b.length > exports.MAX_BODY)
+        throw new ops_1.OpError(`That is longer than ${kind.indefinite} may be.`);
+    return b;
+}
+/** Read a header for a write, refusing if it is not there. */
+function openFor(kind, root, collection, repo, n) {
+    const dir = itemDir(kind, root, collection, repo, n);
+    const doc = dir ? readDoc(path.join(dir, kind.doc)) : null;
+    if (!dir || !doc)
+        throw new ops_1.OpError(`${kind.Bare} ${n} does not exist.`, 'notfound');
+    return { dir, doc };
+}
+function addComment(kind, root, collection, repo, n, input) {
+    const { dir, doc } = openFor(kind, root, collection, repo, n);
+    const body = checkBody(kind, input.body);
+    if (body.trim() === '')
+        throw new ops_1.OpError('A comment needs something in it.');
+    const commentsDir = path.join(dir, 'comments');
+    fs.mkdirSync(commentsDir, { recursive: true });
+    const used = fs
+        .readdirSync(commentsDir)
+        .filter((f) => /^[1-9][0-9]*\.md$/.test(f))
+        .map((f) => parseInt(f, 10));
+    const now = new Date().toISOString();
+    let id = (used.length ? Math.max(...used) : 0) + 1;
+    for (let attempt = 0; attempt < 50; attempt++, id++) {
+        const file = path.join(commentsDir, `${id}.md`);
+        // Exclusive create is the allocation, as mkdir is for the numbers: an
+        // existsSync test leaves a window in which two writers pick the same id,
+        // and the second write would then replace the first comment outright.
+        try {
+            fs.closeSync(fs.openSync(file, 'wx'));
+        }
+        catch {
+            continue;
+        }
+        writeDoc(file, { author: input.author, created: now }, body);
+        writeDoc(path.join(dir, kind.doc), { ...doc.meta, updated: now }, doc.body);
+        const container = kind.dirFor(root, collection, repo);
+        if (container)
+            touch(container);
+        return { id, author: input.author, created: now, body };
+    }
+    throw new ops_1.OpError('Could not add the comment; try again.', 'conflict');
+}
+/**
+ * Allocate the next free number and build the directory for it.
+ *
+ * mkdir is the allocation: whoever creates the directory owns the number, and
+ * the filesystem decides that rather than a check that two writers could both
+ * pass. A racing writer gets EEXIST and tries the next one.
+ */
+function allocate(kind, dir, write) {
+    fs.mkdirSync(dir, { recursive: true });
+    let n = (numericDirs(dir).pop() ?? 0) + 1;
+    for (let attempt = 0; attempt < 50; attempt++, n++) {
+        const sub = path.join(dir, String(n));
+        try {
+            fs.mkdirSync(sub);
+        }
+        catch {
+            continue;
+        }
+        fs.mkdirSync(path.join(sub, 'comments'), { recursive: true });
+        write(sub, n);
+        touch(dir);
+        return n;
+    }
+    throw new ops_1.OpError(`Could not allocate ${kind.indefinite} number; try again.`, 'conflict');
+}