Commit `d3a69034f3`

d3a69034f33047d9abb16b15de426cb60f0028d8

parent: 76cfe39723

Verified · cmc

cmc <hello@cleberg.net> · 2026-09-30 02:20 UTC

Link #N, !N and owner/name#N in bodies

Issue and MR bodies and comments link references the way the web's
autolink does: # is an issue, ! a merge request, nothing inside code
spans, fenced code or existing links. Taps open the issue or MR in-app.

Layout: unified · split

gitbay/Views/Issues/IssueView.swift +3 −2

                 if let body = issue.body, !body.isEmpty {
                     Section {
-                        FormattedBodyView(text: body, format: issue.bodyFormat)
+                        FormattedBodyView(text: body, format: issue.bodyFormat, repo: model.repoPath)
                             .padding(.vertical, 4)
                     }
                 }
             }
         }
         .overlay { LoadStateOverlay(state: model.state) }
+        .referenceNavigation()
         .scrollDismissesKeyboard(.interactively)
         .navigationTitle("#\(model.number)")
         .navigationBarTitleDisplayMode(.inline)
                             .font(.gbSans(.caption))
                             .foregroundStyle(.tertiary)
                     }
-                    FormattedBodyView(text: comment.body, format: comment.bodyFormat)
+                    FormattedBodyView(text: comment.body, format: comment.bodyFormat, repo: model.repoPath)
                         .font(.gbSans(.subheadline))
                 }
                 .padding(.vertical, 2)

gitbay/Views/MRs/MRView.swift +3 −2

                 if let body = mr.body, !body.isEmpty {
                     Section {
-                        FormattedBodyView(text: body, format: mr.bodyFormat)
+                        FormattedBodyView(text: body, format: mr.bodyFormat, repo: model.repoPath)
                             .padding(.vertical, 4)
                     }
                 }
             }
         }
         .overlay { LoadStateOverlay(state: model.state) }
+        .referenceNavigation()
         .scrollDismissesKeyboard(.interactively)
         .navigationTitle("!\(model.number)")
         .navigationBarTitleDisplayMode(.inline)
                             .font(.gbSans(.caption))
                             .foregroundStyle(.tertiary)
                     }
-                    FormattedBodyView(text: comment.body, format: comment.bodyFormat)
+                    FormattedBodyView(text: comment.body, format: comment.bodyFormat, repo: model.repoPath)
                         .font(.gbSans(.subheadline))
                 }
                 .padding(.vertical, 2)

gitbay/Views/Repos/FormattedBodyView.swift +4 −1

 struct FormattedBodyView: View {
     let text: String
     var format: String?
+    /// The repository `#N` and `!N` refer to; nil links no references.
+    /// The links open through `referenceNavigation()`.
+    var repo: String?
     @Environment(\.colorScheme) private var colorScheme
                 keywords: OrgKeywordStyle(todo: .gbOK, done: .gbDone)
             )
         } else {
-            MarkdownView(markdown: text)
+            MarkdownView(markdown: text, referenceRepo: repo)
         }
     }
 }

gitbay/Views/Repos/MarkdownView.swift +36 −10

     /// Repository context for resolving relative link targets. Nil leaves them as authored,
     /// which is right for a body with no file to be relative to.
     var linkOptions: OrgRenderOptions?
