@magland/mochi 0.3.1

package/dist/find.js

@@ -0,0 +1,162 @@
+"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.registerFind = registerFind;
+exports.registerSearch = registerSearch;
+const git_1 = require("./git");
+const session_1 = require("./session");
+const views = __importStar(require("./views"));
+const web_1 = require("./web");
+// The two ways of finding something in a repository: by name and by content.
+//
+// The file finder: every path in the tree at one ref, filtered as you type.
+// GitHub reaches it with the "Go to file" button or the t key, and it is how
+// people navigate a repository they already know; clicking down through
+// directories is for a repository they do not.
+//
+// The whole list is rendered into the page and filtered in the browser. That
+// is the trade this design implies: no search endpoint, no index, no state
+// outside the vault, at the cost of a page whose size grows with the tree.
+// The cap below bounds that page; a tree past it is listed as far as the cap
+// and says so.
+const MAX_PATHS = 20000;
+function registerFind(app, root, gates) {
+    const handler = (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ref = (0, web_1.wildcard)(req) || loaded.defaultBranch || '';
+        if (!(0, git_1.isValidRefName)(ref)) {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        // ls-tree walks the whole tree, and execGit's maxBuffer is 256 MB, so a
+        // handful of these at once on a large repository is a memory problem before
+        // it is a CPU one. MAX_PATHS bounds one response; the gate bounds how many
+        // are in flight.
+        const release = await gates.tree.enter();
+        if (!release) {
+            (0, web_1.sendBusy)(res, viewer);
+            return;
+        }
+        let paths;
+        try {
+            const out = (await (0, git_1.execGit)(loaded.repo.dir, ['ls-tree', '-r', '--name-only', '-z', ref])).toString('utf8');
+            paths = out.split('\0').filter((p) => p !== '');
+        }
+        catch {
+            (0, web_1.send404)(res, `Ref ${ref} not found`, viewer);
+            return;
+        }
+        finally {
+            release();
+        }
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, ref, viewer);
+        res.type('html').send(views.findFilePage(ctx, paths.slice(0, MAX_PATHS), paths.length));
+    });
+    app.get('/:collection/:repo/find/*', handler);
+    app.get('/:collection/:repo/find', handler);
+}
+// How many files a result page groups, and how many lines it shows from any
+// one of them: a search for something common should still fit on a page.
+const MAX_RESULT_FILES = 40;
+const MAX_LINES_PER_FILE = 10;
+/**
+ * Group a flat list of hits by file, keeping git's order and capping both the
+ * number of files and the lines shown from each, so that what was left out is
+ * reported rather than quietly dropped.
+ */
+function groupHits(hits) {
+    const files = [];
+    const byPath = new Map();
+    let capped = false;
+    for (const hit of hits) {
+        let file = byPath.get(hit.path);
+        if (!file) {
+            if (files.length >= MAX_RESULT_FILES) {
+                capped = true;
+                continue;
+            }
+            file = { path: hit.path, hits: [], more: 0 };
+            byPath.set(hit.path, file);
+            files.push(file);
+        }
+        if (file.hits.length < MAX_LINES_PER_FILE)
+            file.hits.push(hit);
+        else
+            file.more++;
+    }
+    return { files, capped };
+}
+function registerSearch(app, root, gates) {
+    app.get('/:collection/:repo/search', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const asked = String(req.query.ref ?? '');
+        const ref = asked !== '' && loaded.refNames.includes(asked) ? asked : loaded.defaultBranch ?? '';
+        if (ref !== '' && !(0, git_1.isValidRefName)(ref)) {
+            (0, web_1.send404)(res, 'Not found', viewer);
+            return;
+        }
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, ref, viewer);
+        // A query is a reader's typing, so it is bounded before it becomes an
+        // argument: git grep is fast, but not on a pattern the length of a page.
+        const query = String(req.query.q ?? '').slice(0, 256);
+        if (query.trim() === '' || ref === '') {
+            res.type('html').send(views.searchPage(ctx, query, { files: [], total: 0, truncated: false, capped: false }));
+            return;
+        }
+        // git grep over a whole tree is the most expensive thing an anonymous
+        // reader can ask for, so it has the tightest gate of the four.
+        const release = await gates.search.enter();
+        if (!release) {
+            (0, web_1.sendBusy)(res, viewer);
+            return;
+        }
+        let hits;
+        let truncated;
+        try {
+            ({ hits, truncated } = await loaded.repo.search(ref, query));
+        }
+        finally {
+            release();
+        }
+        const { files, capped } = groupHits(hits);
+        res.type('html').send(views.searchPage(ctx, query, { files, total: hits.length, truncated, capped }));
+    }));
+}