Commit `3e71822629`

3e718226294cbc34afc3a47656da00baf5c0ae08

parent: 1dadf31dc2

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-14 05:18 UTC

Suggestions: the block follows the range; renamed files; one copy

Moving the start of the range rebuilds an untouched suggestion to cover
it, where it used to keep the tapped line alone and replace the whole
range with it. A removed line in a renamed file sends the new name, the
one the server's diff lists. The thread's comment leaves out the block
it draws above, the marker column scales with the text, and the sheet
shows only its own send's error.

Ref #23

Layout: unified · split

gitbay/MRs/DiffCommentDraft.swift +11 −1

     init?(file: UnifiedDiff.File, hunk: UnifiedDiff.Hunk, line target: UnifiedDiff.Line) {
         let old = target.kind == .deletion
         guard let number = old ? target.oldNumber : target.newNumber else { return nil }
-        self.path = old ? file.oldPath : file.newPath
+        // The server checks --path against the diff's file names, which
+        // list a rename under its new name only, on either side.
+        self.path = file.displayPath
         self.old = old
         self.line = number
         var lines: [(Int, String)] = []
         let text = candidates.filter { $0.number >= startLine }.map(\.text)
         return "```suggestion\n" + text.map { $0 + "\n" }.joined() + "```\n"
     }
+    /// The body after the range's start moves from `old` to `new`: an
+    /// untouched suggestion is rebuilt to cover the new range, since
+    /// sending the old one would replace the whole range with fewer
+    /// lines. Text the user changed is theirs and stays.
+    func rebuilt(_ text: String, from old: Int, to new: Int) -> String {
+        text == suggestion(from: old) ? suggestion(from: new) : text
+    }
 }

gitbay/MRs/Suggestion.swift +10

	@@ -33,4 +33,14 @@ nonisolated struct Suggestion: Decodable, Sendable, Hashable {
33	if lines.last == "" { lines.removeLast() }	33	if lines.last == "" { lines.removeLast() }
34	return lines	34	return lines
35	}	35	}
		36
		37	/// A comment's text without its ```suggestion block, which the thread
		38	/// draws as replaced and proposed lines instead.
		39	static func withoutBlock(_ body: String) -> String {
		40	guard let start = body.range(of: "```suggestion") else { return body }
		41	let afterOpen = body[start.upperBound...]
		42	guard let close = afterOpen.range(of: "```") else { return body }
		43	let rest = body[..<start.lowerBound] + body[close.upperBound...]
		44	return rest.trimmingCharacters(in: .whitespacesAndNewlines)
		45	}
36	}	46	}

gitbay/Views/MRs/DiffCommentSheet.swift +10 −2

     @State private var startLine: Int
     @State private var text: String
+    @State private var sent = false
     @Environment(\.dismiss) private var dismiss
     init(draft: DiffCommentDraft, model: MRDetailViewModel, suggesting: Bool) {
                             Text("From line \(startLine)")
                                 .font(.gbSans(.subheadline))
                         }
+                        .onChange(of: startLine) { old, new in
+                            text = draft.rebuilt(text, from: old, to: new)
+                        }
                         .accessibilityIdentifier("diff-comment-start")
                     }
                 }
                         Text("A suggestion replaces the lines in its range with what the block holds. An empty block deletes them.")
                     }
                 }
-                if let error = model.actionError {
+                // Only this sheet's own send: an error left from an earlier
+                // action on the screen is not this comment's.
+                if sent, let error = model.actionError {
                     Section { GBNotice(error) }
                 }
             }
                         ProgressView()
                     } else {
                         Button("Send") {
+                            sent = true
                             Task {
                                 if await model.diffComment(draft, startLine: startLine, body: text) {
                                     dismiss()
     let suggestion: Suggestion
     let thread: ReviewThread
     let model: MRDetailViewModel
+    @ScaledMetric(relativeTo: .caption2) private var markerWidth: CGFloat = 14
     var body: some View {
         VStack(alignment: .leading, spacing: 6) {
     private func row(_ marker: String, _ text: String, _ markerColor: Color, _ background: Color) -> some View {
         HStack(spacing: 0) {
             Text(marker)
-                .frame(width: 14)
+                .frame(width: markerWidth)
                 .foregroundStyle(markerColor)
             Text(text.isEmpty ? " " : text)
             Spacer(minLength: 0)

gitbay/Views/MRs/MRView.swift +4 −1

                             .foregroundStyle(.tertiary)
                     }
                     // Review comments carry no format; the web renders them as Markdown.
-                    FormattedBodyView(text: comment.body, repo: model.repoPath)
+                    // The thread's first comment holds its suggestion, drawn above.
+                    FormattedBodyView(text: thread.suggestion != nil && comment.id == thread.comments.first?.id
+                                        ? Suggestion.withoutBlock(comment.body) : comment.body,
+                                      repo: model.repoPath)
                         .font(.gbSans(.subheadline))
                 }
             }

gitbayTests/SuggestionTests.swift +41

	@@ -92,6 +92,47 @@ struct DiffCommentDraftTests {
92	}	92	}
93	}	93	}
94		94
		95	struct SuggestionReviewFixTests {
		96
		97	/// The server checks --path against the diff's names, which list a
		98	/// renamed file under its new name only, so both sides send it.
		99	@Test func aRemovedLineInARenamedFileSendsTheNewPath() throws {
		100	let diff = UnifiedDiff.parse("""
		101	diff --git a/old.go b/new.go
		102	--- a/old.go
		103	+++ b/new.go
		104	@@ -1,2 +1,2 @@
		105	-a
		106	+b
		107	c
		108	""")
		109	let file = try #require(diff.files.first)
		110	let hunk = try #require(file.hunks.first)
		111	let removed = try #require(hunk.lines.first { $0.kind == .deletion })
		112	#expect(DiffCommentDraft(file: file, hunk: hunk, line: removed)?.path == "new.go")
		113	}
		114
		115	/// Moving the start of the range rebuilds an untouched suggestion so it
		116	/// covers the range, and leaves an edited one alone.
		117	@Test func movingTheRangeStartRebuildsAnUntouchedSuggestion() throws {
		118	let (file, hunk) = try hunk()
		119	let target = try #require(hunk.lines.first { $0.newNumber == 12 && $0.kind == .context })
		120	let draft = try #require(DiffCommentDraft(file: file, hunk: hunk, line: target))
		121	let untouched = draft.suggestion(from: 12)
		122
		123	#expect(draft.rebuilt(untouched, from: 12, to: 11) == draft.suggestion(from: 11))
		124	#expect(draft.rebuilt("my own words", from: 12, to: 11) == "my own words")
		125	}
		126
		127	/// The thread draws the suggestion as replaced and proposed lines, so
		128	/// the comment shows the rest of its text without the block.
		129	@Test func theBlockIsLeftOutOfTheCommentShownBesideTheSuggestion() {
		130	#expect(Suggestion.withoutBlock("Say who.\n```suggestion\n return x\n```\n") == "Say who.")
		131	#expect(Suggestion.withoutBlock("```suggestion\n```\n") == "")
		132	#expect(Suggestion.withoutBlock("no block here") == "no block here")
		133	}
		134	}
		135
95	@MainActor	136	@MainActor
96	struct SuggestionViewModelTests {	137	struct SuggestionViewModelTests {
97		138

Commit 3e71822629

Commit `3e71822629`