Commit `c108ce3805`

c108ce38051dee4be3c4aed9aed7383c4478f345

parent: 215138b9ca

Unsigned

cmc <hello@cleberg.net> · 2026-09-30 03:49 UTC

Fix push order, list tops, build jump labels, More pill borders (!148)

- Push order: `navigationDestination(item:)` pushes put later value-link pushes underneath (repo → Builds → a build showed the list; Back showed the build). All five tab stacks own a `NavigationPath`; RepoView (strip, More, owner, settings, fork), the created-issue push and body reference links append via the new `pushRoute` environment value. No `navigationDestination(item:)` remains.
- Segmented-filter lists: picker in its own section so the rows' section keeps rounded top corners (issues, MRs, milestones, notifications, explore search, admin users).
- Build detail: labelled "Jump to failure" / "Jump to end" buttons under the header; iOS 26 rendered the toolbar versions icon-only.
- Repository More pills: border removed.

573 unit tests, Release build, UI target compiles. Checked in stub-hosted snapshots (issues list, failed build, repo page); push order not exercised by a test.

Layout: unified · split

gitbay/ContentView.swift +15 −3

     @State private var selectedTab = Tabs.dashboard
     @State private var dashboardPath = NavigationPath()
     @State private var repoPath = NavigationPath()
+    @State private var feedPath = NavigationPath()
+    @State private var explorePath = NavigationPath()
+    @State private var profilePath = NavigationPath()
     @State private var unread = 0
     /// whoami's admin flag, read on the My Profile tab, decides whether
                             DashboardView(client: client, unread: $unread)
                                 .navigationDestinations(client: client)
                         }
+                        .pushesRoutes(into: $dashboardPath)
                     }
                 }
                 .badge(unread)
                 Tab("Feed", systemImage: "bolt", value: Tabs.feed) {
-                    NavigationStack {
+                    NavigationStack(path: $feedPath) {
                         FeedView(client: client)
                             .navigationDestinations(client: client)
                     }
+                    .pushesRoutes(into: $feedPath)
                 }
                 Tab("Repositories", systemImage: "books.vertical", value: Tabs.repositories) {
                     if sizeClass == .regular {
                             RepoListView(client: client)
                                 .navigationDestinations(client: client)
                         }
+                        .pushesRoutes(into: $repoPath)
                     }
                 }
                 Tab("Explore", systemImage: "safari", value: Tabs.explore) {
-                    NavigationStack {
+                    NavigationStack(path: $explorePath) {
                         ExploreView(client: client)
                             .navigationDestinations(client: client)
                     }
+                    .pushesRoutes(into: $explorePath)
                 }
                 Tab("My Profile", systemImage: "person.crop.circle", value: Tabs.profile) {
-                    NavigationStack {
+                    NavigationStack(path: $profilePath) {
                         ProfileView(client: client, name: account.username,
                                     title: "My Profile")
                             .toolbar { AccountMenu(isAdmin: isAdmin) }
                             }
                             .navigationDestinations(client: client)
                     }
+                    .pushesRoutes(into: $profilePath)
                 }
             }
             .id(account.id) // a fresh tab bar and stacks per account
         if pathAccount != account.id {
             dashboardPath = NavigationPath()
             repoPath = NavigationPath()
+            feedPath = NavigationPath()
+            explorePath = NavigationPath()
+            profilePath = NavigationPath()
             selectedTab = .dashboard
             pathAccount = account.id
         }
                 }
                 .navigationDestinations(client: client)
             }
+            .pushesRoutes(into: $path)
         }
     }
 }

