hanna/fabrica

fix(web): clickable global search results; blob box padding/rounding

28d6424 · hanna committed on 2026-07-25

Global code-search hits now link to the blob at each repo's default branch
(they were plain text — only in-repo search linked them), with the repo
heading linking to the repo. Wrap the code blob in a bordered, rounded,
scrollable box with vertical padding so its bottom corners round and the last
line isn't flush against the edge.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +21 −6

crates/web/src/repo.rs +13 −11

crates/web/src/search.rs +17 −10

+}
 /* ---- Search hits ---- */
+.search-repo {
+  margin: 1.5rem 0 0.6rem;
+  font-family: var(--fb-font-mono);
+  font-size: 0.95rem;
+}
+.search-repo a {
+  color: var(--fb-fg);
+}
+.search-repo a:hover {
+  color: var(--fb-accent);
+}
 .search-hit {
   padding: 0;
   overflow: hidden;
   border-radius: 0 0 var(--fb-radius) var(--fb-radius);
+}
+/* The blob box: border, rounded bottom, scroll, and vertical breathing room. */
+.blob-code {
+  border: 1px solid var(--fb-border);
+  border-top: none;
+  border-radius: 0 0 var(--fb-radius) var(--fb-radius);
+  background: var(--fb-bg-inset);
+  overflow-x: auto;
+  padding: 0.5rem 0;
+}
 table.blob {
   width: 100%;
   border-collapse: collapse;
-  border: 1px solid var(--fb-border);
-  border-radius: 0 0 var(--fb-radius) var(--fb-radius);
   font-family: var(--fb-font-mono);
   font-size: 0.85rem;
-  background: var(--fb-bg-inset);
-  overflow-x: auto;
+}
 table.blob td.lineno {
   width: 1%;
     overflow-x: auto;
     -webkit-overflow-scrolling: touch;
+  }
-  /* Blob and diff tables scroll within their own box. */
+  /* Diff tables scroll within their own box (the blob wrapper already does). */
-  table.blob,
   table.diff {
     display: block;
     overflow-x: auto;

 fn highlighted_code(path: &FsPath, content: &[u8], attr_lang: Option<&str>) -> Markup {
     let highlighted = highlight::highlight(path, content, attr_lang);
     html! {
-        table class="blob" {
+        div class="blob-code" {
-            tbody {
+            table class="blob" {
-                @for (i, line) in highlighted.lines.iter().enumerate() {
+                tbody {
-                    @let n = i + 1;
+                    @for (i, line) in highlighted.lines.iter().enumerate() {
-                    tr id={ "L" (n) } {
+                        @let n = i + 1;
-                        td class="lineno" { a href={ "#L" (n) } { (n) } }
+                        tr id={ "L" (n) } {
-                        td class="code-line" {
+                            td class="lineno" { a href={ "#L" (n) } { (n) } }
-                            @for span in &line.spans {
+                            td class="code-line" {
-                                @match span.class {
+                                @for span in &line.spans {
-                                    Some(class) => { span class=(class) { (span.text) } }
+                                    @match span.class {
-                                    None => { (span.text) }
+                                        Some(class) => { span class=(class) { (span.text) } }
+                                        None => { (span.text) }
+                                    }
+                                }
+                            }
+                        }

 /// Run the bounded content search across visible repos. Returns matches plus
 /// whether the time budget or result cap was hit.
+/// A repo's content matches: its `owner/path` label, its default branch (for
+/// blob links), and the per-file results.
+type RepoMatches = (String, String, Vec<FileResult>);
 async fn content_matches(
     state: &AppState,
     query: &ParsedQuery,
     viewer: Option<&User>,
-) -> AppResult<(Vec<(String, Vec<FileResult>)>, bool, bool)> {
+) -> AppResult<(Vec<RepoMatches>, bool, bool)> {
     let mut repos = visible_repos(state, viewer).await?;
     // Honour a repo: qualifier by filtering the candidate set.
     if let Some(repo_q) = &query.repo {
     let deadline = Instant::now() + Duration::from_secs(state.config.search.timeout_secs.max(1));
     let semaphore = Arc::new(Semaphore::new(state.config.search.concurrency.max(1)));
-    let mut set: JoinSet<Option<(String, Vec<FileResult>)>> = JoinSet::new();
+    let mut set: JoinSet<Option<RepoMatches>> = JoinSet::new();
     for repo in repos {
         let state = state.clone();
         set.spawn(async move {
             let _permit = semaphore.acquire().await.ok()?;
             let owner = owner_name(&state, &repo.owner_id).await;
-            let rev = repo.default_branch.clone();
+            let branch = repo.default_branch.clone();
+            let rev = branch.clone();
             let files = crate::repo::git_read(&state, &repo.id, move |repo| {
                 Ok(search_repo_blocking(repo, &rev, &query))
             })
             .await
             .ok()?;
-            (!files.is_empty()).then(|| (format!("{owner}/{}", repo.path), files))
+            (!files.is_empty()).then(|| (format!("{owner}/{}", repo.path), branch, files))
         });
+    }
+        }
         match tokio::time::timeout(remaining, set.join_next()).await {
             Ok(Some(Ok(Some(entry)))) => {
-                total += entry.1.iter().map(|f| f.lines.len().max(1)).sum::<usize>();
+                total += entry.2.iter().map(|f| f.lines.len().max(1)).sum::<usize>();
                 results.push(entry);
                 if total >= cap {
                     truncated = true;
+    }
+}
-/// Render global content matches, grouped by repo then file.
+/// Render global content matches, grouped by repo then file, each linking into
-fn content_section(content: &[(String, Vec<FileResult>)]) -> Markup {
+/// the blob at the repo's default branch.
+fn content_section(content: &[RepoMatches]) -> Markup {
     html! {
         @if !content.is_empty() {
             section {
                 h2 { "Code" }
-                @for (repo, files) in content {
+                @for (repo, rev, files) in content {
-                    h3 { (repo) }
+                    h3 class="search-repo" { a href={ "/" (repo) } { (repo) } }
+                    @let base = format!("/{repo}/-/blob/{rev}");
                     @for file in files {
-                        (file_result(&format!("/{repo}"), None, file))
+                        (file_result(&base, Some(rev), file))
+                    }
+                }
+            }