+    /// The repository `#N` and `!N` refer to. Nil links no references.
+    var referenceRepo: String?
     var body: some View {
         VStack(alignment: .leading, spacing: 12) {
     private func blockView(_ block: Block) -> some View {
         switch block {
         case .heading(let level, let text):
-            Self.inline(text, codeStyle: headingCodeStyle(level), linkOptions: linkOptions)
+            Self.inline(text, codeStyle: headingCodeStyle(level), linkOptions: linkOptions,
+                        referenceRepo: referenceRepo)
                 .font(headingFont(level))
                 .padding(.top, level <= 2 ? 8 : 4)
         case .code(let code):
                 RoundedRectangle(cornerRadius: 2)
                     .fill(.tertiary)
                     .frame(width: 3)
-                Self.inline(text, linkOptions: linkOptions).foregroundStyle(.secondary)
+                Self.inline(text, linkOptions: linkOptions, referenceRepo: referenceRepo).foregroundStyle(.secondary)
             }
             .fixedSize(horizontal: false, vertical: true)
         case .bullet(let items):
                 ForEach(Array(items.enumerated()), id: \.offset) { _, item in
                     HStack(alignment: .firstTextBaseline, spacing: 8) {
                         Text("•")
-                        Self.inline(item, linkOptions: linkOptions)
+                        Self.inline(item, linkOptions: linkOptions, referenceRepo: referenceRepo)
                             .fixedSize(horizontal: false, vertical: true)
                     }
                 }
                 ForEach(Array(items.enumerated()), id: \.offset) { index, item in
                     HStack(alignment: .firstTextBaseline, spacing: 8) {
                         Text("\(index + 1).").monospacedDigit()
-                        Self.inline(item, linkOptions: linkOptions)
+                        Self.inline(item, linkOptions: linkOptions, referenceRepo: referenceRepo)
                             .fixedSize(horizontal: false, vertical: true)
                     }
                 }
             }
         case .table(let table):
-            MarkdownTableView(table: table, linkOptions: linkOptions)
+            MarkdownTableView(table: table, linkOptions: linkOptions, referenceRepo: referenceRepo)
         case .rule:
             Divider()
         case .paragraph(let text):
-            Self.inline(text, linkOptions: linkOptions)
+            Self.inline(text, linkOptions: linkOptions, referenceRepo: referenceRepo)
         }
     }
     static func inline(
         _ text: String,
         codeStyle: Font.TextStyle = .subheadline,
-        linkOptions: OrgRenderOptions? = nil
+        linkOptions: OrgRenderOptions? = nil,
+        referenceRepo: String? = nil
     ) -> Text {
-        Text(attributed(text, codeStyle: codeStyle, linkOptions: linkOptions))
+        Text(attributed(text, codeStyle: codeStyle, linkOptions: linkOptions,
+                        referenceRepo: referenceRepo))
     }
     static func attributed(
         _ text: String,
         codeStyle: Font.TextStyle = .subheadline,
-        linkOptions: OrgRenderOptions? = nil
+        linkOptions: OrgRenderOptions? = nil,
+        referenceRepo: String? = nil
     ) -> AttributedString {
         guard var attributed = try? AttributedString(
             markdown: text,
                 attributed[range].link = url
             }
         }
+        if let referenceRepo {
+            linkReferences(in: &attributed, repo: referenceRepo)
+        }
         return attributed
     }