gitbay/Views/Account/NotificationsView.swift +8 −6

     var body: some View {
         List {
-            Picker("Filter", selection: Bindable(model).showAll) {
+            Section {
-                Text("Unread").tag(false)
+                Picker("Filter", selection: Bindable(model).showAll) {
-                Text("All").tag(true)
+                    Text("Unread").tag(false)
+                    Text("All").tag(true)
+                }
+                .pickerStyle(.segmented)
+                .listRowBackground(Color.clear)
+                .listRowInsets(EdgeInsets())
             }
-            .pickerStyle(.segmented)
-            .listRowBackground(Color.clear)
-            .listRowInsets(EdgeInsets())
             if let actionError = model.actionError {
                 Section { GBNotice(actionError) }

gitbay/Views/Admin/AdminUsersView.swift +9 −7

     var body: some View {
         List {
-            Picker("State", selection: Bindable(model).filter) {
+            Section {
-                ForEach(AdminUserFilter.allCases) { filter in
+                Picker("State", selection: Bindable(model).filter) {
-                    Text(filter.label).tag(filter)
+                    ForEach(AdminUserFilter.allCases) { filter in
+                        Text(filter.label).tag(filter)
+                    }
                 }
+                .pickerStyle(.segmented)
+                .listRowBackground(Color.clear)
+                .listRowInsets(EdgeInsets())
+                .accessibilityIdentifier("admin-user-filter")
             }
-            .pickerStyle(.segmented)
-            .listRowBackground(Color.clear)
-            .listRowInsets(EdgeInsets())
-            .accessibilityIdentifier("admin-user-filter")
             if let error = model.actionError {
                 Section {

gitbay/Views/Builds/BuildDetailView.swift +24 −14

                             .padding(.vertical, 8)
                     }
                     header(detail.build)
+                    if !detail.log.isEmpty {
+                        jumpBar(failed: detail.lines.failed != nil)
+                    }
                     Divider()
                     log(detail)
                 }
         .navigationBarTitleDisplayMode(.inline)
         .searchable(text: $query, prompt: "Filter log lines")
         .toolbar {
-            ToolbarItemGroup(placement: .topBarTrailing) {
-                if let detail = model.state.value, !detail.log.isEmpty {
-                    if detail.lines.failed != nil {
-                        Button("Jump to failure", systemImage: "exclamationmark.triangle") {
-                            jump = .failure
-                        }
-                        .accessibilityIdentifier("build-jump-failure")
-                    }
-                    Button("Jump to end", systemImage: "arrow.down.to.line") {
-                        jump = .end
-                    }
-                    .accessibilityIdentifier("build-jump-end")
-                }
-            }
             ToolbarItem(placement: .topBarTrailing) {
                 if model.isCancellable {
                     if model.working {
         }
     }
+    private func jumpBar(failed: Bool) -> some View {
+        HStack(spacing: 20) {
+            if failed {
+                Button("Jump to failure", systemImage: "exclamationmark.triangle") {
+                    jump = .failure
+                }
+                .accessibilityIdentifier("build-jump-failure")
+            }
+            Button("Jump to end", systemImage: "arrow.down.to.line") {
+                jump = .end
+            }
+            .accessibilityIdentifier("build-jump-end")
+            Spacer()
+        }
+        .font(.gbSans(.caption))
+        .foregroundStyle(Color.gbAccent)
+        .buttonStyle(.borderless)
+        .padding(.horizontal, 16)
+        .padding(.bottom, 10)
+    }
     private func header(_ build: Build) -> some View {
         VStack(alignment: .leading, spacing: 6) {
             HStack(spacing: 8) {

gitbay/Views/Discovery/ExploreView.swift +8 −6

     var body: some View {
         List {
             if search.isSearching {
-                Picker("Kind", selection: Bindable(search).kind) {
+                Section {
-                    ForEach(SearchKind.allCases) { kind in
+                    Picker("Kind", selection: Bindable(search).kind) {
-                        Text(kind.label).tag(kind)
+                        ForEach(SearchKind.allCases) { kind in
+                            Text(kind.label).tag(kind)
+                        }
                     }
+                    .pickerStyle(.segmented)
+                    .listRowBackground(Color.clear)
+                    .listRowInsets(EdgeInsets())
                 }
-                .pickerStyle(.segmented)
-                .listRowBackground(Color.clear)
-                .listRowInsets(EdgeInsets())
                 ForEach(search.state.value ?? []) { result in
                     searchRow(for: result)

gitbay/Views/Issues/IssueListView.swift +10 −11

     @State private var draftTitle = ""
     @State private var draftBody = ""
     @State private var draftFormat = "md"
-    @State private var createdIssue: Int64?
+    @Environment(\.pushRoute) private var pushRoute
     private let client: GitbayClient
     var body: some View {
         List {
-            Picker("State", selection: Bindable(model).filter.state) {
+            Section {
-                ForEach(IssueFilter.State.allCases) { filter in
+                Picker("State", selection: Bindable(model).filter.state) {
-                    Text(filter.label).tag(filter)
+                    ForEach(IssueFilter.State.allCases) { filter in
+                        Text(filter.label).tag(filter)
+                    }
                 }
+                .pickerStyle(.segmented)
+                .listRowBackground(Color.clear)
+                .listRowInsets(EdgeInsets())
             }
-            .pickerStyle(.segmented)
-            .listRowBackground(Color.clear)
-            .listRowInsets(EdgeInsets())
             ForEach(model.state.value ?? []) { issue in
                 NavigationLink(value: IssueRoute.issue(repo: model.repoPath, number: issue.number)) {
                         draftBody = ""
                         draftFormat = "md"
                         composing = false
-                        createdIssue = number
+                        pushRoute(IssueRoute.issue(repo: model.repoPath, number: number))
                         await model.load()
                     }
                 }
             }
         }
-        .navigationDestination(item: $createdIssue) { number in
-            IssueView(client: client, repo: model.repoPath, number: number)
-        }
         .task { await model.loadIfNeeded() }
         .task { await createModel.loadTemplates() }
         .refreshable { await model.load() }

gitbay/Views/Issues/MilestoneListView.swift +8 −6

     var body: some View {
         List {
-            Picker("State", selection: Bindable(model).filter) {
+            Section {
-                ForEach(MilestoneListViewModel.StateFilter.allCases) { filter in
+                Picker("State", selection: Bindable(model).filter) {
-                    Text(filter.rawValue.capitalized).tag(filter)
+                    ForEach(MilestoneListViewModel.StateFilter.allCases) { filter in
+                        Text(filter.rawValue.capitalized).tag(filter)
+                    }
                 }
+                .pickerStyle(.segmented)
+                .listRowBackground(Color.clear)
+                .listRowInsets(EdgeInsets())
             }
-            .pickerStyle(.segmented)
-            .listRowBackground(Color.clear)
-            .listRowInsets(EdgeInsets())
             if let error = model.actionError {
                 Section {

gitbay/Views/MRs/MRListView.swift +8 −6

     var body: some View {
         List {
-            Picker("State", selection: Bindable(model).filter.state) {
+            Section {
-                ForEach(MRFilter.State.allCases) { filter in
+                Picker("State", selection: Bindable(model).filter.state) {
-                    Text(filter.label).tag(filter)
+                    ForEach(MRFilter.State.allCases) { filter in
+                        Text(filter.label).tag(filter)
+                    }
                 }
+                .pickerStyle(.segmented)
+                .listRowBackground(Color.clear)
+                .listRowInsets(EdgeInsets())
             }
-            .pickerStyle(.segmented)
-            .listRowBackground(Color.clear)
-            .listRowInsets(EdgeInsets())
             ForEach(model.state.value ?? []) { mr in
                 NavigationLink(value: MRRoute.mr(repo: model.repoPath, number: mr.number)) {

gitbay/Views/Repos/RepoView.swift +24 −30

     @State private var confirmingArchive = false
     @State private var confirmingFork = false
     @State private var forkName = ""
-    @State private var forkDestination: RepoRoute?
     @Environment(\.dynamicTypeSize) private var typeSize
     @ScaledMetric(relativeTo: .title3) private var statValueHeight: CGFloat = 26
-    @State private var destination: Destination?
+    @Environment(\.pushRoute) private var pushRoute
     /// Pushed from buttons rather than NavigationLinks: several share a
     /// list row, and a link there claims the whole row and adds a chevron.
         case history, refs, milestones, labels, releases, wiki, grep
     }
+    private func open(_ target: Destination) {
+        switch target {
+        case .files: pushRoute(RepoRoute.tree(repo: path, directory: "", ref: nil))
+        case .mergeRequests: pushRoute(MRRoute.list(repo: path))
+        case .issues: pushRoute(IssueRoute.list(repo: path))
+        case .builds: pushRoute(BuildRoute.list(repo: path))
+        case .owner: pushRoute(RepoRoute.profile(owner))
+        case .settings: pushRoute(RepoRoute.settings(repo: path))
+        case .history: pushRoute(RepoRoute.log(repo: path, ref: nil, path: nil))
+        case .refs: pushRoute(RepoRoute.refs(repo: path))
+        case .milestones: pushRoute(RepoRoute.milestones(repo: path))
+        case .labels: pushRoute(RepoRoute.labels(repo: path))
+        case .releases: pushRoute(ReleaseRoute.list(repo: path))
+        case .wiki: pushRoute(RepoRoute.wiki(repo: path))
+        case .grep: pushRoute(RepoRoute.grep(repo: path))
+        }
+    }
     var body: some View {
         List {
             if let detail = model.state.value {
         .toolbar { toolbar }
         .task { await model.load() }
         .refreshable { await model.load() }
-        .navigationDestination(item: $forkDestination) { route in
-            if case .repo(let forkedPath) = route {
-                RepoView(client: client, path: forkedPath)
-            }
-        }
-        .navigationDestination(item: $destination) { destination in
-            switch destination {
-            case .files: TreeView(client: client, repo: path, directory: "", ref: nil)
-            case .mergeRequests: MRListView(client: client, repo: path)
-            case .issues: IssueListView(client: client, repo: path)
-            case .builds: BuildListView(client: client, repo: path)
-            case .owner: ProfileView(client: client, name: owner)
-            case .settings: RepoSettingsView(client: client, repo: path)
-            case .history: LogView(client: client, repo: path, ref: nil, path: nil)
-            case .refs: RefsView(client: client, repo: path)
-            case .milestones: MilestoneListView(client: client, repo: path)
-            case .labels: LabelListView(client: client, repo: path)
-            case .releases: ReleaseListView(client: client, repo: path)
-            case .wiki: WikiView(client: client, repo: path)
-            case .grep: GrepView(client: client, repo: path)
-            }
-        }
         .alert("Fork \(path)", isPresented: $confirmingFork) {
             TextField("New name (optional)", text: $forkName)
                 .autocorrectionDisabled()
             Button("Fork") {
                 Task {
                     if let result = await actionsModel.fork(named: forkName) {
-                        forkDestination = .repo(result.path)
+                        pushRoute(RepoRoute.repo(result.path))
                     }
                 }
             }
                     }
                     Divider()
                     Button {
-                        destination = .settings
+                        open(.settings)
                     } label: {
                         Label("Settings", systemImage: "gearshape")
                     }
             VStack(alignment: .leading, spacing: 8) {
                 HStack(spacing: 6) {
                     HStack(spacing: 0) {
-                        Button(owner) { destination = .owner }
+                        Button(owner) { open(.owner) }
                             .buttonStyle(.borderless)
                             .accessibilityIdentifier("repo-owner-link")
                         Text("/" + (detail.path.split(separator: "/").last.map(String.init) ?? ""))
         _ title: String, label: String, value: String? = nil, id: String,
         to target: Destination, first: Bool, @ViewBuilder top: () -> some View
     ) -> some View {
-        Button { destination = target } label: {
+        Button { open(target) } label: {
             VStack(spacing: 2) {
                 top()
                     .font(.gbSans(.title3))
     }
     private func pill(_ title: String, systemImage: String, to target: Destination) -> some View {
-        Button { destination = target } label: {
+        Button { open(target) } label: {
             Label {
                 Text(title).lineLimit(1).minimumScaleFactor(0.8)
             } icon: {
             .padding(.horizontal, 10)
             .padding(.vertical, 8)
             .frame(maxWidth: .infinity, alignment: .leading)
-            .overlay(RoundedRectangle(cornerRadius: 2).stroke(Color.gbLine, lineWidth: 0.5))
             .contentShape(Rectangle())
         }
         .buttonStyle(.plain)

gitbay/Views/Shared/BodyReferences.swift +6 −15

 private struct ReferenceNavigation: ViewModifier {
-    @Environment(SessionStore.self) private var session
+    @Environment(\.pushRoute) private var pushRoute
-    @State private var target: NotificationDestination?
     func body(content: Content) -> some View {
         content
             .environment(\.openURL, OpenURLAction { url in
                 guard let destination = referenceDestination(url) else { return .systemAction }
-                target = destination
+                switch destination {
+                case .issue(let repo, let number): pushRoute(IssueRoute.issue(repo: repo, number: number))
+                case .mr(let repo, let number): pushRoute(MRRoute.mr(repo: repo, number: number))
+                case .build(let repo, let number): pushRoute(BuildRoute.detail(repo: repo, number: number))
+                }
                 return .handled
             })
-            .navigationDestination(item: $target) { destination in
-                if let client = session.client {
-                    switch destination {
-                    case .issue(let repo, let number):
-                        IssueView(client: client, repo: repo, number: number)
-                    case .mr(let repo, let number):
-                        MRView(client: client, repo: repo, number: number)
-                    case .build(let repo, let number):
-                        BuildDetailView(client: client, repo: repo, number: number)
-                    }
-                }
-            }
     }
 }

gitbay/Views/Shared/SidebarRouting.swift +12

	@@ -4,6 +4,18 @@ extension EnvironmentValues {
4	/// Set on a list shown as a `NavigationSplitView` sidebar: what it	4	/// Set on a list shown as a `NavigationSplitView` sidebar: what it
5	/// selects opens in the detail column's stack. Nil in a plain stack.	5	/// selects opens in the detail column's stack. Nil in a plain stack.
6	@Entry var sidebarSelection: Binding<AnyHashable?>?	6	@Entry var sidebarSelection: Binding<AnyHashable?>?
		7
		8	/// Appends a route to the enclosing stack's path. Screens that push
		9	/// from a button use it instead of `navigationDestination(item:)`,
		10	/// which puts any later value-link push underneath the pushed screen.
		11	@Entry var pushRoute: (any Hashable) -> Void = { _ in }
		12	}
		13
		14	extension View {
		15	/// Lets screens in this stack push onto `path` with `pushRoute`.
		16	func pushesRoutes(into path: Binding<NavigationPath>) -> some View {
		17	environment(\.pushRoute) { path.wrappedValue.append($0) }
		18	}
7	}	19	}
8		20
9	/// A `List` whose rows select into `sidebarSelection` when there is one.	21	/// A `List` whose rows select into `sidebarSelection` when there is one.

Commit c108ce3805

Commit `c108ce3805`