hanna/fabrica

fix(web): title-only header edit, per-comment/body edit, Blocks spacing

5c6c0e0 · hanna committed on 2026-07-25

The header Edit button now edits only the title (/issue/{id}/edit-title). Each
comment header — including the issue/PR description card — gets its own Edit that
posts to /comment/{id}/edit or /issue/{id}/edit-body; the edit form expands to a
full-width row when opened. Split the "Blocked by" and "Blocks" dependency lists
into separate sidebar sections so "Blocks" is properly spaced and styled.

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

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

assets/base.css +8 −0

crates/web/src/issues.rs +68 −31

crates/web/src/lib.rs +2 −1

crates/web/src/pulls.rs +5 −2

crates/web/src/tests.rs +15 −3

 .comment-edit {
   margin-left: auto;
+}
+/* When opened, break onto its own full-width row so the form isn't cramped. */
+.comment-edit[open] {
+  flex-basis: 100%;
+  margin-left: 0;
+  margin-top: 0.4rem;
+}
 .comment-edit > summary {
   font-size: 0.9em;
   color: var(--fb-accent);
   margin-top: 0.5rem;
+}
 .comment-edit textarea {
+  width: 100%;
   font-family: inherit;
+}
 .issue-sub {
 .comment-head {
   display: flex;
   align-items: center;
+  flex-wrap: wrap;
   gap: 0.35rem;
   padding: 0.5rem 0.85rem;
   border-bottom: 1px solid var(--fb-border);

+            }
             div class="issue-main" {
                 article class="issue-thread" {
-                    (comment_card(&author, &issue.body, issue.created_at, None))
+                    @let body_action = format!("/issue/{}/edit-body", issue.id);
+                    (comment_card(&author, &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,
-                            editable.then_some((c.id.as_str(), csrf.as_str()))))
+                            editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
                     @if issue.locked() { (locked_note(can_write)) }
                     @if can_write || (is_author && !issue.locked()) {
 // ---- shared render helpers ----
 /// A single comment card (also used for the issue body). When `edit` is
-/// `Some((comment_id, csrf))`, an inline edit form is offered to the viewer.
+/// `Some((action, csrf))`, the header offers an inline edit form posting to
+/// `action` — `/comment/{id}/edit` for comments, `/issue/{id}/edit-body` for the
+/// issue/PR description.
 pub(crate) fn comment_card(
     author: &str,
     body: &str,
             div class="comment-head muted" {
                 strong { (author) }
                 span { " commented " (crate::activity::fmt_relative(created_at, crate::now_ms())) }
-                @if let Some((id, csrf)) = edit {
+                @if let Some((action, csrf)) = edit {
                     details class="comment-edit" {
                         summary { "Edit" }
-                        form method="post" action=(format!("/comment/{id}/edit")) {
+                        form method="post" action=(action) {
                             input type="hidden" name="_csrf" value=(csrf);
                             textarea name="body" rows="4" required { (body) }
                             button class="btn inline-btn" type="submit" { "Save" }
+    }
+}
-/// The edit-title/description form, revealed by a toggle in the issue header.
+/// The edit-title form, revealed by a toggle in the issue/PR header. (The
+/// description is edited from its own comment card.)
 pub(crate) fn edit_issue_form(issue: &Issue, kind: Kind, csrf: &str) -> Markup {
     html! {
         details class="issue-edit" {
             summary class="btn" { "Edit" }
             div class="card" {
-                form method="post" action=(format!("/issue/{}/edit", issue.id)) {
+                form method="post" action=(format!("/issue/{}/edit-title", issue.id)) {
                     input type="hidden" name="_csrf" value=(csrf);
                     label for="edit-title" { "Title" }
                     input type="text" id="edit-title" name="title" value=(issue.title) required;
-                    label for="edit-body" { "Description" }
+                    button class="btn btn-primary inline-btn" type="submit" { "Save " (kind.noun) " title" }
-                    textarea id="edit-body" name="body" rows="6" { (issue.body) }
-                    button class="btn btn-primary inline-btn" type="submit" { "Save " (kind.noun) }
+                }
+            }
+        }
                     button class="btn inline-btn" type="submit" { "Add" }
+                }
+            }
-            @if !dependents.is_empty() {
+        }
+        @if !dependents.is_empty() {
+            section {
                 h3 { "Blocks" }
                 ul class="dep-list" { @for d in dependents { (row(d, false)) } }
+            }
     respond_redirect(result)
+}
-/// Edit-issue form (title + description).
+/// Edit-title form.
 #[derive(Debug, Deserialize)]
-pub struct EditIssueForm {
+pub struct EditTitleForm {
     /// New title.
     #[serde(default)]
     title: String,
-    /// New markdown description.
-    #[serde(default)]
-    body: String,
     /// CSRF token.
     #[serde(rename = "_csrf")]
     csrf: String,
+}
-/// `POST /issue/{id}/edit` — edit an issue/PR's title and description (Write or
+/// `POST /issue/{id}/edit-title` — edit an issue/PR's title (Write or author).
-/// the author).
+pub async fn edit_title(
-pub async fn edit(
     State(state): State<AppState>,
     MaybeUser(viewer): MaybeUser,
     jar: CookieJar,
     headers: HeaderMap,
     Path(id): Path<String>,
-    Form(form): Form<EditIssueForm>,
+    Form(form): Form<EditTitleForm>,
 ) -> Response {
     if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
         return AppError::Forbidden.into_response();
+    }
     let result = async {
-        let user = viewer.ok_or(AppError::Forbidden)?;
+        let (repo, issue) = edit_target(&state, viewer.as_ref(), &id).await?;
-        let issue = state
-            .store
-            .issue_by_id(&id)
-            .await?
-            .ok_or(AppError::NotFound)?;
-        let (repo, access) = repo_of_issue(&state, Some(&user), &issue).await?;
-        if access < auth::Access::Write && user.id != issue.author_id {
-            return Err(AppError::Forbidden);
-        }
         let title = form.title.trim();
         if title.is_empty() {
             return Err(AppError::BadRequest("A title is required.".to_string()));
+        }
         state
             .store
-            .update_issue(&issue.id, title, form.body.trim())
+            .update_issue(&issue.id, title, &issue.body)
             .await?;
         Ok::<String, AppError>(issue_url(&state, &repo, &issue).await)
+    }
     respond_redirect(result)
+}
+/// `POST /issue/{id}/edit-body` — edit an issue/PR's description (Write or
+/// author). Reuses [`CommentForm`] (the `body` field).
+pub async fn edit_body(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path(id): Path<String>,
+    Form(form): Form<CommentForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    let result = async {
+        let (repo, issue) = edit_target(&state, viewer.as_ref(), &id).await?;
+        state
+            .store
+            .update_issue(&issue.id, &issue.title, form.body.trim())
+            .await?;
+        Ok::<String, AppError>(issue_url(&state, &repo, &issue).await)
+    }
+    .await;
+    respond_redirect(result)
+}
+/// Resolve the issue and authorize the viewer to edit it (Write or the author).
+async fn edit_target(
+    state: &AppState,
+    viewer: Option<&User>,
+    id: &str,
+) -> AppResult<(model::Repo, Issue)> {
+    let user = viewer.ok_or(AppError::Forbidden)?;
+    let issue = state
+        .store
+        .issue_by_id(id)
+        .await?
+        .ok_or(AppError::NotFound)?;
+    let (repo, access) = repo_of_issue(state, Some(user), &issue).await?;
+    if access < auth::Access::Write && user.id != issue.author_id {
+        return Err(AppError::Forbidden);
+    }
+    Ok((repo, issue))
+}
 /// `POST /comment/{id}/edit` — edit a comment (Write or the comment's author).
 pub async fn comment_edit(
     State(state): State<AppState>,

         .route("/issue/{id}/labels", post(issues::set_labels))
         .route("/issue/{id}/deps/add", post(issues::deps_add))
         .route("/issue/{id}/deps/remove", post(issues::deps_remove))
-        .route("/issue/{id}/edit", post(issues::edit))
+        .route("/issue/{id}/edit-title", post(issues::edit_title))
+        .route("/issue/{id}/edit-body", post(issues::edit_body))
         .route("/issue/{id}/lock", post(issues::set_lock))
         .route("/comment/{id}/edit", post(issues::comment_edit))
         .route("/pull-new/{repo_id}", post(pulls::create))

+            }
             div class="issue-main" {
                 article class="issue-thread" {
-                    (comment_card(&author, &issue.body, issue.created_at, None))
+                    @let body_action = format!("/issue/{}/edit-body", issue.id);
+                    (comment_card(&author, &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,
-                            editable.then_some((c.id.as_str(), csrf.as_str()))))
+                            editable.then_some((action.as_str(), csrf.as_str()))))
+                    }
                     (merge_panel(&issue, &pr, mergeable, blocked, &csrf))
                     @if issue.locked() { (locked_note(can_write)) }

+        }
     };
-    // Edit the issue title + body.
+    // Edit the issue title (title only; body preserved).
     let res = post(
-        format!("/issue/{}/edit", issue.id),
+        format!("/issue/{}/edit-title", issue.id),
-        format!("title=Fixed+title&body=new+body&_csrf={token}"),
+        format!("title=Fixed+title&_csrf={token}"),
         cookie.clone(),
+    )
     .await;
     assert_eq!(res.status(), StatusCode::SEE_OTHER);
     let updated = state.store.issue_by_id(&issue.id).await.unwrap().unwrap();
     assert_eq!(updated.title, "Fixed title");
+    assert_eq!(updated.body, "body", "body untouched by title edit");
+    // Edit the issue description via its own card.
+    let res = post(
+        format!("/issue/{}/edit-body", issue.id),
+        format!("body=new+body&_csrf={token}"),
+        cookie.clone(),
+    )
+    .await;
+    assert_eq!(res.status(), StatusCode::SEE_OTHER);
+    let updated = state.store.issue_by_id(&issue.id).await.unwrap().unwrap();
+    assert_eq!(updated.title, "Fixed title", "title untouched by body edit");
     assert_eq!(updated.body, "new body");
     // Edit the comment.