+    /// Links `#N`, `!N` and `owner/name#N` outside code spans and
+    /// existing links. Fenced code never reaches here.
+    private static func linkReferences(in attributed: inout AttributedString, repo: String) {
+        for reference in bodyReferences(in: String(attributed.characters), repo: repo) {
+            let lower = attributed.characters.index(attributed.startIndex,
+                                                    offsetBy: reference.range.lowerBound)
+            let upper = attributed.characters.index(lower, offsetBy: reference.range.count)
+            let skip = attributed[lower..<upper].runs.contains {
+                $0.link != nil || $0.inlinePresentationIntent?.contains(.code) == true
+            }
+            if !skip, let url = referenceURL(reference.destination) {
+                attributed[lower..<upper].link = url
+            }
+        }
+    }
     private func headingFont(_ level: Int) -> Font {
         switch level {
         case 1: .title2.bold()
 private struct MarkdownTableView: View {
     let table: MarkdownView.Table
     var linkOptions: OrgRenderOptions?
+    var referenceRepo: String?
     private static let spacing: CGFloat = 14
     private func cell(_ text: String, _ column: Int) -> some View {
         let alignment = table.alignments[column]
-        return MarkdownView.inline(text, linkOptions: linkOptions)
+        return MarkdownView.inline(text, linkOptions: linkOptions, referenceRepo: referenceRepo)
             .multilineTextAlignment(Self.textAlignment(alignment))
             .frame(width: cellWidth, alignment: Self.frameAlignment(alignment))
             .fixedSize(horizontal: cellWidth == nil, vertical: true)

gitbay/Views/Shared/BodyReferences.swift added +96

@@ -0,0 +1,96 @@
	1	import Foundation
	2	import SwiftUI
	3
	4	/// A `#N`, `!N`, `owner/name#N` or `owner/name!N` in a body, as the web's
	5	/// autolink package reads them: `#` is an issue, `!` a merge request.
	6	/// `range` counts characters.
	7	nonisolated struct BodyReference: Equatable, Sendable {
	8	let range: Range<Int>
	9	let destination: NotificationDestination
	10	}
	11
	12	/// Every reference in `text`, bare ones resolved against `repo`. The
	13	/// patterns are the web's: a bare reference needs the start of the text,
	14	/// whitespace or an opening bracket before it, and a cross-repository one
	15	/// wins where the two overlap. Unlike the web, the target is not checked
	16	/// to exist.
	17	nonisolated func bodyReferences(in text: String, repo: String) -> [BodyReference] {
	18	let cross = /([a-z0-9][a-z0-9._-])\/([a-z0-9][a-z0-9._-])([#!])([0-9]+)/
	19	let bare = /(^\|[\s(\[{])([#!])([0-9]+)(?![0-9A-Za-z_])/
	20
	21	func offsets(_ range: Range<String.Index>) -> Range<Int> {
	22	let lower = text.distance(from: text.startIndex, to: range.lowerBound)
	23	return lower..<(lower + text.distance(from: range.lowerBound, to: range.upperBound))
	24	}
	25	func destination(_ repo: String, _ kind: Substring, _ number: Substring) -> NotificationDestination? {
	26	guard let n = Int64(number) else { return nil }
	27	return kind == "#" ? .issue(repo: repo, number: n) : .mr(repo: repo, number: n)
	28	}
	29
	30	var found: [BodyReference] = []
	31	for match in text.matches(of: cross) {
	32	if let d = destination("\(match.1)/\(match.2)", match.3, match.4) {
	33	found.append(BodyReference(range: offsets(match.range), destination: d))
	34	}
	35	}
	36	for match in text.matches(of: bare) {
	37	let range = offsets(match.2.startIndex..<match.3.endIndex)
	38	guard !found.contains(where: { $0.range.overlaps(range) }),
	39	let d = destination(repo, match.2, match.3) else { continue }
	40	found.append(BodyReference(range: range, destination: d))
	41	}
	42	return found.sorted { $0.range.lowerBound < $1.range.lowerBound }
	43	}
	44
	45	nonisolated private let referenceScheme = "gitbay-ref"
	46
	47	/// The link a reference carries: the web path under an app-only scheme,
	48	/// so only `referenceNavigation()` acts on it.
	49	nonisolated func referenceURL(_ destination: NotificationDestination) -> URL? {
	50	let path = switch destination {
	51	case .issue(let repo, let number): "\(repo)/issues/\(number)"
	52	case .mr(let repo, let number): "\(repo)/mrs/\(number)"
	53	case .build(let repo, let number): "\(repo)/builds/\(number)"
	54	}
	55	return URL(string: "\(referenceScheme):\(path)")
	56	}
	57
	58	nonisolated func referenceDestination(_ url: URL) -> NotificationDestination? {
	59	guard url.scheme == referenceScheme else { return nil }
	60	return notificationDestination(forPath: String(url.absoluteString.dropFirst(referenceScheme.count + 1)))
	61	}
	62
	63	extension View {
	64	/// Opens reference links from a body in-app. Attach outside the
	65	/// `List`: a navigation destination inside a lazy container is ignored.
	66	func referenceNavigation() -> some View {
	67	modifier(ReferenceNavigation())
	68	}
	69	}
	70
	71	private struct ReferenceNavigation: ViewModifier {
	72
	73	@Environment(SessionStore.self) private var session
	74	@State private var target: NotificationDestination?
	75
	76	func body(content: Content) -> some View {
	77	content
	78	.environment(\.openURL, OpenURLAction { url in
	79	guard let destination = referenceDestination(url) else { return .systemAction }
	80	target = destination
	81	return .handled
	82	})
	83	.navigationDestination(item: $target) { destination in
	84	if let client = session.client {
	85	switch destination {
	86	case .issue(let repo, let number):
	87	IssueView(client: client, repo: repo, number: number)
	88	case .mr(let repo, let number):
	89	MRView(client: client, repo: repo, number: number)
	90	case .build(let repo, let number):
	91	BuildDetailView(client: client, repo: repo, number: number)
	92	}
	93	}
	94	}
	95	}
	96	}

gitbayTests/BodyReferenceTests.swift added +91

@@ -0,0 +1,91 @@
	1	import Foundation
	2	import Testing
	3	@testable import gitbay
	4
	5	/// `#N`, `!N`, `owner/name#N` and `owner/name!N`, found the way the web's
	6	/// autolink package finds them: `#` is an issue, `!` a merge request.
	7	struct BodyReferenceTests {
	8
	9	private func refs(_ text: String, repo: String = "krz/gitbay") -> [BodyReference] {
	10	bodyReferences(in: text, repo: repo)
	11	}
	12
	13	@Test func bareHashIsAnIssueInThisRepo() {
	14	#expect(refs("see #12 please") == [
	15	BodyReference(range: 4..<7, destination: .issue(repo: "krz/gitbay", number: 12)),
	16	])
	17	}
	18
	19	@Test func bangIsAMergeRequest() {
	20	#expect(refs("!3") == [
	21	BodyReference(range: 0..<2, destination: .mr(repo: "krz/gitbay", number: 3)),
	22	])
	23	}
	24
	25	@Test func crossRepoReferenceNamesItsRepo() {
	26	#expect(refs("fixed in krz/solar#7 and krz/solar!8.") == [
	27	BodyReference(range: 9..<20, destination: .issue(repo: "krz/solar", number: 7)),
	28	BodyReference(range: 25..<36, destination: .mr(repo: "krz/solar", number: 8)),
	29	])
	30	}
	31
	32	@Test func aBareReferenceNeedsABoundaryBefore() {
	33	#expect(refs("a1b2#3").isEmpty)
	34	#expect(refs("(#4)").map(\.range) == [1..<3])
	35	#expect(refs("[#5]").map(\.range) == [1..<3])
	36	#expect(refs("line\n#6").map(\.range) == [5..<7])
	37	}
	38
	39	@Test func digitsMustEndAtAWordBoundary() {
	40	#expect(refs("#12abc").isEmpty)
	41	#expect(refs("#12, #13").count == 2)
	42	}
	43
	44	@Test func aCrossReferenceIsNotAlsoReadAsABareOne() {
	45	#expect(refs("krz/solar#7").count == 1)
	46	}
	47
	48	@Test func offsetsCountCharactersNotBytes() {
	49	#expect(refs("é #1").map(\.range) == [2..<4])
	50	}
	51
	52	@Test func theURLRoundTrips() throws {
	53	for destination in [NotificationDestination.issue(repo: "krz/gitbay", number: 12),
	54	.mr(repo: "krz/solar", number: 3)] {
	55	let url = try #require(referenceURL(destination))
	56	#expect(referenceDestination(url) == destination)
	57	}
	58	#expect(referenceDestination(URL(string: "https://gitbay.org/krz/gitbay/issues/1")!) == nil)
	59	}
	60	}
	61
	62	@MainActor
	63	struct BodyReferenceMarkdownTests {
	64
	65	private func links(_ markdown: String) -> [String: URL] {
	66	let attributed = MarkdownView.attributed(markdown, referenceRepo: "krz/gitbay")
	67	var found: [String: URL] = [:]
	68	for run in attributed.runs {
	69	if let link = run.link {
	70	found[String(attributed[run.range].characters)] = link
	71	}
	72	}
	73	return found
	74	}
	75
	76	@Test func referencesBecomeLinks() {
	77	let found = links("closes #12, see krz/solar!3")
	78	#expect(found["#12"] == referenceURL(.issue(repo: "krz/gitbay", number: 12)))
	79	#expect(found["krz/solar!3"] == referenceURL(.mr(repo: "krz/solar", number: 3)))
	80	}
	81
	82	@Test func codeSpansAndExistingLinksAreLeftAlone() {
	83	let found = links("`#12` and [#13](https://example.com)")
	84	#expect(found.count == 1)
	85	#expect(found["#13"] == URL(string: "https://example.com"))
	86	}
	87
	88	@Test func noRepoMeansNoReferenceLinks() {
	89	#expect(MarkdownView.attributed("#12").runs.allSatisfy { $0.link == nil })
	90	}
	91	}

Commit d3a69034f3

Commit `d3a69034f3`