hanna/fabrica

feat(web): #n cross-references and closes/fixes on merge

d46dc25 · hanna committed on 2026-07-26

- Issue/PR descriptions and comments now linkify `#123` to the referenced
  issue/PR (markdown::render_with_refs), skipping code spans, tags, and
  word-internal `#`. Links target the issues path; the issue and PR views
  redirect to each other when a number is the other kind, so a `#n` link
  always resolves.
- Merging a PR closes the issues its body references with a GitHub-style
  keyword ("closes #1", "fixes #2", "resolves #3").

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

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

assets/base.css +4 −0

crates/web/src/issues.rs +20 −5

crates/web/src/markdown.rs +90 −2

crates/web/src/pulls.rs +73 −4

   color: var(--fb-accent);
   border-color: var(--fb-accent);
+}
+/* An inline #n issue/PR cross-reference link. */
+.issue-ref {
+  font-weight: 600;
+}
 .repo-tabs a,
 .profile-tabs a,
 .subnav a {

+}
 /// `GET …/-/issues/{n}` — a single issue with comments and controls.
+#[allow(clippy::too_many_lines)] // Cohesive view: header, thread, sidebar.
 pub(crate) async fn view(
     state: &AppState,
     viewer: Option<User>,
     if (kind.is_pull && !ctx.repo.pulls_enabled) || (!kind.is_pull && !ctx.repo.issues_enabled) {
         return Err(AppError::NotFound);
+    }
-    let issue = state
+    let Some(issue) = state
         .store
         .issue_by_number(&ctx.repo.id, number, kind.is_pull)
         .await?
-        .ok_or(AppError::NotFound)?;
+    else {
+        // A `#n` reference may point at the other kind — redirect there.
+        if let Some(other) = state
+            .store
+            .issue_by_number(&ctx.repo.id, number, !kind.is_pull)
+            .await?
+        {
+            let seg = if other.is_pull { "pulls" } else { "issues" };
+            let dest = format!("/{}/{}/-/{seg}/{number}", ctx.owner.username, ctx.repo.path);
+            return Ok(Redirect::to(&dest).into_response());
+        }
+        return Err(AppError::NotFound);
+    };
     let author = username(state, &issue.author_id).await;
     let comments = state.store.list_comments(&issue.id).await?;
     let issue_labels = state.store.issue_labels(&issue.id).await?;
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let csrf = chrome.csrf.clone();
+    let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
     let body = html! {
         (repo_header(state, &ctx, kind.tab, &ctx.repo.default_branch, &branches))
         div class="issue-view" {
             div class="issue-main" {
                 article class="issue-thread" {
                     @let body_action = format!("/issue/{}/edit-body", issue.id);
-                    (comment_card(&author, &issue.body, issue.created_at,
+                    (comment_card(&author, &base, &issue.body, issue.created_at,
                         (can_write || is_author).then_some((body_action.as_str(), csrf.as_str()))))
                     @for (c, cauthor) in &comment_rows {
                         @let editable = can_write || viewer_id.as_deref() == Some(c.author_id.as_str());
                         @let action = format!("/comment/{}/edit", c.id);
-                        (comment_card(cauthor, &c.body, c.created_at,
+                        (comment_card(cauthor, &base, &c.body, c.created_at,
                             editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
                     @if issue.locked() { (locked_note(can_write)) }
 /// issue/PR description.
 pub(crate) fn comment_card(
     author: &str,
+    repo_base: &str,
     body: &str,
     created_at: i64,
     edit: Option<(&str, &str)>,
+                    }
+                }
+            }
-            div class="comment-body markdown" { (markdown::render(body)) }
+            div class="comment-body markdown" { (markdown::render_with_refs(body, repo_base)) }
             @if let Some((action, csrf)) = edit {
                 form class="comment-editor" method="post" action=(action) {
                     input type="hidden" name="_csrf" value=(csrf);

 /// Render `source` markdown to sanitized, syntax-highlighted HTML.
 #[must_use]
 pub fn render(source: &str) -> Markup {
+    PreEscaped(render_html(source))
+}
+/// Like [`render`], but also linkifies `#123` issue/PR references against
+/// `repo_base` (e.g. `/owner/repo`). Used for issue/PR descriptions and comments.
+#[must_use]
+pub fn render_with_refs(source: &str, repo_base: &str) -> Markup {
+    PreEscaped(linkify_refs(&render_html(source), repo_base))
+}
+/// The shared comrak + ammonia pipeline, producing sanitized HTML.
+fn render_html(source: &str) -> String {
     let mut options = comrak::Options::default();
     options.extension.table = true;
     options.extension.strikethrough = true;
     plugins.render.codefence_syntax_highlighter = Some(&adapter);
     let unsafe_html = comrak::markdown_to_html_with_plugins(source, &options, &plugins);
-    let safe = sanitizer().clean(&unsafe_html).to_string();
+    sanitizer().clean(&unsafe_html).to_string()
-    PreEscaped(safe)
+}
+/// Turn `#123` into a link to the issue/PR, but only in ordinary text — never
+/// inside a tag, an attribute, or a `<code>`/`<pre>` block. Runs on already
+/// sanitized HTML, so the injected anchors are trusted. The link targets the
+/// issues path; the issue view redirects to the PR view when the number is a PR.
+fn linkify_refs(html: &str, base: &str) -> String {
+    let bytes = html.as_bytes();
+    // Build as bytes so multibyte UTF-8 is copied verbatim (only ASCII markers
+    // are special-cased).
+    let mut out: Vec<u8> = Vec::with_capacity(html.len() + 32);
+    let mut i = 0;
+    let mut in_tag = false;
+    let mut code_depth: usize = 0;
+    while i < bytes.len() {
+        let c = bytes[i];
+        if in_tag {
+            out.push(c);
+            if c == b'>' {
+                in_tag = false;
+            }
+            i += 1;
+            continue;
+        }
+        if c == b'<' {
+            let rest = &html[i..];
+            if rest.starts_with("<code") || rest.starts_with("<pre") {
+                code_depth += 1;
+            } else if rest.starts_with("</code") || rest.starts_with("</pre") {
+                code_depth = code_depth.saturating_sub(1);
+            }
+            in_tag = true;
+            out.push(b'<');
+            i += 1;
+            continue;
+        }
+        // A `#` that follows a non-alphanumeric boundary and is followed by digits.
+        if code_depth == 0 && c == b'#' && (i == 0 || !bytes[i - 1].is_ascii_alphanumeric()) {
+            let mut j = i + 1;
+            while j < bytes.len() && bytes[j].is_ascii_digit() {
+                j += 1;
+            }
+            if j > i + 1 {
+                let num = &html[i + 1..j];
+                out.extend_from_slice(
+                    format!("<a class=\"issue-ref\" href=\"{base}/-/issues/{num}\">#{num}</a>")
+                        .as_bytes(),
+                );
+                i = j;
+                continue;
+            }
+        }
+        out.push(c);
+        i += 1;
+    }
+    String::from_utf8(out).unwrap_or_else(|_| html.to_string())
+}
 /// The ammonia sanitizer, extended to allow the highlighter's `<span class="hl-*">`
+    }
     #[test]
+    fn linkifies_issue_refs_outside_code() {
+        let html = render_with_refs("see #12 and `#34` here", "/o/r").into_string();
+        assert!(
+            html.contains(r#"<a class="issue-ref" href="/o/r/-/issues/12">#12</a>"#),
+            "plain #12 links: {html}"
+        );
+        // The `#34` inside a code span is left alone.
+        assert!(html.contains("#34</code>"), "code #34 untouched: {html}");
+        assert!(
+            !html.contains("issues/34"),
+            "code #34 must not link: {html}"
+        );
+    }
+    #[test]
+    fn does_not_link_word_hash() {
+        let html = render_with_refs("color abc#5 def", "/o/r").into_string();
+        assert!(!html.contains("issues/5"), "abc#5 is not a ref: {html}");
+    }
+    #[test]
     fn highlights_fenced_code() {
         let html = render("```rust\nfn main() {}\n```").into_string();
         // A keyword span survives sanitizing with its highlight class.

+}
 /// `GET …/-/pulls/{n}` — a pull request: conversation, commits, and diff.
+#[allow(clippy::too_many_lines)] // Cohesive view: header, thread, merge panel, diff.
 pub(crate) async fn view(
     state: &AppState,
     viewer: Option<User>,
     if !ctx.repo.pulls_enabled {
         return Err(AppError::NotFound);
+    }
-    let issue = state
+    let Some(issue) = state
         .store
         .issue_by_number(&ctx.repo.id, number, true)
         .await?
-        .ok_or(AppError::NotFound)?;
+    else {
+        // A `#n` reference to a plain issue lands here — redirect to it.
+        if ctx.repo.issues_enabled
+            && state
+                .store
+                .issue_by_number(&ctx.repo.id, number, false)
+                .await?
+                .is_some()
+        {
+            let dest = format!(
+                "/{}/{}/-/issues/{number}",
+                ctx.owner.username, ctx.repo.path
+            );
+            return Ok(Redirect::to(&dest).into_response());
+        }
+        return Err(AppError::NotFound);
+    };
     let pr = state
         .store
         .pull_by_issue(&issue.id)
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let csrf = chrome.csrf.clone();
+    let repo_base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
     let body = html! {
         (repo_header(state, &ctx, Tab::Pulls, &ctx.repo.default_branch, &branches))
         div class="issue-view" {
             div class="issue-main" {
                 article class="issue-thread" {
                     @let body_action = format!("/issue/{}/edit-body", issue.id);
-                    (comment_card(&author, &issue.body, issue.created_at,
+                    (comment_card(&author, &repo_base, &issue.body, issue.created_at,
                         (can_write || is_author).then_some((body_action.as_str(), csrf.as_str()))))
                     @for (c, cauthor) in &comment_rows {
                         @let editable = can_write || viewer_id.as_deref() == Some(c.author_id.as_str());
                         @let action = format!("/comment/{}/edit", c.id);
-                        (comment_card(cauthor, &c.body, c.created_at,
+                        (comment_card(cauthor, &repo_base, &c.body, c.created_at,
                             editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
                     (merge_panel(&issue, &pr, mergeable, blocked, &csrf))
             .store
             .mark_pull_merged(&issue.id, &user.id, &sha, strategy.as_str())
             .await?;
+        // Close any issues the PR body says it closes ("closes #1", "fixes #2").
+        for number in closing_refs(&issue.body) {
+            if let Some(target) = state.store.issue_by_number(&repo.id, number, false).await?
+                && target.state == model::IssueState::Open
+            {
+                let _ = state
+                    .store
+                    .set_issue_state(&target.id, model::IssueState::Closed)
+                    .await;
+            }
+        }
         Ok::<String, AppError>(issue_url(&state, &repo, &issue).await)
+    }
     .await;
     respond_redirect(result)
+}
+/// Parse GitHub-style closing keywords (`closes #1`, `fixes #2`, `resolves #3`)
+/// from a PR body, returning the referenced issue numbers.
+fn closing_refs(text: &str) -> Vec<i64> {
+    const KEYWORDS: &[&str] = &[
+        "close", "closes", "closed", "fix", "fixes", "fixed", "resolve", "resolves", "resolved",
+    ];
+    let lower = text.to_lowercase();
+    let words: Vec<&str> = lower.split_whitespace().collect();
+    let mut out = Vec::new();
+    for pair in words.windows(2) {
+        if KEYWORDS.contains(&pair[0])
+            && let Some(rest) = pair[1].strip_prefix('#')
+        {
+            let digits: String = rest.chars().take_while(char::is_ascii_digit).collect();
+            if let Ok(n) = digits.parse::<i64>() {
+                out.push(n);
+            }
+        }
+    }
+    out.sort_unstable();
+    out.dedup();
+    out
+}
 /// Run the blocking server-side merge on the blocking pool.
 async fn run_merge(
     state: &AppState,
         other => AppError::from(other),
     })
+}
+#[cfg(test)]
+mod tests {
+    use super::closing_refs;
+    #[test]
+    fn parses_closing_keywords() {
+        assert_eq!(closing_refs("Closes #1 and fixes #2."), vec![1, 2]);
+        assert_eq!(closing_refs("resolves #10"), vec![10]);
+        // No keyword, or a plain mention, does not close.
+        assert!(closing_refs("see #3").is_empty());
+        assert!(closing_refs("closesnt #4").is_empty());
+        // Deduped and sorted.
+        assert_eq!(closing_refs("fix #5 fix #5 close #2"), vec![2, 5]);
+    }
+}