Skip to content

armgit / cra

Public Imported from GitHub
0

The open-source Arc replacement for macOS. Spaces, pinned tabs, split view, Little Windows and Arc's shortcuts on Chromium, with your Arc sidebar imported in one go.

GitLab live folders, built as Arc's GitHub folder: Live Folders ▸ GitLab…, one folder per instance (#223)

Grigoriybb38e5a70b7b
diff --git a/Packages/CraCore/Sources/CraCore/GitLabLiveClient.swift b/Packages/CraCore/Sources/CraCore/GitLabLiveClient.swift
new file mode 100644
index 0000000..d8128a8
--- /dev/null
+++ b/Packages/CraCore/Sources/CraCore/GitLabLiveClient.swift
@@ -0,0 +1,116 @@
+import Foundation
+
+/// GitLab live folders: Arc's GitHub folder (LiveFolderModel) filled from GitLab's REST API, read with the
+/// space's own browser session like Arc reads github.com (no token: GitLab accepts its session cookie on
+/// GET /api/v4). Works for gitlab.com and self-managed instances, a port or a subpath included.
+public enum GitLabLiveClient {
+ public static let pageSize = 100
+
+ /// The instance's base URL, normalized (lowercase scheme and host, no default port, no trailing slash),
+ /// or nil for anything that isn't a plain http(s) address (credentials, a query or a fragment).
+ public static func serverURL(_ input: String) -> String? {
+ let text = input.trimmingCharacters(in: .whitespacesAndNewlines)
+ guard !text.isEmpty,
+ var url = URLComponents(string: text.contains("://") ? text : "https://\(text)"),
+ ["https", "http"].contains(url.scheme?.lowercased() ?? ""),
+ let host = url.host, !host.isEmpty,
+ url.user == nil, url.password == nil, url.query == nil, url.fragment == nil else { return nil }
+ url.scheme = url.scheme?.lowercased()
+ url.host = host.lowercased()
+ if (url.scheme == "https" && url.port == 443) || (url.scheme == "http" && url.port == 80) { url.port = nil }
+ while url.path.hasSuffix("/") { url.path.removeLast() }
+ return url.url?.absoluteString
+ }
+
+ /// A new folder's name, as Arc names its GitHub folder "Pull Requests".
+ public static let folderTitle = "Merge Requests"
+
+ /// The instance as the Live Folders menu names it: "gitlab.com", "git.example.com:8443/gitlab".
+ public static func serverLabel(_ server: String) -> String {
+ let normalized = serverURL(server) ?? server
+ return normalized.components(separatedBy: "://").last ?? normalized
+ }
+
+ public static func userURL(server: String) -> String { "\(server)/api/v4/user" }
+
+ public static func mergeRequestsURL(server: String, category: GitLabLiveCategory, userID: Int, page: Int) -> String {
+ let scope: String
+ switch category {
+ case .authored: scope = "created_by_me"
+ case .review: scope = "all"
+ case .assigned: scope = "assigned_to_me"
+ }
+ var url = URLComponents(string: "\(server)/api/v4/merge_requests")!
+ url.queryItems = [
+ URLQueryItem(name: "state", value: "opened"),
+ URLQueryItem(name: "scope", value: scope),
+ URLQueryItem(name: "order_by", value: "created_at"),
+ URLQueryItem(name: "sort", value: "desc"),
+ URLQueryItem(name: "per_page", value: "\(pageSize)"),
+ URLQueryItem(name: "page", value: "\(page)"),
+ ]
+ if category == .review { url.queryItems?.append(URLQueryItem(name: "reviewer_id", value: "\(userID)")) }
+ return url.url!.absoluteString
+ }
+
+ public static func validate(status: Int, finalURL: String, requestedURL: String) throws {
+ if status == 0 { throw LiveFolderError.network }
+ if status == 401 { throw LiveFolderError.notSignedIn }
+ if status == 429 { throw LiveFolderError.rateLimited }
+ guard (200..<300).contains(status) else { throw LiveFolderError.unexpectedPage }
+ guard let final = URL(string: finalURL), let requested = URL(string: requestedURL),
+ final.scheme == requested.scheme, final.host == requested.host,
+ final.port == requested.port, final.path == requested.path else { throw LiveFolderError.notSignedIn }
+ }
+
+ public static func userID(in body: String) throws -> Int {
+ struct User: Decodable { var id: Int }
+ return try decode(User.self, body: body).id
+ }
+
+ public static func mergeRequests(in body: String, server: String, category: GitLabLiveCategory) throws -> [LivePullRequest] {
+ struct Author: Decodable { var username: String }
+ struct MergeRequest: Decodable {
+ var iid: Int
+ var title: String
+ var webUrl: String
+ var author: Author?
+ var state: String
+ var draft: Bool?
+ var createdAt: String?
+ var updatedAt: String?
+ }
+ let requests = try decode([MergeRequest].self, body: body)
+ let fractional = ISO8601DateFormatter()
+ fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+ let plain = ISO8601DateFormatter()
+ func date(_ text: String?) -> Date? { text.flatMap { fractional.date(from: $0) ?? plain.date(from: $0) } }
+ return try requests.map { request in
+ guard request.webUrl.hasPrefix(server + "/"),
+ let boundary = request.webUrl.range(of: "/-/merge_requests/", options: .backwards) else {
+ throw LiveFolderError.unexpectedPage
+ }
+ let project = String(request.webUrl[..<boundary.lowerBound].dropFirst(server.count + 1))
+ guard let slash = project.lastIndex(of: "/"), request.iid > 0 else { throw LiveFolderError.unexpectedPage }
+ var pr = LivePullRequest(owner: String(project[..<slash]), repo: String(project[project.index(after: slash)...]),
+ number: request.iid, title: request.title, author: request.author?.username,
+ createdByMe: category == .authored, isAwaitingMyReview: category == .review,
+ createdAt: date(request.createdAt), updatedAt: date(request.updatedAt))
+ pr.webURL = request.webUrl
+ switch request.state {
+ case "opened": pr.state = request.draft == true ? .draft : .open
+ case "merged": pr.state = .merged
+ case "closed": pr.state = .closed
+ default: throw LiveFolderError.unexpectedPage
+ }
+ return pr
+ }
+ }
+
+ private static func decode<T: Decodable>(_ type: T.Type, body: String) throws -> T {
+ let decoder = JSONDecoder()
+ decoder.keyDecodingStrategy = .convertFromSnakeCase
+ do { return try decoder.decode(type, from: Data(body.utf8)) }
+ catch { throw LiveFolderError.unexpectedPage }
+ }
+}
diff --git a/Packages/CraCore/Sources/CraCore/LiveFolderModel.swift b/Packages/CraCore/Sources/CraCore/LiveFolderModel.swift
index 6f662f4..dc9855f 100644
--- a/Packages/CraCore/Sources/CraCore/LiveFolderModel.swift
+++ b/Packages/CraCore/Sources/CraCore/LiveFolderModel.swift
@@ -6,9 +6,13 @@ import Foundation
// cached LiveItem.github.pullRequest in StorableLiveData.json. Dia 1.54 keeps the same GitHub client
// (ARCClients/GitHubClient). Findings and what was verified: docs/live-folders.md.
-/// What a live folder is filled from. Arc and Dia also have Bitbucket, Notion, Drive and calendar sources.
+/// What a live folder is filled from. Arc and Dia also have Bitbucket, Notion, Drive and calendar sources;
+/// Arc has no GitLab source, so Cra's GitLab folder is Arc's GitHub folder read from GitLab's API.
public enum LiveFolderSource: String, Codable {
case github
+ case gitlab
+
+ public var title: String { self == .github ? "GitHub" : "GitLab" }
}
/// Which pull requests a GitHub live folder shows. Arc saves `attributes` as a bit mask (7 = all three).
@@ -22,6 +26,8 @@ public struct GitHubLiveFilter: Codable, Equatable {
public static let reviewRequests = Attributes(rawValue: 2)
/// review-requested:@me, which also covers teams you are on (Arc: "Team Review Requests")
public static let teamReviewRequests = Attributes(rawValue: 4)
+ /// GitLab only: merge requests assigned to you (Cra's bit; Arc's mask stops at 4).
+ public static let assigned = Attributes(rawValue: 8)
public static let all: Attributes = [.authored, .reviewRequests, .teamReviewRequests]
}
@@ -35,12 +41,36 @@ public struct GitHubLiveFilter: Codable, Equatable {
}
}
-public enum LiveFolderError: String, Codable, Equatable {
+public enum LiveFolderError: String, Codable, Equatable, Error {
case notSignedIn, rateLimited, unexpectedPage, network
}
+/// The GitLab folder's filters, one API query each (the GitHub folder's My Pull Requests and Review Requests,
+/// plus Assigned to Me, which GitLab has where GitHub has team review requests).
+public enum GitLabLiveCategory: String, Codable, CaseIterable {
+ case authored, review, assigned
+
+ public var title: String {
+ switch self {
+ case .authored: return "My Merge Requests"
+ case .review: return "Review Requests"
+ case .assigned: return "Assigned to Me"
+ }
+ }
+
+ public var attribute: GitHubLiveFilter.Attributes {
+ switch self {
+ case .authored: return .authored
+ case .review: return .reviewRequests
+ case .assigned: return .assigned
+ }
+ }
+}
+
public struct LiveFolderData: Codable, Equatable {
public var source: LiveFolderSource = .github
+ /// GitLab: the instance's base URL (GitLabLiveClient.serverURL), gitlab.com or self-managed.
+ public var serverURL: String?
public var filter = GitHubLiveFilter()
/// Items closed out of the folder; they don't come back (Arc: hiddenItems).
public var hiddenItems: [String] = []
@@ -55,14 +85,21 @@ public struct LiveFolderData: Codable, Equatable {
/// Where to sign in again.
public var signInURL: String {
+ if source == .gitlab { return "\(serverURL ?? "https://gitlab.com")/users/sign_in" }
if let enterprise { return "https://github.com/enterprises/\(enterprise)/sso" }
return "https://github.com/login?return_to=%2Fpulls"
}
public init() {}
+
+ public var gitLabCategories: [GitLabLiveCategory] {
+ GitLabLiveCategory.allCases.filter { filter.attributes.contains($0.attribute) }
+ }
+
public init(from decoder: Decoder) throws {
let c = try decoder.container(keyedBy: CodingKeys.self)
source = try c.decodeIfPresent(LiveFolderSource.self, forKey: .source) ?? .github
+ serverURL = try c.decodeIfPresent(String.self, forKey: .serverURL)
filter = try c.decodeIfPresent(GitHubLiveFilter.self, forKey: .filter) ?? GitHubLiveFilter()
hiddenItems = try c.decodeIfPresent([String].self, forKey: .hiddenItems) ?? []
lastFetch = try c.decodeIfPresent(Date.self, forKey: .lastFetch)
@@ -86,6 +123,8 @@ public struct LivePullRequest: Codable, Equatable, Identifiable {
public var isAwaitingMyReview = false
public var createdAt: Date?
public var updatedAt: Date?
+ /// GitLab's own address for the merge request (its URL can't be built from owner/repo/number).
+ public var webURL: String?
public init(owner: String, repo: String, number: Int, title: String, author: String? = nil, state: State = .open,
createdByMe: Bool = false, isAwaitingMyReview: Bool = false, createdAt: Date? = nil, updatedAt: Date? = nil) {
@@ -102,6 +141,6 @@ public struct LivePullRequest: Codable, Equatable, Identifiable {
}
public var id: String { url }
- public var url: String { "https://github.com/\(owner)/\(repo)/pull/\(number)" }
+ public var url: String { webURL ?? "https://github.com/\(owner)/\(repo)/pull/\(number)" }
public var repository: String { "\(owner)/\(repo)" }
}
diff --git a/Packages/CraCore/Tests/CraCoreTests/GitLabLiveClientTests.swift b/Packages/CraCore/Tests/CraCoreTests/GitLabLiveClientTests.swift
new file mode 100644
index 0000000..51c67c0
--- /dev/null
+++ b/Packages/CraCore/Tests/CraCoreTests/GitLabLiveClientTests.swift
@@ -0,0 +1,82 @@
+import Foundation
+import CraCore
+import Testing
+
+struct GitLabLiveClientTests {
+ @Test func selfHostedURLsKeepPortsAndSubpaths() throws {
+ let server = try #require(GitLabLiveClient.serverURL(" https://git.example.com:8443/gitlab/ "))
+ #expect(server == "https://git.example.com:8443/gitlab")
+ #expect(GitLabLiveClient.userURL(server: server) == server + "/api/v4/user")
+ let url = try #require(URLComponents(string: GitLabLiveClient.mergeRequestsURL(server: server, category: .review, userID: 42, page: 2)))
+ #expect(url.path == "/gitlab/api/v4/merge_requests")
+ let query = Dictionary(uniqueKeysWithValues: (url.queryItems ?? []).map { ($0.name, $0.value) })
+ #expect(query["reviewer_id"] == "42" && query["scope"] == "all" && query["page"] == "2")
+ #expect(GitLabLiveClient.serverURL("git.example.com") == "https://git.example.com")
+ for input in ["", "file:///etc/passwd", "https://user:[email protected]", "https://git.example.com?token=secret"] {
+ #expect(GitLabLiveClient.serverURL(input) == nil)
+ }
+ }
+
+ @Test func mergeRequestsKeepNestedGroupsAndServerIdentity() throws {
+ let server = "https://git.example.com/gitlab"
+ let body = #"[{"iid":17,"title":"Fix startup","web_url":"https://git.example.com/gitlab/company/team/app/-/merge_requests/17","author":{"username":"alex"},"state":"opened","draft":true,"created_at":"2026-11-06T12:00:00.123Z"}]"#
+ let request = try #require(GitLabLiveClient.mergeRequests(in: body, server: server, category: .review).first)
+ #expect(request.repository == "company/team/app")
+ #expect(request.url == server + "/company/team/app/-/merge_requests/17")
+ #expect(request.author == "alex" && request.state == .draft && request.createdAt != nil)
+ #expect(request.isAwaitingMyReview && !request.createdByMe)
+ let restored = try JSONDecoder().decode(LivePullRequest.self, from: JSONEncoder().encode(request))
+ #expect(restored == request)
+ #expect(throws: LiveFolderError.unexpectedPage) {
+ try GitLabLiveClient.mergeRequests(in: body, server: "https://other.example.com", category: .review)
+ }
+ }
+
+ @Test func serverNamesDistinguishInstancesAndNormalizeEquivalentAddresses() {
+ #expect(GitLabLiveClient.serverURL("HTTPS://GIT.Example.com:443/") == "https://git.example.com")
+ #expect(GitLabLiveClient.serverURL("http://GIT.Example.com:80/gitlab/") == "http://git.example.com/gitlab")
+ #expect(GitLabLiveClient.serverLabel("https://gitlab.com") == "gitlab.com")
+ #expect(GitLabLiveClient.serverLabel("https://git.example.com:8443/gitlab/") == "git.example.com:8443/gitlab")
+ }
+
+ @Test func failuresCannotBecomeEmptySuccesses() throws {
+ let url = "https://git.example.com/api/v4/merge_requests"
+ for (status, error) in [(0, LiveFolderError.network), (401, .notSignedIn), (403, .unexpectedPage), (429, .rateLimited), (500, .unexpectedPage)] {
+ #expect(throws: error) { try GitLabLiveClient.validate(status: status, finalURL: url, requestedURL: url) }
+ }
+ #expect(throws: LiveFolderError.notSignedIn) {
+ try GitLabLiveClient.validate(status: 200, finalURL: "https://sso.example.com/login", requestedURL: url)
+ }
+ for body in ["<html>Sign in</html>", #"{"message":"403 Forbidden"}"#, #"[{"iid":1}]"#] {
+ #expect(throws: LiveFolderError.unexpectedPage) {
+ try GitLabLiveClient.mergeRequests(in: body, server: "https://git.example.com", category: .authored)
+ }
+ }
+ #expect(try GitLabLiveClient.mergeRequests(in: "[]", server: "https://git.example.com", category: .authored).isEmpty)
+ }
+
+ @Test func gitLabFolderSurvivesPersistence() throws {
+ var folder = LiveFolderData()
+ folder.source = .gitlab
+ folder.serverURL = "https://git.example.com/gitlab"
+ folder.hiddenItems = ["https://git.example.com/gitlab/team/app/-/merge_requests/17"]
+ let restored = try JSONDecoder().decode(LiveFolderData.self, from: JSONEncoder().encode(folder))
+ #expect(restored == folder)
+ #expect(restored.signInURL == "https://git.example.com/gitlab/users/sign_in")
+ let legacy = try JSONDecoder().decode(LiveFolderData.self, from: Data("{}".utf8))
+ #expect(legacy.source == .github && legacy.serverURL == nil)
+ }
+
+ @Test func filtersUseDistinctQueries() throws {
+ let expected: [(GitLabLiveCategory, String)] = [(.authored, "created_by_me"), (.review, "all"), (.assigned, "assigned_to_me")]
+ for (category, scope) in expected {
+ let url = try #require(URLComponents(string: GitLabLiveClient.mergeRequestsURL(server: "https://git.example.com", category: category, userID: 42, page: 1)))
+ let query = Dictionary(uniqueKeysWithValues: (url.queryItems ?? []).map { ($0.name, $0.value) })
+ #expect(query["scope"] == scope)
+ #expect((query["reviewer_id"] != nil) == (category == .review))
+ }
+ var folder = LiveFolderData()
+ folder.filter.attributes = [.reviewRequests, .assigned]
+ #expect(folder.gitLabCategories == [.review, .assigned])
+ }
+}
diff --git a/Sources/Cra/Services/LiveFolderManager.swift b/Sources/Cra/Services/LiveFolderManager.swift
index f6347bb..7e1b307 100644
--- a/Sources/Cra/Services/LiveFolderManager.swift
+++ b/Sources/Cra/Services/LiveFolderManager.swift
@@ -16,6 +16,9 @@ final class LiveFolderManager {
/// Repositories in each folder's last results plus the hidden ones: the folder menu's list
/// (Arc: "This list is generated based on your currently active pull requests.").
private(set) var repositories: [UUID: [String]] = [:]
+ /// Folders whose filters, profile or server changed while a refresh was out: they refresh again
+ /// once it's back (its answer is for the old settings and is dropped).
+ @ObservationIgnored private var pendingRefresh: Set<UUID> = []
@ObservationIgnored private var timer: ScheduledWork?
/// The last address each tab reported, to tell what a page came from.
@ObservationIgnored private var lastURL: [UUID: String] = [:]
@@ -40,6 +43,10 @@ final class LiveFolderManager {
func start(store: SidebarStore) {
self.store = store
+ store.liveFolderChanged = { [weak self] id in
+ self?.repositories[id] = nil
+ self?.refresh(id, force: true)
+ }
timer = store.clock.every(15) { [weak self] in
self?.store?.expireLiveItems(olderThan: Self.retention)
self?.refreshStale()
@@ -70,13 +77,22 @@ final class LiveFolderManager {
/// `force` skips the gap between refreshes: the folder's filters just changed.
func refresh(_ id: UUID, force: Bool = false) {
- guard let store, let live = store.item(id)?.liveFolder, !refreshing.contains(id) else { return }
+ guard let store, let live = store.item(id)?.liveFolder, let context = store.liveRequestContext(id) else { return }
+ if refreshing.contains(id) {
+ if force { pendingRefresh.insert(id) }
+ return
+ }
if !force, let last = live.lastFetch, store.clock.now.timeIntervalSince(last) < Self.minimumInterval, live.lastError == nil { return }
+ if live.source == .gitlab {
+ refreshGitLab(id, live: live, profile: store.profilePath(item: id), context: context)
+ return
+ }
let attributes: [GitHubLiveFilter.Attributes] = [.authored, .reviewRequests, .teamReviewRequests]
.filter { live.filter.attributes.contains($0) }
refreshing.insert(id)
let profile = store.profilePath(item: id)
Task { @MainActor in
+ defer { finishRefresh(id) }
var pages: [(GitHubLiveFilter.Attributes, GitHubLiveClient.Page)] = []
var failure: GitHubLiveClient.Failure?
for a in attributes {
@@ -85,19 +101,32 @@ final class LiveFolderManager {
case .failure(let f): failure = failure == .notSignedIn ? failure : f
}
}
- refreshing.remove(id)
- guard let store = self.store, store.item(id)?.isLiveFolder == true else { return }
+ guard acceptsResponse(id, context: context), let store = self.store else { return }
// A partial update would empty the folder of whatever the failed search found.
if let failure {
- store.applyLiveFailure(failure.asLiveFolderError, to: id)
+ store.applyLiveFailure(failure.asLiveFolderError, to: id, context: context)
return
}
let prs = Self.merge(pages)
let hidden = store.item(id)?.liveFolder?.filter.hiddenRepositories ?? []
repositories[id] = Array(Set(prs.map(\.repository) + hidden)).sorted { $0.lowercased() < $1.lowercased() }
let sso = Array(Set(pages.flatMap { $0.1.ssoOrganizations })).sorted()
- store.applyLiveResults(prs, to: id, ssoOrganizations: sso)
+ store.applyLiveResults(prs, to: id, ssoOrganizations: sso, context: context)
+ }
+ }
+
+ private func acceptsResponse(_ id: UUID, context: SidebarStore.LiveRequestContext) -> Bool {
+ guard let current = store?.liveRequestContext(id) else { return false }
+ guard current == context else {
+ pendingRefresh.insert(id)
+ return false
}
+ return true
+ }
+
+ private func finishRefresh(_ id: UUID) {
+ refreshing.remove(id)
+ if pendingRefresh.remove(id) != nil { refresh(id, force: true) }
}
/// A page in a tab moved (BrowserManager). Creating a pull request (compare page → pull page)
@@ -108,7 +137,7 @@ final class LiveFolderManager {
lastURL[tab] = url
if lastURL.count > 500 { lastURL = [tab: url] }
guard old != url, let store, !store.liveFolders.isEmpty else { return }
- let folders = store.liveFolders
+ let folders = store.liveFolders.filter { $0.liveFolder?.source == .github }
guard let page = URL(string: url), page.host == "github.com" else { return }
learnEnterprise(from: url)
if folders.contains(where: { $0.liveFolder.map(Self.needsSignIn) ?? false }) { checkSignIn() }
@@ -119,7 +148,7 @@ final class LiveFolderManager {
guard created || reviewed else { return }
for delay in Self.triggerDelays {
DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
- for f in self?.store?.liveFolders ?? [] { self?.refresh(f.id, force: true) }
+ for f in self?.store?.liveFolders ?? [] where f.liveFolder?.source == .github { self?.refresh(f.id, force: true) }
}
}
}
@@ -128,7 +157,7 @@ final class LiveFolderManager {
/// 2026), a tab and the folder's own requests alike: the folder's sign-in goes there too.
private func learnEnterprise(from url: String) {
guard let slug = GitHubLiveClient.enterprise(inSSO: url), let store else { return }
- for f in store.liveFolders where f.liveFolder?.enterprise != slug { store.updateLiveFolder(f.id) { $0.enterprise = slug } }
+ for f in store.liveFolders where f.liveFolder?.source == .github && f.liveFolder?.enterprise != slug { store.updateLiveFolder(f.id) { $0.enterprise = slug } }
}
/// Signing in ends on a GitHub page, and so does an SSO session that renews by itself (an
@@ -147,6 +176,59 @@ final class LiveFolderManager {
DispatchQueue.main.asyncAfter(deadline: .now() + 2, execute: work)
}
+ private func refreshGitLab(_ id: UUID, live: LiveFolderData, profile: String?, context: SidebarStore.LiveRequestContext) {
+ guard let server = live.serverURL.flatMap(GitLabLiveClient.serverURL) else {
+ store?.applyLiveFailure(.unexpectedPage, to: id)
+ return
+ }
+ refreshing.insert(id)
+ Task { @MainActor in
+ defer { finishRefresh(id) }
+ do {
+ let user = try await getGitLab(GitLabLiveClient.userURL(server: server), profile: profile, folder: id, context: context)
+ let userID = try GitLabLiveClient.userID(in: user)
+ var results: [String: LivePullRequest] = [:]
+ for category in live.gitLabCategories {
+ for page in 1...50 {
+ let url = GitLabLiveClient.mergeRequestsURL(server: server, category: category, userID: userID, page: page)
+ let body = try await getGitLab(url, profile: profile, folder: id, context: context)
+ let requests = try GitLabLiveClient.mergeRequests(in: body, server: server, category: category)
+ for var request in requests {
+ if let previous = results[request.url] {
+ request.createdByMe = request.createdByMe || previous.createdByMe
+ request.isAwaitingMyReview = request.isAwaitingMyReview || previous.isAwaitingMyReview
+ }
+ results[request.url] = request
+ }
+ if requests.count < GitLabLiveClient.pageSize { break }
+ if page == 50 { throw LiveFolderError.unexpectedPage }
+ }
+ }
+ guard acceptsResponse(id, context: context), let store, let current = store.item(id)?.liveFolder else { return }
+ let requests = results.values.sorted {
+ let a = $0.createdAt ?? .distantPast, b = $1.createdAt ?? .distantPast
+ return a == b ? $0.url < $1.url : a > b
+ }
+ repositories[id] = Array(Set(requests.map(\.repository) + current.filter.hiddenRepositories)).sorted()
+ store.applyLiveResults(requests, to: id, ssoOrganizations: [], context: context)
+ } catch {
+ guard acceptsResponse(id, context: context) else { return }
+ store?.applyLiveFailure(error as? LiveFolderError ?? .unexpectedPage, to: id, context: context)
+ }
+ }
+ }
+
+ private func getGitLab(_ url: String, profile: String?, folder: UUID, context: SidebarStore.LiveRequestContext) async throws -> String {
+ let (status, finalURL, body): (Int, String, String) = await withCheckedContinuation { continuation in
+ CraCEFRuntime.fetchURL(url, headers: ["Accept": "application/json"], profilePath: profile) { status, finalURL, _, body in
+ continuation.resume(returning: (Int(status), finalURL, body))
+ }
+ }
+ guard acceptsResponse(folder, context: context) else { throw CancellationError() }
+ try GitLabLiveClient.validate(status: status, finalURL: finalURL, requestedURL: url)
+ return body
+ }
+
/// One search: the pulls page first (what Arc and Dia read), then GitHub's search page
/// when that comes back with nothing it can read.
private func fetch(_ query: String, profile: String?, label: String) async -> Result<GitHubLiveClient.Page, GitHubLiveClient.Failure> {
diff --git a/Sources/Cra/Services/SidebarStore.swift b/Sources/Cra/Services/SidebarStore.swift
index 3e3f292..d0504a7 100644
--- a/Sources/Cra/Services/SidebarStore.swift
+++ b/Sources/Cra/Services/SidebarStore.swift
@@ -58,6 +58,8 @@ final class SidebarStore {
/// A tab came into a space's pinned tabs from elsewhere (⌘D, a drag, a menu): Tidy Tab Titles
/// may give it a shorter name (TidyTitlesService).
@ObservationIgnored var tabPinned: (UUID) -> Void = { _ in }
+ @ObservationIgnored var liveFolderChanged: (UUID) -> Void = { _ in }
+ @ObservationIgnored private var liveFolderVersions: [UUID: UUID] = [:]
// MARK: Persistence
@@ -539,7 +541,8 @@ final class SidebarStore {
select: Bool = true, parent: UUID? = nil, index: Int? = nil, window: UUID? = nil) -> SidebarItem {
let sid = spaceID ?? focusedSpaceID(window: window)
let space = spaces[sid] ?? focusedSpace(window: window)
- let parentID = parent ?? (pinned ? space.pinnedContainerID : space.todayContainerID)
+ let requestedParent = parent ?? (pinned ? space.pinnedContainerID : space.todayContainerID)
+ let parentID = liveFolder(containing: requestedParent) == nil ? requestedParent : space.todayContainerID
var tab = SidebarItem.tab(url, title: title, parent: parentID)
tab.data = .tab({ var t = TabData(url: url, title: title); t.activeTabBeforeCreationID = selectedTabID(in: sid, window: window); return t }())
tab.isUnread = !select
@@ -808,13 +811,26 @@ final class SidebarStore {
return
}
let fromParent = it.parentID
+ let movingLiveFolders = liveFolderRoots(under: id)
+ let movingIDs = Set(movingLiveFolders.map(\.id))
+ let destinationSpaces = Set(spaceIDs(ofItem: newParent))
+ for folder in movingLiveFolders {
+ guard let live = folder.liveFolder else { continue }
+ if liveFolders.contains(where: { other in
+ guard !movingIDs.contains(other.id), let otherLive = other.liveFolder,
+ !destinationSpaces.isDisjoint(with: spaceIDs(ofItem: other.id)), otherLive.source == live.source else { return false }
+ return live.source == .github || otherLive.serverURL.flatMap(GitLabLiveClient.serverURL) == live.serverURL.flatMap(GitLabLiveClient.serverURL)
+ }) { return }
+ }
+ if !movingLiveFolders.isEmpty, case .today? = rootContainerKind(newParent) { return }
+ let previousProfiles = Dictionary(uniqueKeysWithValues: movingLiveFolders.map { ($0.id, profileDirectoryName(item: $0.id)) })
// A tab group lives at the top of Today and holds tabs and splits only (Arc's tabGroup items).
if it.isTabGroup, items[newParent]?.container != .today(spaceID: spaceID(ofItem: id) ?? UUID()) { return }
if items[newParent]?.isTabGroup == true, !(it.isTab || it.isSplit) { return }
// A live folder fills itself: nothing is dropped into it, and it never unpacks into Today.
- if items[newParent]?.isLiveFolder == true, fromParent != newParent { return }
+ if liveFolder(containing: newParent) != nil, fromParent != newParent { return }
if it.isLiveFolder, case .today? = rootContainerKind(newParent) { return }
- if fromParent != newParent, let from = fromParent, items[from]?.isLiveFolder == true { hideLiveItem(id, in: from) }
+ if fromParent != newParent, let from = fromParent, let live = liveFolder(containing: from) { hideLiveItem(id, in: live.id) }
let oldIndex = fromParent.flatMap { items[$0]?.children.firstIndex(of: id) }
let wasPinned = fromParent.map { if case .pinned? = rootContainerKind($0) { return true } else { return false } } ?? false
if it.isFolder, !it.isTabGroup, case .today? = rootContainerKind(newParent) {
@@ -849,6 +865,9 @@ final class SidebarStore {
it.data = .tab(t)
}
items[id] = it
+ for (folder, profile) in previousProfiles where profileDirectoryName(item: folder) != profile {
+ invalidateLiveFolder(folder)
+ }
if it.isSplit, isPinned(newParent) {
// A pinned split keeps each pane's page as that pane's home.
for c in it.children {
@@ -1315,7 +1334,7 @@ final class SidebarStore {
let ids = ids.filter { items[$0] != nil }
guard let space = spaces[sid], let first = ids.first else { return }
let from = spaceID(ofItem: first)
- let moved = Set(ids + ids.flatMap { items[$0]?.children ?? [] })
+ let moved = Set(ids + ids.flatMap { tabs(under: $0).map(\.id) })
let today = from.flatMap { spaces[$0] }.map { shownTabs(under: $0.todayContainerID) } ?? []
// Favorites the space already shows (#154) stay where they are.
let favorites = ids.filter { isFavorite($0) && !isInSpace($0, sid) }
@@ -1387,6 +1406,7 @@ final class SidebarStore {
let tabIDs = tabIDs.filter { $0 != targetID && items[$0]?.isTab == true }
guard !tabIDs.isEmpty, items[targetID]?.isTab == true,
let parent = items[targetID]?.parentID, let sid = spaceID(ofItem: targetID), let space = spaces[sid] else { return nil }
+ guard liveFolder(containing: parent) == nil else { return nil }
let inPinned = rootContainer(of: targetID) == .pinned(spaceID: sid)
let folder = createFolder(named: name, in: inPinned ? parent : space.pinnedContainerID,
index: inPinned ? items[parent]?.children.firstIndex(of: targetID) : nil)
@@ -1413,8 +1433,9 @@ final class SidebarStore {
guard let f = items[id], f.isFolder else { return }
// A live folder's tabs are the service's items, not the user's: they go with it.
if f.isLiveFolder {
- for c in f.children { items[c] = nil }
- items[id]?.children = []
+ removeLiveTree(id)
+ touch()
+ return
}
for t in tabs(under: id) { archiveTab(t.id, reason: .manual) }
// Nested folders left behind (now empty) go too.
@@ -1541,13 +1562,62 @@ final class SidebarStore {
var liveFolders: [SidebarItem] { items.values.filter(\.isLiveFolder) }
+ struct LiveRequestContext: Equatable {
+ var source: LiveFolderSource
+ var serverURL: String?
+ var profile: String
+ var attributes: GitHubLiveFilter.Attributes
+ var version: UUID?
+ }
+
+ func liveRequestContext(_ id: UUID) -> LiveRequestContext? {
+ guard let live = items[id]?.liveFolder else { return nil }
+ return LiveRequestContext(source: live.source, serverURL: live.serverURL,
+ profile: profileDirectoryName(item: id), attributes: live.filter.attributes,
+ version: liveFolderVersions[id])
+ }
+
+ private func liveFolderRoots(under id: UUID) -> [SidebarItem] {
+ guard let item = items[id] else { return [] }
+ if item.isLiveFolder { return [item] }
+ return children(of: id).flatMap { liveFolderRoots(under: $0.id) }
+ }
+
+ private func invalidateLiveFolder(_ id: UUID) {
+ liveFolderVersions[id] = UUID()
+ for tab in tabs(under: id) where tab.tab.map({ $0.liveItemURL == nil || $0.url != $0.liveItemURL }) == true {
+ if let sid = spaceID(ofItem: id), let today = spaces[sid]?.todayContainerID { moveItem(tab.id, to: today, index: nil) }
+ }
+ for child in items[id]?.children ?? [] { removeLiveTree(child) }
+ updateLiveFolder(id) {
+ $0.hiddenItems = []
+ $0.lastFetch = nil
+ $0.lastError = nil
+ $0.ssoOrganizations = []
+ $0.enterprise = nil
+ }
+ liveFolderChanged(id)
+ }
+
+ func liveFolder(containing id: UUID) -> SidebarItem? {
+ var current: UUID? = id
+ for _ in 0..<64 {
+ guard let key = current, let item = items[key] else { return nil }
+ if item.isLiveFolder { return item }
+ current = item.parentID
+ }
+ return nil
+ }
+
/// The space's live folder for a source (Dia: one Pull Requests folder per space).
/// Walks only the space's own lists, so a view that asks depends on those items alone.
- func liveFolder(_ source: LiveFolderSource, inSpace sid: UUID) -> SidebarItem? {
+ func liveFolder(_ source: LiveFolderSource, inSpace sid: UUID, serverURL: String? = nil) -> SidebarItem? {
guard let space = spaces[sid] else { return nil }
+ let server = serverURL.flatMap(GitLabLiveClient.serverURL)
func find(under id: UUID) -> SidebarItem? {
for c in children(of: id) where c.isFolder || c.isSplit {
- if c.liveFolder?.source == source { return c }
+ if let live = c.liveFolder, live.source == source,
+ serverURL == nil || (server != nil && live.serverURL.flatMap(GitLabLiveClient.serverURL) == server) { return c }
if let found = find(under: c.id) { return found }
}
return nil
@@ -1560,11 +1630,18 @@ final class SidebarStore {
/// Arc's "Pull Requests" folder at the top of the space's pinned tabs, open.
@discardableResult
- func createLiveFolder(_ source: LiveFolderSource, inSpace sid: UUID) -> SidebarItem? {
- if let existing = liveFolder(source, inSpace: sid) { return existing }
+ func createLiveFolder(_ source: LiveFolderSource, inSpace sid: UUID, serverURL: String? = nil) -> SidebarItem? {
+ let server = source == .gitlab ? serverURL.flatMap(GitLabLiveClient.serverURL) : nil
+ if source == .gitlab, server == nil { return nil }
+ if let existing = liveFolder(source, inSpace: sid, serverURL: server) { return existing }
guard let space = spaces[sid], !isStandalone(space: sid) else { return nil }
- let folder = createFolder(named: "Pull Requests", in: space.pinnedContainerID, index: 0)
- items[folder.id]?.liveFolder = LiveFolderData()
+ let title = source == .gitlab ? GitLabLiveClient.folderTitle : "Pull Requests"
+ let folder = createFolder(named: title, in: space.pinnedContainerID, index: 0)
+ var live = LiveFolderData()
+ live.source = source
+ live.serverURL = server
+ if source == .gitlab { live.filter.attributes = [.authored, .reviewRequests, .assigned] }
+ items[folder.id]?.liveFolder = live
touch()
return items[folder.id]
}
@@ -1576,11 +1653,21 @@ final class SidebarStore {
touch()
}
+ private func removeLiveTree(_ id: UUID) {
+ for child in items[id]?.children ?? [] { removeLiveTree(child) }
+ detach(id)
+ items[id] = nil
+ prefs.expandedFolders.remove(id)
+ prefs.peekedFolders.removeValue(forKey: id)
+ }
+
/// A refresh came back. New pull requests come in unread at their place (a Today tab already
/// showing one moves in instead, Dia's reparentPullRequestTabToLiveFolder), ones that left the
/// results stay for LiveFolderManager.retention before they go, the rest keep the pull request's
/// title and author. The first fill marks nothing unread.
- func applyLiveResults(_ prs: [LivePullRequest], to folderID: UUID, ssoOrganizations: [String]) {
+ /// `context`: what the request was made for; an answer for an old profile, server or filter is dropped.
+ func applyLiveResults(_ prs: [LivePullRequest], to folderID: UUID, ssoOrganizations: [String], context: LiveRequestContext? = nil) {
+ if let context, liveRequestContext(folderID) != context { return }
guard var folder = items[folderID], var live = folder.liveFolder else { return }
let hidden = Set(live.hiddenItems)
let hiddenRepos = Set(live.filter.hiddenRepositories.map { $0.lowercased() })
@@ -1645,7 +1732,7 @@ final class SidebarStore {
let open = Set(prefs.windows.flatMap { $0.selectedTabPerSpace.values })
var changed = false
for folder in liveFolders {
- for c in children(of: folder.id) where !open.contains(c.id) {
+ for c in tabs(under: folder.id) where !open.contains(c.id) {
guard let goneAt = c.tab?.liveGoneAt, clock.now.timeIntervalSince(goneAt) >= age else { continue }
detach(c.id)
items[c.id] = nil
@@ -1659,12 +1746,14 @@ final class SidebarStore {
private func adoptableTab(for pr: LivePullRequest, folderID: UUID) -> UUID? {
guard let sid = spaceID(ofItem: folderID), let space = spaces[sid] else { return nil }
return children(of: space.todayContainerID).first { c in
+ if pr.webURL != nil { return c.tab?.url == pr.url }
guard let url = c.tab?.url, let p = GitHubLiveClient.pullPath(url) else { return false }
return p.owner.lowercased() == pr.owner.lowercased() && p.repo.lowercased() == pr.repo.lowercased() && p.number == pr.number
}?.id
}
- func applyLiveFailure(_ error: LiveFolderError, to folderID: UUID) {
+ func applyLiveFailure(_ error: LiveFolderError, to folderID: UUID, context: LiveRequestContext? = nil) {
+ if let context, liveRequestContext(folderID) != context { return }
updateLiveFolder(folderID) {
$0.lastFetch = clock.now
$0.lastError = error
@@ -1702,8 +1791,8 @@ final class SidebarStore {
let list = pinned ? [] : (sid.flatMap { spaces[$0] }.map { shownTabs(under: $0.todayContainerID) } ?? [])
// Closed out of a live folder: the item stays out (Arc: hiddenItems). The archive keeps
// the live copy so ⇧⌘T can put it back.
- if let folder, items[folder]?.isLiveFolder == true {
- hideLiveItem(id, in: folder)
+ if let folder, let live = liveFolder(containing: folder) {
+ hideLiveItem(id, in: live.id)
}
detach(id)
items[id] = nil
@@ -2104,12 +2193,16 @@ final class SidebarStore {
/// Pages already open in the space load again in the new profile (BrowserManager).
func setProfile(_ profileID: UUID?, forSpace id: UUID) {
guard var s = spaces[id], s.profileID != profileID, profileID == nil || profile(profileID) != nil else { return }
+ let previousProfiles = Dictionary(uniqueKeysWithValues: liveFolders.map { ($0.id, profileDirectoryName(item: $0.id)) })
// Arc: favorites belong to the profile. The space shows its new profile's list and takes
// nothing along; the old list stays with the old profile, shown or not. A favorite open in
// the space stays open, in its own profile, though its tile is gone (Arc 1.171).
if isProfileList(s.favoritesContainerID) { s.favoritesContainerID = profileList(profileID) }
s.profileID = profileID
spaces[id] = s
+ for (folder, profile) in previousProfiles where profileDirectoryName(item: folder) != profile {
+ invalidateLiveFolder(folder)
+ }
touch()
}
diff --git a/Sources/Cra/UI/Sidebar/List/SidebarMenus.swift b/Sources/Cra/UI/Sidebar/List/SidebarMenus.swift
index 631c6db..2041528 100644
--- a/Sources/Cra/UI/Sidebar/List/SidebarMenus.swift
+++ b/Sources/Cra/UI/Sidebar/List/SidebarMenus.swift
@@ -165,11 +165,13 @@ enum SidebarMenus {
let live = item.liveFolder ?? LiveFolderData()
let menu = menu()
note(menu, manager.refreshing.contains(id) ? "Updating…" : LiveFolderText.lastUpdate(live))
+ if live.source == .gitlab, let server = live.serverURL { note(menu, GitLabLiveClient.serverLabel(server)) }
add(menu, "Refresh") { manager.refresh(id) }
menu.addItem(.separator())
- for (title, attribute) in [("My Pull Requests", GitHubLiveFilter.Attributes.authored),
- ("Review Requests", .reviewRequests),
- ("Team Review Requests", .teamReviewRequests)] {
+ let filters: [(String, GitHubLiveFilter.Attributes)] = live.source == .gitlab
+ ? GitLabLiveCategory.allCases.map { ($0.title, $0.attribute) }
+ : [("My Pull Requests", .authored), ("Review Requests", .reviewRequests), ("Team Review Requests", .teamReviewRequests)]
+ for (title, attribute) in filters {
let on = live.filter.attributes.contains(attribute)
add(menu, title, on: on) {
store.updateLiveFolder(id) { l in
@@ -180,8 +182,8 @@ enum SidebarMenus {
}
let repos = manager.repositories[id] ?? live.filter.hiddenRepositories
if !repos.isEmpty {
- let sub = submenu(menu, "Repositories")
- note(sub, "This list is generated based on your currently active pull requests.")
+ let sub = submenu(menu, live.source == .gitlab ? "Projects" : "Repositories")
+ note(sub, live.source == .gitlab ? "Projects with active merge requests." : "This list is generated based on your currently active pull requests.")
sub.addItem(.separator())
for repo in repos {
let shown = !live.filter.hiddenRepositories.contains(repo)
@@ -196,7 +198,7 @@ enum SidebarMenus {
}
if live.lastError == .notSignedIn {
menu.addItem(.separator())
- add(menu, "Sign In to GitHub…") { actions.openURL(live.signInURL) }
+ add(menu, "Sign In to \(live.source.title)…") { actions.openURL(live.signInURL) }
} else if !live.ssoOrganizations.isEmpty {
menu.addItem(.separator())
note(menu, "SSO ensures all of your organizations’ PRs appear")
@@ -208,7 +210,7 @@ enum SidebarMenus {
add(menu, "Rename…") { ui.renamingID = id }
iconColor(menu, item, list: list)
add(menu, "Copy All Links as Markdown", enabled: !item.children.isEmpty) {
- let lines = store.children(of: id).compactMap { c in c.tab.map { "- [\(c.displayTitle)](\($0.liveItemURL ?? $0.url))" } }
+ let lines = store.tabs(under: id).compactMap { c in c.tab.map { "- [\(c.displayTitle)](\($0.liveItemURL ?? $0.url))" } }
copy(lines.joined(separator: "\n"))
}
menu.addItem(.separator())
@@ -232,6 +234,43 @@ enum SidebarMenus {
// MARK: Splits
+ /// Live Folders ▸ in the sidebar's and the space header's menus, after GitHub: the GitLab folders like
+ /// the GitHub one (✓ while there, a click asks to delete it; one per instance), then GitLab… to add one.
+ static func addGitLabFolders(to menu: NSMenu, space: UUID, store: SidebarStore, window: NSWindow?) {
+ let gitlabs = store.liveFolders.filter { $0.liveFolder?.source == .gitlab && store.isInSpace($0.id, space) }
+ .sorted { ($0.liveFolder?.serverURL ?? "") < ($1.liveFolder?.serverURL ?? "") }
+ for folder in gitlabs {
+ let server = folder.liveFolder?.serverURL.map(GitLabLiveClient.serverLabel) ?? ""
+ add(menu, "GitLab (\(server))", on: true) { confirmDeleteLiveFolder(folder, store: store, in: window) }
+ }
+ add(menu, "GitLab…", enabled: !store.isStandalone(space: space) && window != nil) {
+ if let window { newGitLabFolder(space: space, store: store, window: window) }
+ }
+ }
+
+ /// GitLab…: Arc has no GitLab folder, so this asks for the instance in Arc's text-input dialog (the
+ /// Rename Profile sheet's shape) and adds a folder like its GitHub one. Empty means gitlab.com.
+ private static func newGitLabFolder(space: UUID, store: SidebarStore, window: NSWindow) {
+ let dialog = AppDialog(title: "Add a GitLab Live Folder",
+ message: "Enter your GitLab’s address, or leave it empty for GitLab.com. The folder signs in with this Space’s Profile.",
+ actions: [DialogAction("Add Folder"), .cancel], input: "", placeholder: "https://gitlab.com",
+ icon: .none, width: 496, buttonSpacing: 30, buttonOutset: 0)
+ dialog.present(over: window) { response in
+ guard response == .alertFirstButtonReturn else { return }
+ let address = (dialog.input ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+ guard let server = GitLabLiveClient.serverURL(address.isEmpty ? "https://gitlab.com" : address) else {
+ DispatchQueue.main.async {
+ AppDialog(title: "That isn’t a GitLab address",
+ message: "Use the address you open GitLab at, like https://gitlab.example.com.").runModal(over: window)
+ }
+ return
+ }
+ guard let folder = store.createLiveFolder(.gitlab, inSpace: space, serverURL: server) else { return }
+ store.setExpanded(folder.id, true)
+ LiveFolderManager.shared.refresh(folder.id, force: true)
+ }
+ }
+
/// Arc 1.171's split menu, item for item where Cra has the feature (no Share or Change Icon).
/// It is pinned by dragging it into Pinned or with Pin Tab (⌘D), not from here.
static func split(_ m: SplitRowModel, list: SpaceListView) -> NSMenu {
@@ -309,9 +348,14 @@ enum SidebarMenus {
}
add(menu, action: "newTab", "New Tab") { actions.openCommandBar(.newTab) }
add(menu, action: "newFolder") { actions.performAction("newFolder") }
- add(menu, action: "newGitHubLiveFolder", enabled: store.liveFolder(.github, inSpace: space) == nil) {
- actions.performAction("newGitHubLiveFolder")
+ let liveFolders = submenu(menu, "Live Folders")
+ let github = store.liveFolder(.github, inSpace: space)
+ add(liveFolders, action: "newGitHubLiveFolder", "GitHub",
+ enabled: !store.isStandalone(space: space), on: github != nil) {
+ if let github { confirmDeleteLiveFolder(github, store: store, in: list.window) }
+ else { actions.performAction("newGitHubLiveFolder") }
}
+ addGitLabFolders(to: liveFolders, space: space, store: store, window: list.window)
menu.addItem(.separator())
if let s = store.space(space), !store.children(of: s.todayContainerID).isEmpty {
add(menu, action: "clearToday") { store.clearToday(space) }
diff --git a/Sources/Cra/UI/Sidebar/List/SidebarRowViews.swift b/Sources/Cra/UI/Sidebar/List/SidebarRowViews.swift
index 6b10ea6..76276d4 100644
--- a/Sources/Cra/UI/Sidebar/List/SidebarRowViews.swift
+++ b/Sources/Cra/UI/Sidebar/List/SidebarRowViews.swift
@@ -387,10 +387,10 @@ final class SidebarFaviconView: NSImageView {
}
}
- func showGitHubMark(colors: SidebarColors, color: NSColor? = nil) {
+ func showGitHubMark(colors: SidebarColors, color: NSColor? = nil, source: LiveFolderSource = .github) {
shown = nil
imageScaling = .scaleProportionallyUpOrDown
- image = GitHubMark.image
+ image = source == .gitlab ? GitLabMark.image : GitHubMark.image
contentTintColor = color ?? colors.monoGlyph
layer?.masksToBounds = false
}
@@ -461,13 +461,15 @@ final class FolderGlyphView: NSView {
override var isFlipped: Bool { true }
override func hitTest(_ point: NSPoint) -> NSView? { nil }
- func show(expanded: Bool, peeked: Bool = false, live: Bool, tint: NSColor, fillColor: NSColor, backColor: NSColor? = nil, animated: Bool = false) {
+ func show(expanded: Bool, peeked: Bool = false, live: Bool, tint: NSColor, fillColor: NSColor, backColor: NSColor? = nil, animated: Bool = false,
+ source: LiveFolderSource = .github) {
CATransaction.begin()
CATransaction.setDisableActions(true)
back.fillColor = (backColor ?? fillColor).cgColor
frontPanel.fillColor = fillColor.cgColor
for l in [back, frontPanel] { l.strokeColor = tint.cgColor }
mark.isHidden = !live
+ mark.image = source == .gitlab ? GitLabMark.image : GitHubMark.image
mark.contentTintColor = tint
dots.isHidden = !peeked || expanded || live
dots.fillColor = tint.cgColor
@@ -907,6 +909,7 @@ struct TabRowModel: Equatable {
var peekIcon: NSImage?
/// Tidy Tab Titles just renamed it: the row plays Arc's rename once.
var tidyRename: TidyTitlesService.Effect? = nil
+ var gitlabMark: Bool = false
}
final class TabRowView: SidebarRowView, ArcTooltipTarget, NSTextFieldDelegate {
@@ -1222,8 +1225,8 @@ final class TabRowView: SidebarRowView, ArcTooltipTarget, NSTextFieldDelegate {
guard let m = model else { return }
if overIcon && !separating {
favicon.show(m.homeIcon, flip: m.homeFlipIcon, colors: colors)
- } else if m.githubMark {
- favicon.showGitHubMark(colors: colors)
+ } else if m.githubMark || m.gitlabMark {
+ favicon.showGitHubMark(colors: colors, source: m.gitlabMark ? .gitlab : .github)
} else {
favicon.show(m.icon, flip: m.flipIcon, colors: colors)
}
@@ -1525,6 +1528,7 @@ struct FolderRowModel: Equatable {
/// Where the warning button signs in, when GitHub asked for that (else it tries again).
var liveSignInURL: String?
var liveHelp: String
+ var liveSource: LiveFolderSource? = nil
}
final class FolderRowView: SidebarRowView, NSTextFieldDelegate {
@@ -1549,7 +1553,8 @@ final class FolderRowView: SidebarRowView, NSTextFieldDelegate {
// The same folder opening or closing turns its glyph; a row taking another folder doesn't.
let toggled = model.map { $0.id == m.id && $0.expanded != m.expanded } ?? false
model = m
- glyph.show(expanded: m.expanded, peeked: m.peeked, live: m.live, tint: m.tint, fillColor: m.fill, backColor: m.back, animated: toggled && window != nil)
+ glyph.show(expanded: m.expanded, peeked: m.peeked, live: m.live,
+ tint: m.tint, fillColor: m.fill, backColor: m.back, animated: toggled && window != nil, source: m.liveSource ?? .github)
titleLabel.stringValue = m.title
titleLabel.textColor = colors.textPrimary
setAccessibilityLabel(m.title)
diff --git a/Sources/Cra/UI/Sidebar/List/SpaceColumnView.swift b/Sources/Cra/UI/Sidebar/List/SpaceColumnView.swift
index 86238a8..069a421 100644
--- a/Sources/Cra/UI/Sidebar/List/SpaceColumnView.swift
+++ b/Sources/Cra/UI/Sidebar/List/SpaceColumnView.swift
@@ -449,12 +449,13 @@ enum SpaceMenu {
let github = store.liveFolder(.github, inSpace: id)
MenuItems.add(live, "GitHub", on: github != nil) {
if let github {
- SidebarMenus.confirmDeleteLiveFolder(github, store: store)
+ SidebarMenus.confirmDeleteLiveFolder(github, store: store, in: anchor.window)
} else if let f = store.createLiveFolder(.github, inSpace: id) {
store.setExpanded(f.id, true)
LiveFolderManager.shared.refresh(f.id)
}
}
+ SidebarMenus.addGitLabFolders(to: live, space: id, store: store, window: anchor.window)
m.addItem(.separator())
let export = MenuItems.submenu(m, "Export “\(space.title)” into Folder")
for s in store.orderedSpaces {
diff --git a/Sources/Cra/UI/Sidebar/List/SpaceListView.swift b/Sources/Cra/UI/Sidebar/List/SpaceListView.swift
index 1ba02a5..c10b91f 100644
--- a/Sources/Cra/UI/Sidebar/List/SpaceListView.swift
+++ b/Sources/Cra/UI/Sidebar/List/SpaceListView.swift
@@ -266,7 +266,7 @@ final class SpaceListView: NSView, NSDraggingSource {
tabCount: expanded ? 0 : store.tabs(under: item.id).count,
liveBusy: refreshing.contains(item.id), liveError: item.liveFolder.flatMap(LiveFolderText.warning)?.help,
liveSignInURL: item.liveFolder.flatMap(LiveFolderText.warning)?.signInURL,
- liveHelp: LiveFolderText.refreshHelp(item.liveFolder)))
+ liveHelp: LiveFolderText.refreshHelp(item.liveFolder), liveSource: item.liveFolder?.source))
out.append(row)
guard expanded else {
// Arc keeps the open tab of a closed folder in sight, one level in (FolderPeek).
@@ -280,7 +280,7 @@ final class SpaceListView: NSView, NSDraggingSource {
for c in store.children(of: item.id) {
add(c, depth: depth + 1, pinned: pinned, parent: item.id, index: kids.firstIndex(of: c.id) ?? 0)
}
- if item.isLiveFolder, let m = Self.liveStatus(item) {
+ if item.isLiveFolder, let m = Self.liveStatus(item, hasTabs: !store.tabs(under: item.id).isEmpty) {
out.append(Row(key: .liveStatus(item.id), content: .liveStatus(LiveStatusModel(text: m.text, url: m.url, depth: depth + 1))))
}
} else if let tab = item.tab {
@@ -294,10 +294,11 @@ final class SpaceListView: NSView, NSDraggingSource {
let subtitle = tidyRename != nil ? TidyTitlesService.subtitle : tab.sidebarSubtitle(developerMode: developerMode)
// Arc's tidy titles: a known site's page shows a shorter title unless the tab has a name.
let title = item.title == nil ? TidyTitleRules.arc.tidy(item.displayTitle, url: tab.url) : item.displayTitle
+ let liveSource = tab.liveItemURL != nil && tab.customIconKey == nil ? store.liveFolder(containing: parent)?.liveFolder?.source : nil
row.content = .tab(TabRowModel(
id: item.id, depth: depth, pinned: pinned, title: title, customTitle: item.title != nil,
renameText: item.title ?? title, subtitle: subtitle,
- icon: img, flipIcon: flip, githubMark: tab.liveItemURL != nil && tab.customIconKey == nil,
+ icon: img, flipIcon: flip, githubMark: liveSource == .github,
editing: renaming == item.id, selected: selected,
highlighted: picks.isEmpty ? selected && !placeholder : picks.contains(item.id),
capturing: capturing.contains(item.id), audible: audible.contains(item.id), muted: tab.muted, unread: item.isUnread,
@@ -305,7 +306,7 @@ final class SpaceListView: NSView, NSDraggingSource {
focusRing: focusID == item.id, developerMode: developerMode, peeked: peeked,
homeIcon: homeImg, homeFlipIcon: homeFlip,
peekIcon: ui.peekBadge?.tabID == item.id ? icon(ui.peekBadge?.iconKey).0 : nil,
- tidyRename: tidyRename))
+ tidyRename: tidyRename, gitlabMark: liveSource == .gitlab))
out.append(row)
} else if item.isSplit {
let children = store.children(of: item.id).filter(\.isTab)
@@ -358,8 +359,17 @@ final class SpaceListView: NSView, NSDraggingSource {
/// A line inside the open live folder when there are no pull requests to show, or GitHub
/// can't be read (Arc: "Sign back in to GitHub.", "Login with SSO to unlock this folder").
- private static func liveStatus(_ item: SidebarItem) -> (text: String, url: String?)? {
- guard let live = item.liveFolder, item.children.isEmpty else { return nil }
+ private static func liveStatus(_ item: SidebarItem, hasTabs: Bool) -> (text: String, url: String?)? {
+ guard let live = item.liveFolder, !hasTabs else { return nil }
+ // GitLab: the GitHub folder's lines, in GitLab's words.
+ if live.source == .gitlab {
+ switch live.lastError {
+ case .notSignedIn?: return ("Sign back in to GitLab.", live.signInURL)
+ case .some: return ("We’re having trouble connecting to GitLab; click here to see your Merge Requests.",
+ live.serverURL.map { "\($0)/dashboard/merge_requests" })
+ case nil: return live.lastFetch == nil ? nil : ("Merge requests from you and your team will show up here automatically", nil)
+ }
+ }
switch live.lastError {
case .notSignedIn?: return ("Sign back in to GitHub.", live.signInURL)
case .some: return ("We’re having trouble connecting to GitHub; click here to see your Pull Requests.", "https://github.com/pulls")
@@ -1081,9 +1091,9 @@ final class SpaceListView: NSView, NSDraggingSource {
// A live folder fills itself: nothing goes into it from outside, and its tabs make no new folders.
switch target {
- case .into(let f)? where store.item(f)?.isLiveFolder == true: target = nil
- case .insert(let parent, _)? where store.item(parent)?.isLiveFolder == true && store.item(id)?.parentID != parent: target = nil
- case .split(let tab, _)? where store.item(store.item(tab)?.parentID ?? tab)?.isLiveFolder == true: target = nil
+ case .into(let f)? where store.liveFolder(containing: f) != nil: target = nil
+ case .insert(let parent, _)? where store.liveFolder(containing: parent) != nil && store.item(id)?.parentID != parent: target = nil
+ case .split(let tab, _)? where store.liveFolder(containing: tab) != nil: target = nil
default: break
}
diff --git a/Sources/Cra/UI/Sidebar/LiveFolderViews.swift b/Sources/Cra/UI/Sidebar/LiveFolderViews.swift
index fc3b0a3..e1ac783 100644
--- a/Sources/Cra/UI/Sidebar/LiveFolderViews.swift
+++ b/Sources/Cra/UI/Sidebar/LiveFolderViews.swift
@@ -16,6 +16,17 @@ enum GitHubMark {
}()
}
+/// GitLab's tanuki in one colour, tinted like GitHubMark: Arc draws its GitHub folder's mark in the
+/// folder's ink, so the GitLab folder does the same rather than show the full-colour logo.
+enum GitLabMark {
+ static let image: NSImage = {
+ let svg = #"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 25 24" width="16" height="16"><path d="m24.507 9.5-.034-.09L21.082.562a.896.896 0 0 0-1.694.091l-2.29 7.01H7.825L5.535.653a.898.898 0 0 0-1.694-.09L.451 9.411.416 9.5a6.297 6.297 0 0 0 2.09 7.278l.012.01.03.022 5.16 3.867 2.56 1.935 1.554 1.176a1.051 1.051 0 0 0 1.268 0l1.555-1.176 2.56-1.935 5.197-3.89.014-.01A6.297 6.297 0 0 0 24.507 9.5Z"/></svg>"#
+ let img = NSImage(data: Data(svg.utf8)) ?? NSImage()
+ img.isTemplate = true
+ return img
+ }()
+}
+
enum LiveFolderText {
private static let relative: RelativeDateTimeFormatter = {
let f = RelativeDateTimeFormatter()
@@ -24,7 +35,7 @@ enum LiveFolderText {
}()
static func lastUpdate(_ live: LiveFolderData) -> String {
- if let error = live.lastError { return status(error) }
+ if let error = live.lastError { return status(error, source: live.source) }
guard let last = live.lastFetch else { return "Not updated yet" }
if Date().timeIntervalSince(last) < 60 { return "Updated just now" }
return "Updated \(relative.localizedString(for: last, relativeTo: Date()))"
@@ -38,20 +49,20 @@ enum LiveFolderText {
/// The folder's warning button: Arc's tip, and where a click signs in (nil: it tries again).
static func warning(_ live: LiveFolderData) -> (help: String, signInURL: String?)? {
switch live.lastError {
- case .notSignedIn?: return ("Sign back in to GitHub.", live.signInURL)
- case let error?: return ("\(status(error)). Click to try again.", nil)
+ case .notSignedIn?: return ("Sign back in to \(live.source.title).", live.signInURL)
+ case let error?: return ("\(status(error, source: live.source)). Click to try again.", nil)
case nil:
guard let org = live.ssoOrganizations.first else { return nil }
return ("Login with SSO to unlock this folder", "https://github.com/orgs/\(org)/sso")
}
}
- static func status(_ error: LiveFolderError) -> String {
+ static func status(_ error: LiveFolderError, source: LiveFolderSource = .github) -> String {
switch error {
- case .notSignedIn: return "Not signed in to GitHub"
- case .rateLimited: return "GitHub rate limit exceeded"
- case .unexpectedPage: return "Failed to update: unexpected GitHub page"
- case .network: return "Failed to update: GitHub can’t be reached"
+ case .notSignedIn: return "Not signed in to \(source.title)"
+ case .rateLimited: return "\(source.title) rate limit exceeded"
+ case .unexpectedPage: return "Failed to update: unexpected \(source.title) response"
+ case .network: return "Failed to update: \(source.title) can’t be reached"
}
}
}
diff --git a/Tests/StoreTests.swift b/Tests/StoreTests.swift
index c421053..620cfba 100644
--- a/Tests/StoreTests.swift
+++ b/Tests/StoreTests.swift
@@ -27,6 +27,13 @@ enum StoreTests {
integrity()
liveFolderExpiry()
liveFolderSignIn()
+ gitLabHiddenItems()
+ gitLabFolderExpiryAndDeletion()
+ gitLabMultipleServers()
+ liveFoldersRejectStandaloneSpaces()
+ gitLabProfileChangeClearsResults()
+ gitLabFolderMovesRejectDuplicateServers()
+ gitLabProfileChangeKeepsNavigatedPages()
stampsUseTheClock()
persistenceFaults()
incognitoStaysOffDisk()
@@ -346,6 +353,168 @@ enum StoreTests {
expect(store.integrityProblems().isEmpty, "live folder changes keep the sidebar sound")
}
+ private static func gitLabRequest(_ number: Int, server: String = "https://git.example.test") -> LivePullRequest {
+ var request = LivePullRequest(owner: "company/team", repo: "app", number: number, title: "Merge request \(number)", createdByMe: true)
+ request.webURL = "\(server)/company/team/app/-/merge_requests/\(number)"
+ return request
+ }
+
+ @MainActor
+ private static func liveFoldersRejectStandaloneSpaces() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let windows = [store.addBlankWindow(frame: nil), store.addIncognitoWindow(frame: nil)]
+ for window in windows {
+ let space = store.focusedSpaceID(window: window.id)
+ for source in [LiveFolderSource.github, .gitlab] {
+ expect(store.createLiveFolder(source, inSpace: space, serverURL: source == .gitlab ? "https://gitlab.com" : nil) == nil,
+ "neither provider creates live folders inside Blank or Incognito windows")
+ }
+ }
+ expect(store.integrityProblems().isEmpty, "rejected live folders leave standalone windows unchanged")
+ }
+
+ @MainActor
+ private static func gitLabProfileChangeKeepsNavigatedPages() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let space = store.createSpace(title: "GitLab navigated pages", emoji: "G", focus: true)
+ guard let folder = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test") else { return expect(false, "a GitLab folder exists") }
+ store.applyLiveResults([gitLabRequest(60)], to: folder.id, ssoOrganizations: [])
+ guard let tab = store.tabs(under: folder.id).first else { return expect(false, "an MR tab exists") }
+ store.selectTab(tab.id)
+ store.updateTab(tab.id, url: "https://example.test/reading", title: "Reading")
+ let profile = store.createProfile(name: "Other account")
+ store.setProfile(profile.id, forSpace: space.id)
+ expect(store.item(tab.id)?.tab?.url == "https://example.test/reading" && store.item(tab.id)?.tab?.savedTitle == "Reading",
+ "a profile change keeps the page a live tab navigated to")
+ expect(store.item(tab.id)?.parentID == space.todayContainerID && store.selectedTabID == tab.id,
+ "the navigated page remains selected as an ordinary Today tab")
+ expect(store.item(tab.id)?.tab?.liveItemURL == nil && store.integrityProblems().isEmpty,
+ "the preserved page is no longer controlled by the live folder")
+ }
+
+ @MainActor
+ private static func gitLabProfileChangeClearsResults() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let space = store.createSpace(title: "GitLab profiles", emoji: "G", focus: true)
+ guard let folder = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test") else { return expect(false, "a GitLab folder exists") }
+ store.applyLiveResults([gitLabRequest(41)], to: folder.id, ssoOrganizations: [])
+ let oldContext = store.liveRequestContext(folder.id)
+ store.updateLiveFolder(folder.id) { $0.hiddenItems = ["https://git.example.test/private/mr"] }
+ let profile = store.createProfile(name: "Other GitLab account")
+ store.setProfile(profile.id, forSpace: space.id)
+ expect(store.tabs(under: folder.id).isEmpty, "changing profile clears the previous account's MR tabs")
+ expect(store.item(folder.id)?.liveFolder?.lastFetch == nil, "changing profile makes the folder refresh at once")
+ expect(store.item(folder.id)?.liveFolder?.hiddenItems.isEmpty == true, "the new profile does not inherit another account's exclusions")
+ store.applyLiveResults([gitLabRequest(41)], to: folder.id, ssoOrganizations: [], context: oldContext)
+ store.applyLiveFailure(.notSignedIn, to: folder.id, context: oldContext)
+ expect(store.tabs(under: folder.id).isEmpty && store.item(folder.id)?.liveFolder?.lastError == nil,
+ "late successes and failures from the previous profile are ignored")
+ store.setProfile(nil, forSpace: space.id)
+ expect(store.liveRequestContext(folder.id) != oldContext, "switching away and back still invalidates the original request")
+ store.applyLiveResults([gitLabRequest(41)], to: folder.id, ssoOrganizations: [], context: oldContext)
+ expect(store.tabs(under: folder.id).isEmpty, "returning to the original profile cannot revive an obsolete response")
+ expect(store.integrityProblems().isEmpty, "profile invalidation keeps the tree sound")
+ }
+
+ @MainActor
+ private static func gitLabFolderMovesRejectDuplicateServers() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let a = store.createSpace(title: "GitLab A", emoji: "A", focus: true)
+ let b = store.createSpace(title: "GitLab B", emoji: "B", focus: false)
+ guard let one = store.createLiveFolder(.gitlab, inSpace: a.id, serverURL: "https://git.example.test"),
+ let two = store.createLiveFolder(.gitlab, inSpace: b.id, serverURL: "https://git.example.test") else { return expect(false, "both spaces have a server folder") }
+ store.moveTab(one.id, toSpace: b.id)
+ expect(store.spaceID(ofItem: one.id) == a.id && store.spaceID(ofItem: two.id) == b.id, "a folder move cannot create a duplicate server in the destination")
+ let wrapper = store.createFolder(named: "Work", in: a.pinnedContainerID)
+ store.moveItem(one.id, to: wrapper.id, index: nil)
+ store.moveTab(wrapper.id, toSpace: b.id)
+ expect(store.spaceID(ofItem: wrapper.id) == a.id, "wrapping a live folder does not bypass server uniqueness")
+ let c = store.createSpace(title: "GitLab C", emoji: "C", focus: false)
+ let profile = store.createProfile(name: "GitLab C account")
+ store.setProfile(profile.id, forSpace: c.id)
+ store.applyLiveResults([gitLabRequest(42)], to: one.id, ssoOrganizations: [])
+ let context = store.liveRequestContext(one.id)
+ store.moveTab(wrapper.id, toSpace: c.id)
+ expect(store.spaceID(ofItem: one.id) == c.id && store.tabs(under: one.id).isEmpty,
+ "moving a wrapper to a different profile invalidates its live folder results")
+ store.applyLiveResults([gitLabRequest(42)], to: one.id, ssoOrganizations: [], context: context)
+ expect(store.tabs(under: one.id).isEmpty, "a pre-move response cannot cross into the new profile")
+ expect(store.integrityProblems().isEmpty, "rejected moves keep both spaces sound")
+ }
+
+ @MainActor
+ private static func gitLabMultipleServers() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let space = store.createSpace(title: "GitLab servers", emoji: "G", focus: true)
+ guard let one = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test"),
+ let two = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://gitlab.com") else {
+ return expect(false, "folders for two GitLab servers can be created")
+ }
+ expect(one.id != two.id && one.title == "Merge Requests" && two.title == "Merge Requests",
+ "each server has its own folder, named like Arc's Pull Requests folder")
+ expect(one.liveFolder?.filter.attributes == [.authored, .reviewRequests, .assigned], "every filter starts on, as in Arc")
+ let duplicate = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "HTTPS://GIT.EXAMPLE.TEST:443/")
+ expect(duplicate?.id == one.id, "equivalent server URLs reuse the existing folder")
+ expect(store.liveFolder(.gitlab, inSpace: space.id, serverURL: "gitlab.com/")?.id == two.id, "server lookup identifies the right folder")
+ store.applyLiveResults([gitLabRequest(30)], to: one.id, ssoOrganizations: [])
+ store.applyLiveResults([gitLabRequest(30, server: "https://gitlab.com")], to: two.id, ssoOrganizations: [])
+ if let tab = store.tabs(under: one.id).first { store.archiveTab(tab.id, reason: .manual) }
+ expect(store.item(one.id)?.liveFolder?.hiddenItems.count == 1 && store.item(two.id)?.liveFolder?.hiddenItems.isEmpty == true,
+ "hidden lists are independent even for matching project names and MR numbers")
+ let three = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test:8443/gitlab")
+ expect(three != nil && three?.id != one.id, "ports and installation paths distinguish GitLab instances")
+ expect(store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "file:///etc") == nil, "invalid servers are rejected")
+ let github = store.createLiveFolder(.github, inSpace: space.id)
+ expect(store.createLiveFolder(.github, inSpace: space.id)?.id == github?.id, "GitHub still has one folder per space")
+ store.deleteFolder(one.id)
+ expect(store.item(two.id) != nil && store.tabs(under: two.id).count == 1, "deleting a server folder leaves the other server untouched")
+ expect(store.integrityProblems().isEmpty, "multiple server folders keep the sidebar sound")
+ }
+
+ @MainActor
+ private static func gitLabHiddenItems() {
+ let store = AppComposition(clock: ManualScheduler()).store
+ let space = store.createSpace(title: "GitLab hidden", emoji: "G", focus: true)
+ guard let folder = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test") else {
+ return expect(false, "a GitLab live folder is made")
+ }
+ let requests = [gitLabRequest(10), gitLabRequest(11)]
+ store.applyLiveResults(requests, to: folder.id, ssoOrganizations: [])
+ for tab in store.tabs(under: folder.id) { store.archiveTab(tab.id, reason: .manual) }
+ expect(Set(store.item(folder.id)?.liveFolder?.hiddenItems ?? []) == Set(requests.map(\.url)), "closing an MR's tab hides it, as in Arc")
+ store.applyLiveResults(requests, to: folder.id, ssoOrganizations: [])
+ expect(store.tabs(under: folder.id).isEmpty, "refreshing does not restore hidden merge requests")
+ if let archived = store.archive.first(where: { $0.item.tab?.liveItemURL == requests[1].url }) { store.restoreArchived(archived.id, select: false) }
+ expect(store.tabs(under: folder.id).map(\.tab?.liveItemURL) == [requests[1].url], "Reopen Closed Tab puts the MR back in its folder")
+ expect(store.item(folder.id)?.liveFolder?.hiddenItems == [requests[0].url], "the other MR remains hidden")
+ guard let moved = store.tabs(under: folder.id).first else { return expect(false, "a tab can be moved out") }
+ store.moveItem(moved.id, to: space.todayContainerID, index: 0)
+ expect(store.item(folder.id)?.liveFolder?.hiddenItems.count == 2 && store.item(moved.id)?.tab?.liveItemURL == nil,
+ "dragging an MR out of the folder hides it too")
+ expect(store.integrityProblems().isEmpty, "hide and restore keep the sidebar sound")
+ }
+
+ @MainActor
+ private static func gitLabFolderExpiryAndDeletion() {
+ let clock = ManualScheduler()
+ let store = AppComposition(clock: clock).store
+ let space = store.createSpace(title: "GitLab expiry", emoji: "G", focus: true)
+ guard let folder = store.createLiveFolder(.gitlab, inSpace: space.id, serverURL: "https://git.example.test") else {
+ return expect(false, "a GitLab live folder is made")
+ }
+ let requests = [gitLabRequest(20), gitLabRequest(21)]
+ store.applyLiveResults(requests, to: folder.id, ssoOrganizations: [])
+ store.applyLiveResults([requests[0]], to: folder.id, ssoOrganizations: [])
+ clock.advance(by: 121)
+ store.expireLiveItems(olderThan: 120)
+ expect(store.tabs(under: folder.id).map(\.tab?.liveItemURL) == [requests[0].url], "a merged MR leaves after the grace period")
+ expect(store.item(folder.id)?.liveFolder?.hiddenItems.isEmpty == true, "automatic expiry never hides an MR")
+ let tabs = store.tabs(under: folder.id).map(\.id)
+ store.deleteFolder(folder.id)
+ expect(store.item(folder.id) == nil && tabs.allSatisfy { store.item($0) == nil }, "deleting the folder deletes its MR tabs")
+ expect(store.integrityProblems().isEmpty, "deleting a live folder leaves no orphan tabs")
+ }
+
/// Every date the store writes comes from its clock.
@MainActor
private static func stampsUseTheClock() {
diff --git a/docs/live-folders.md b/docs/live-folders.md
index c891d6b..813753b 100644
--- a/docs/live-folders.md
+++ b/docs/live-folders.md
@@ -117,3 +117,26 @@ Legend: [O] observed, [I] inference, [U] unknown.
pull request was moved into the folder without a duplicate; no fetch for 2.5 minutes in the background,
one within a second of the window taking focus.
- Not verified: the review trigger (`#pullrequestreview-` anchor) with a real review.
+
+## GitLab live folders (Cra only; contributed by STRENCH0, #223)
+
+Arc has no GitLab source (only `dataSource.github`), so Cra's GitLab folder is Arc's GitHub folder with
+GitLab as the source: the same folder row, menus, dialogs, refresh schedule and hidden items.
+- Live Folders ▸ (space and sidebar menus, Arc's submenu): **GitHub** ✓ while the space has one, then
+ **GitLab (host)** ✓ per GitLab folder, then **GitLab…**. A ✓ item asks Arc's "Delete your %@ Live Folder?"
+ ("You can restore this folder at any time by right-clicking the sidebar.", Delete Folder `↩`).
+- GitLab… asks for the instance in Arc's text-input dialog; empty means `https://gitlab.com`. Self-managed
+ addresses keep their port and subpath (`GitLabLiveClient.serverURL`). One folder per instance per space,
+ named "Merge Requests" (Arc's GitHub one is "Pull Requests").
+- Requests go through `+[CraCEFRuntime fetchURL:…]` on the space's profile, like GitHub's: GitLab takes its
+ session cookie on `GET /api/v4`, so no token. `/api/v4/user` for the user id, then one paged
+ `/api/v4/merge_requests?state=opened` per filter: `scope=created_by_me` (My Merge Requests),
+ `scope=all&reviewer_id=<id>` (Review Requests), `scope=assigned_to_me` (Assigned to Me). All three on by
+ default, as Arc's GitHub filters are. A redirect to another page (a sign-in) reads as signed out.
+- The folder menu is the GitHub one: last update, the instance, Refresh, the three filters, Projects
+ (Arc's Repositories), Sign In to GitLab… when signed out, Rename…, Icon Color, Copy All Links as Markdown,
+ Delete Live Folder. The mark is GitLab's tanuki in one colour, drawn in the folder's ink like GitHub's.
+- A space moving to another profile empties its live folders and fetches again with the new profile;
+ an answer to a request made for the old profile, server or filters is dropped.
+- Left out of #223 as not Arc: category subfolders ("Separate by Category"), "Restore Hidden", a minimum
+ 450 ms refresh spinner and manual refreshes without Arc's 10 s gap.