From 4f5f0085e538ad7f2cd878fe55ef2a52edd8adb1 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 15:11:35 +0700 Subject: [PATCH] feat(sidebar): version history for saved queries and Git status for linked SQL folders --- CHANGELOG.md | 2 + TablePro/Core/Events/AppEvents.swift | 2 + TablePro/Core/Git/GitClient.swift | 73 +++++ TablePro/Core/Git/GitCommand.swift | 91 ++++++ TablePro/Core/Git/GitExecutableLocator.swift | 42 +++ TablePro/Core/Git/GitFileStatus.swift | 126 ++++++++ TablePro/Core/Git/GitOutputParsers.swift | 149 +++++++++ TablePro/Core/Git/GitProcessRunner.swift | 149 +++++++++ .../Tools/MCPTabSnapshotProvider.swift | 1 + .../Core/Scripting/ScriptEnumerations.swift | 1 + .../Infrastructure/EditorTabOpener.swift | 3 + .../MainSplitViewController.swift | 2 +- .../Infrastructure/SQLFileService.swift | 6 + .../Toolbar/ToolbarContextResolver.swift | 6 +- .../Infrastructure/WindowTitleResolver.swift | 5 + .../Services/SQL/GitRepositoryWatcher.swift | 65 ++++ .../SQL/LinkedFolderGitStatusStore.swift | 152 +++++++++ .../Core/Services/SQL/SQLFolderWatcher.swift | 12 +- .../Core/Storage/SQLFavoriteManager.swift | 18 ++ .../Storage/SQLFavoriteStorage+Versions.swift | 148 +++++++++ .../Core/Storage/SQLFavoriteStorage.swift | 1 + .../Core/Utilities/File/FileTextLoader.swift | 17 + .../LinkedFileVersionHistoryProvider.swift | 169 ++++++++++ .../SavedQueryVersionHistoryProvider.swift | 66 ++++ .../VersionHistory/VersionComparison.swift | 23 ++ .../VersionHistory/VersionHistoryModels.swift | 103 ++++++ TablePro/Models/Query/EditorTabPayload.swift | 8 +- TablePro/Models/Query/QueryTab.swift | 4 +- TablePro/Models/Query/QueryTabManager.swift | 24 ++ TablePro/Models/Query/QueryTabState.swift | 8 +- .../Models/Query/SQLFavoriteVersion.swift | 14 + TablePro/Models/UI/GridSelectionOwner.swift | 2 +- TablePro/Models/UI/PendingChangeKind.swift | 2 +- TablePro/Resources/TablePro.sdef | 1 + ...oritesSidebarViewModel+LinkedFolders.swift | 1 + .../ViewModels/VersionHistoryViewModel.swift | 196 ++++++++++++ .../Compare/StructureDefinitionDiffView.swift | 111 +------ .../Main/Child/MainEditorContentView.swift | 34 ++ .../MainContentCoordinator+Refresh.swift | 5 + ...ainContentCoordinator+VersionHistory.swift | 68 ++++ TablePro/Views/Shared/TextDiffView.swift | 143 +++++++++ .../Sidebar/FavoritesOutlineCoordinator.swift | 3 +- .../Views/Sidebar/FavoritesOutlineView.swift | 1 + TablePro/Views/Sidebar/FavoritesTabView.swift | 33 +- .../Views/Sidebar/LinkedFavoriteRowView.swift | 13 + .../Sidebar/Menu/FavoritesMenuCommand.swift | 3 + .../Sidebar/Menu/FavoritesMenuSpec.swift | 28 +- .../VersionHistoryChangesView.swift | 64 ++++ .../VersionHistoryContentView.swift | 22 ++ .../VersionHistoryDetailHeader.swift | 62 ++++ .../VersionHistoryDetailPane.swift | 57 ++++ .../VersionHistoryFactory.swift | 49 +++ .../VersionHistoryFormatting.swift | 80 +++++ .../VersionHistoryListPane.swift | 62 ++++ .../VersionHistoryRowView.swift | 37 +++ .../VersionHistoryTabView.swift | 75 +++++ .../Core/Git/GitIntegrationTests.swift | 268 ++++++++++++++++ .../Core/Git/GitOutputParserTests.swift | 302 ++++++++++++++++++ .../Scripting/ScriptingDictionaryTests.swift | 2 +- .../Services/PersistedTabRoundTripTests.swift | 30 ++ .../Storage/SQLFavoriteVersionTests.swift | 226 +++++++++++++ .../Services/WindowTitleResolverTests.swift | 22 ++ .../VersionHistoryViewModelTests.swift | 280 ++++++++++++++++ .../MainContentCoordinatorRefreshTests.swift | 15 + .../Sidebar/FavoritesMenuSpecTests.swift | 60 ++++ .../SavedQueryHistoryUITests.swift | 78 +++++ docs/external-api/applescript.mdx | 2 +- docs/features/connection-window.mdx | 4 +- docs/features/favorites.mdx | 49 ++- docs/images/linked-file-history-dark.png | Bin 0 -> 295220 bytes docs/images/linked-file-history.png | Bin 0 -> 273506 bytes 71 files changed, 3852 insertions(+), 128 deletions(-) create mode 100644 TablePro/Core/Git/GitClient.swift create mode 100644 TablePro/Core/Git/GitCommand.swift create mode 100644 TablePro/Core/Git/GitExecutableLocator.swift create mode 100644 TablePro/Core/Git/GitFileStatus.swift create mode 100644 TablePro/Core/Git/GitOutputParsers.swift create mode 100644 TablePro/Core/Git/GitProcessRunner.swift create mode 100644 TablePro/Core/Services/SQL/GitRepositoryWatcher.swift create mode 100644 TablePro/Core/Services/SQL/LinkedFolderGitStatusStore.swift create mode 100644 TablePro/Core/Storage/SQLFavoriteStorage+Versions.swift create mode 100644 TablePro/Core/VersionHistory/LinkedFileVersionHistoryProvider.swift create mode 100644 TablePro/Core/VersionHistory/SavedQueryVersionHistoryProvider.swift create mode 100644 TablePro/Core/VersionHistory/VersionComparison.swift create mode 100644 TablePro/Core/VersionHistory/VersionHistoryModels.swift create mode 100644 TablePro/Models/Query/SQLFavoriteVersion.swift create mode 100644 TablePro/ViewModels/VersionHistoryViewModel.swift create mode 100644 TablePro/Views/Main/Extensions/MainContentCoordinator+VersionHistory.swift create mode 100644 TablePro/Views/Shared/TextDiffView.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryChangesView.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryContentView.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryDetailHeader.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryDetailPane.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryFactory.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryFormatting.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryListPane.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryRowView.swift create mode 100644 TablePro/Views/VersionHistory/VersionHistoryTabView.swift create mode 100644 TableProTests/Core/Git/GitIntegrationTests.swift create mode 100644 TableProTests/Core/Git/GitOutputParserTests.swift create mode 100644 TableProTests/Core/Storage/SQLFavoriteVersionTests.swift create mode 100644 TableProTests/ViewModels/VersionHistoryViewModelTests.swift create mode 100644 TableProUITests/SavedQueryHistoryUITests.swift create mode 100644 docs/images/linked-file-history-dark.png create mode 100644 docs/images/linked-file-history.png diff --git a/CHANGELOG.md b/CHANGELOG.md index 5ae86d408a..2a868ad7d2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Tables from every schema in Open Quickly and the sidebar filter, and `schema.table` searches in both. (#3048) - Recent-tab switching on Control-Tab, with a list of the window's tabs while Control is held. (#2524) - **Extensions** for SQLite and local libSQL connections, loading sqlite-vec, SpatiaLite and other libraries on connect. (#2502) +- Version history for saved queries, with **Restore This Version**. (#2505) +- Git status letters, history and **Discard Changes…** for files in a linked SQL folder. (#2505) ### Changed diff --git a/TablePro/Core/Events/AppEvents.swift b/TablePro/Core/Events/AppEvents.swift index 787b557672..5c10196086 100644 --- a/TablePro/Core/Events/AppEvents.swift +++ b/TablePro/Core/Events/AppEvents.swift @@ -115,6 +115,8 @@ final class AppEvents { /// uniformly handle "this update may affect me" via `payload == nil || payload == self.connectionId`. let linkedSQLFoldersDidUpdate = PassthroughSubject() + let versionHistoryRefreshRequested = PassthroughSubject() + // MARK: - License & Sync let licenseStatusDidChange = PassthroughSubject() diff --git a/TablePro/Core/Git/GitClient.swift b/TablePro/Core/Git/GitClient.swift new file mode 100644 index 0000000000..e81f6e3938 --- /dev/null +++ b/TablePro/Core/Git/GitClient.swift @@ -0,0 +1,73 @@ +// +// GitClient.swift +// TablePro +// + +import Foundation +import os + +internal struct GitCommandFailure: LocalizedError, Equatable { + let exitCode: Int32 + let message: String + + var errorDescription: String? { + message.isEmpty ? String(format: String(localized: "Git exited with status %d."), exitCode) : message + } +} + +internal struct GitClient: Sendable { + private static let logger = Logger(subsystem: "com.TablePro", category: "GitClient") + + let runner: GitProcessRunner + + static func make(locator: GitExecutableLocator = .system) -> GitClient? { + locator.locate().map { GitClient(runner: GitProcessRunner(executableURL: $0)) } + } + + func repositoryInfo(in directory: URL) async throws -> GitRepositoryInfo? { + let result = try await runner.run(.repositoryInfo(in: directory)) + guard result.succeeded else { + Self.logger.debug("Not a work tree: \(result.errorMessage, privacy: .private)") + return nil + } + return GitRepositoryInfoParser.parse(result.standardOutput) + } + + func hasCommits(in directory: URL) async throws -> Bool { + try await headCommit(in: directory) != nil + } + + func headCommit(in directory: URL) async throws -> String? { + let result = try await runner.run(.verifyHead(in: directory)) + guard result.succeeded else { return nil } + return (String(bytes: result.standardOutput, encoding: .utf8) ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + } + + func status(in directory: URL, pathspec: String = ".") async throws -> [GitStatusRecord] { + let result = try await runner.run(.status(in: directory, pathspec: pathspec)) + guard result.succeeded else { throw failure(result) } + return GitStatusParser.parse(result.standardOutput) + } + + func trackedFiles(in directory: URL) async throws -> [String] { + let result = try await runner.run(.trackedFiles(in: directory)) + guard result.succeeded else { throw failure(result) } + return GitOutputTokens.split(result.standardOutput, separator: 0).filter { !$0.isEmpty } + } + + func history(of fileURL: URL, limit: Int) async throws -> [GitCommitRecord] { + let result = try await runner.run(.fileHistory(of: fileURL, limit: limit)) + guard result.succeeded else { throw failure(result) } + return GitLogParser.parse(result.standardOutput) + } + + func blob(revision: String, path: String, in directory: URL) async throws -> Data { + let result = try await runner.run(.blob(revision: revision, path: path, in: directory)) + guard result.succeeded else { throw failure(result) } + return result.standardOutput + } + + private func failure(_ result: GitProcessResult) -> GitCommandFailure { + GitCommandFailure(exitCode: result.exitCode, message: result.errorMessage) + } +} diff --git a/TablePro/Core/Git/GitCommand.swift b/TablePro/Core/Git/GitCommand.swift new file mode 100644 index 0000000000..c9fef8c942 --- /dev/null +++ b/TablePro/Core/Git/GitCommand.swift @@ -0,0 +1,91 @@ +// +// GitCommand.swift +// TablePro +// + +import Foundation + +internal struct GitCommand: Equatable, Sendable { + let arguments: [String] + let workingDirectory: URL + + static let hardeningArguments: [String] = [ + "--no-optional-locks", + "--no-pager", + "--literal-pathspecs", + "-c", "core.fsmonitor=false", + "-c", "core.hooksPath=/dev/null", + "-c", "color.ui=never", + "-c", "log.showSignature=false", + "-c", "safe.bareRepository=explicit", + ] + + static let environmentOverrides: [String: String] = [ + "GIT_OPTIONAL_LOCKS": "0", + "GIT_TERMINAL_PROMPT": "0", + "GIT_PAGER": "cat", + "GIT_NO_LAZY_FETCH": "1", + ] + + static let inheritedRepositoryVariables: Set = [ + "GIT_DIR", + "GIT_WORK_TREE", + "GIT_INDEX_FILE", + "GIT_OBJECT_DIRECTORY", + "GIT_ALTERNATE_OBJECT_DIRECTORIES", + "GIT_COMMON_DIR", + "GIT_NAMESPACE", + "GIT_CEILING_DIRECTORIES", + "GIT_CONFIG_PARAMETERS", + "GIT_CONFIG_COUNT", + "GIT_EXTERNAL_DIFF", + ] + + static let historyFormat = "%x1e%H%x1f%an%x1f%aI%x1f%s" + + var processArguments: [String] { + Self.hardeningArguments + arguments + } + + static func environment(base: [String: String]) -> [String: String] { + var environment = base.filter { !inheritedRepositoryVariables.contains($0.key) } + environment.merge(environmentOverrides) { _, override in override } + return environment + } + + static func repositoryInfo(in directory: URL) -> GitCommand { + GitCommand( + arguments: ["rev-parse", "--show-toplevel", "--absolute-git-dir", "--show-prefix"], + workingDirectory: directory + ) + } + + static func verifyHead(in directory: URL) -> GitCommand { + GitCommand(arguments: ["rev-parse", "--verify", "--quiet", "HEAD"], workingDirectory: directory) + } + + static func status(in directory: URL, pathspec: String = ".") -> GitCommand { + GitCommand( + arguments: ["status", "--porcelain=v2", "-z", "--untracked-files=all", "--find-renames", "--", pathspec], + workingDirectory: directory + ) + } + + static func trackedFiles(in directory: URL) -> GitCommand { + GitCommand(arguments: ["ls-files", "-z", "--full-name", "--", "."], workingDirectory: directory) + } + + static func fileHistory(of fileURL: URL, limit: Int) -> GitCommand { + GitCommand( + arguments: [ + "log", "--follow", "-z", "--no-color", "--no-show-signature", "--name-status", + "--max-count=\(limit)", "--format=\(historyFormat)", "--", fileURL.lastPathComponent, + ], + workingDirectory: fileURL.deletingLastPathComponent() + ) + } + + static func blob(revision: String, path: String, in directory: URL) -> GitCommand { + GitCommand(arguments: ["cat-file", "blob", "--end-of-options", "\(revision):\(path)"], workingDirectory: directory) + } +} diff --git a/TablePro/Core/Git/GitExecutableLocator.swift b/TablePro/Core/Git/GitExecutableLocator.swift new file mode 100644 index 0000000000..2e5f2490d3 --- /dev/null +++ b/TablePro/Core/Git/GitExecutableLocator.swift @@ -0,0 +1,42 @@ +// +// GitExecutableLocator.swift +// TablePro +// + +import Foundation + +internal struct GitExecutableLocator: Sendable { + static let developerDirectoryLink = "/var/db/xcode_select_link" + static let homebrewCandidates = ["/opt/homebrew/bin/git", "/usr/local/bin/git"] + static let commandLineToolsGit = "/Library/Developer/CommandLineTools/usr/bin/git" + static let defaultXcodeGit = "/Applications/Xcode.app/Contents/Developer/usr/bin/git" + static let installerShim = "/usr/bin/git" + + let isExecutable: @Sendable (String) -> Bool + let developerDirectory: @Sendable () -> String? + + static let system = GitExecutableLocator( + isExecutable: { FileManager.default.isExecutableFile(atPath: $0) }, + developerDirectory: { try? FileManager.default.destinationOfSymbolicLink(atPath: developerDirectoryLink) } + ) + + func candidates() -> [String] { + var paths = Self.homebrewCandidates + if let developerDirectory = developerDirectory(), developerDirectory.hasPrefix("/") { + paths.append((developerDirectory as NSString).appendingPathComponent("usr/bin/git")) + } + paths.append(Self.commandLineToolsGit) + paths.append(Self.defaultXcodeGit) + + var seen: Set = [] + return paths.filter { path in + let standardized = (path as NSString).standardizingPath + guard standardized != Self.installerShim else { return false } + return seen.insert(standardized).inserted + } + } + + func locate() -> URL? { + candidates().first(where: isExecutable).map { URL(fileURLWithPath: $0) } + } +} diff --git a/TablePro/Core/Git/GitFileStatus.swift b/TablePro/Core/Git/GitFileStatus.swift new file mode 100644 index 0000000000..7013e9e429 --- /dev/null +++ b/TablePro/Core/Git/GitFileStatus.swift @@ -0,0 +1,126 @@ +// +// GitFileStatus.swift +// TablePro +// + +import Foundation + +internal struct GitFileStatus: Hashable, Sendable { + internal enum Change: Hashable, Sendable { + case unmodified + case modified + case added + case deleted + case renamed + case copied + case typeChanged + case unmerged + + init(code: Character) { + switch code { + case "M": self = .modified + case "A": self = .added + case "D": self = .deleted + case "R": self = .renamed + case "C": self = .copied + case "T": self = .typeChanged + case "U": self = .unmerged + default: self = .unmodified + } + } + } + + internal enum Badge: Hashable, Sendable { + case modified + case added + case renamed + case untracked + case conflicted + + var letter: String { + switch self { + case .modified: return "M" + case .added: return "A" + case .renamed: return "R" + case .untracked: return "U" + case .conflicted: return "!" + } + } + + var label: String { + switch self { + case .modified: return String(localized: "Modified") + case .added: return String(localized: "Added") + case .renamed: return String(localized: "Renamed") + case .untracked: return String(localized: "Untracked") + case .conflicted: return String(localized: "Conflicted") + } + } + } + + let staged: Change + let unstaged: Change + let isUntracked: Bool + let isConflicted: Bool + + static let untracked = GitFileStatus(staged: .unmodified, unstaged: .unmodified, isUntracked: true) + + init(staged: Change, unstaged: Change, isUntracked: Bool = false, isUnmergedEntry: Bool = false) { + self.staged = staged + self.unstaged = unstaged + self.isUntracked = isUntracked + self.isConflicted = isUnmergedEntry || staged == .unmerged || unstaged == .unmerged + } + + init(code: Substring, isUnmergedEntry: Bool = false) { + let characters = Array(code) + self.init( + staged: Change(code: characters.first ?? "."), + unstaged: Change(code: characters.count > 1 ? characters[1] : "."), + isUnmergedEntry: isUnmergedEntry + ) + } + + var hasStagedChanges: Bool { + !isUntracked && staged != .unmodified + } + + var hasUnstagedChanges: Bool { + isUntracked || unstaged != .unmodified + } + + var badge: Badge { + if isConflicted { return .conflicted } + if isUntracked { return .untracked } + switch staged { + case .added: return .added + case .renamed, .copied: return .renamed + default: return .modified + } + } + + var canDiscardChanges: Bool { + guard !isUntracked, !isConflicted else { return false } + return unstaged == .modified || unstaged == .typeChanged + } + + var hasCommittedHistory: Bool { + guard !isUntracked else { return false } + switch staged { + case .added, .renamed, .copied: return false + default: return true + } + } + + var accessibilityDescription: String { + guard !isUntracked, !isConflicted else { return badge.label } + switch (hasStagedChanges, unstaged != .unmodified) { + case (true, false): + return String(format: String(localized: "%@, staged"), badge.label) + case (true, true): + return String(format: String(localized: "%@, partly staged"), badge.label) + default: + return badge.label + } + } +} diff --git a/TablePro/Core/Git/GitOutputParsers.swift b/TablePro/Core/Git/GitOutputParsers.swift new file mode 100644 index 0000000000..4d512dcc28 --- /dev/null +++ b/TablePro/Core/Git/GitOutputParsers.swift @@ -0,0 +1,149 @@ +// +// GitOutputParsers.swift +// TablePro +// + +import Foundation + +internal struct GitStatusRecord: Equatable, Sendable { + let path: String + let originalPath: String? + let status: GitFileStatus +} + +internal struct GitRepositoryInfo: Equatable, Sendable { + let topLevel: URL + let gitDirectory: URL + let prefix: String +} + +internal struct GitCommitRecord: Equatable, Sendable { + let hash: String + let author: String + let date: Date? + let subject: String + let path: String? +} + +internal enum GitStatusParser { + static func parse(_ data: Data) -> [GitStatusRecord] { + let tokens = GitOutputTokens.split(data, separator: 0) + var records: [GitStatusRecord] = [] + var index = 0 + while index < tokens.count { + let token = tokens[index] + index += 1 + guard let kind = token.first else { continue } + switch kind { + case "1": + if let record = trackedRecord(token, fieldCount: 8) { records.append(record) } + case "2": + let originalPath = index < tokens.count ? tokens[index] : nil + index += 1 + if let record = trackedRecord(token, fieldCount: 9, originalPath: originalPath) { + records.append(record) + } + case "u": + if let record = trackedRecord(token, fieldCount: 10, isUnmergedEntry: true) { records.append(record) } + case "?": + let path = String(token.dropFirst(2)) + guard !path.isEmpty else { continue } + records.append(GitStatusRecord(path: path, originalPath: nil, status: .untracked)) + default: + continue + } + } + return records + } + + private static func trackedRecord( + _ token: String, + fieldCount: Int, + originalPath: String? = nil, + isUnmergedEntry: Bool = false + ) -> GitStatusRecord? { + let fields = token.split(separator: " ", maxSplits: fieldCount, omittingEmptySubsequences: false) + guard fields.count == fieldCount + 1 else { return nil } + let path = String(fields[fieldCount]) + guard !path.isEmpty else { return nil } + return GitStatusRecord( + path: path, + originalPath: originalPath, + status: GitFileStatus(code: fields[1], isUnmergedEntry: isUnmergedEntry) + ) + } +} + +internal enum GitRepositoryInfoParser { + static func parse(_ data: Data) -> GitRepositoryInfo? { + let lines = (String(bytes: data, encoding: .utf8) ?? "") + .split(separator: "\n", omittingEmptySubsequences: false) + .map(String.init) + guard lines.count >= 2, !lines[0].isEmpty, !lines[1].isEmpty else { return nil } + return GitRepositoryInfo( + topLevel: URL(fileURLWithPath: lines[0], isDirectory: true), + gitDirectory: URL(fileURLWithPath: lines[1], isDirectory: true), + prefix: lines.count > 2 ? lines[2] : "" + ) + } +} + +internal enum GitLogParser { + private static let recordSeparator: Character = "\u{1E}" + private static let fieldSeparator: Character = "\u{1F}" + + static func parse(_ data: Data) -> [GitCommitRecord] { + let dateFormatter = ISO8601DateFormatter() + dateFormatter.formatOptions = [.withInternetDateTime] + var commits: [GitCommitRecord] = [] + var header: [Substring]? + var paths: [String] = [] + var changeStatus = "" + var expectsStatus = false + + func flush() { + guard let header, header.count >= 3, isCommitHash(header[0]), !changeStatus.hasPrefix("D") else { return } + commits.append(GitCommitRecord( + hash: String(header[0]), + author: String(header[1]), + date: dateFormatter.date(from: String(header[2])), + subject: header.count > 3 ? String(header[3]) : "", + path: paths.last + )) + } + + for token in GitOutputTokens.split(data, separator: 0) { + if token.first == recordSeparator { + flush() + header = token.dropFirst().split(separator: fieldSeparator, maxSplits: 3, omittingEmptySubsequences: false) + paths = [] + changeStatus = "" + expectsStatus = true + continue + } + let trimmed = token.trimmingCharacters(in: .newlines) + guard !trimmed.isEmpty else { continue } + if expectsStatus { + expectsStatus = false + changeStatus = trimmed + continue + } + paths.append(trimmed) + } + flush() + return commits + } + + static func isCommitHash(_ value: Substring) -> Bool { + guard value.count == 40 || value.count == 64 else { return false } + return value.allSatisfy(\.isHexDigit) + } +} + +internal enum GitOutputTokens { + static func split(_ data: Data, separator: UInt8) -> [String] { + data.split(separator: separator, omittingEmptySubsequences: false).map { bytes in + String(bytes: bytes, encoding: .utf8) ?? String(bytes: bytes, encoding: .isoLatin1) ?? "" + } + } +} diff --git a/TablePro/Core/Git/GitProcessRunner.swift b/TablePro/Core/Git/GitProcessRunner.swift new file mode 100644 index 0000000000..d133f64307 --- /dev/null +++ b/TablePro/Core/Git/GitProcessRunner.swift @@ -0,0 +1,149 @@ +// +// GitProcessRunner.swift +// TablePro +// + +import Foundation +import os + +internal struct GitProcessResult: Sendable { + let exitCode: Int32 + let standardOutput: Data + let standardError: Data + + var succeeded: Bool { exitCode == 0 } + + var errorMessage: String { + (String(bytes: standardError, encoding: .utf8) ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + } +} + +internal enum GitProcessError: Error, Equatable { + case launchFailed(String) + case timedOut + case outputTooLarge +} + +internal struct GitProcessRunner: Sendable { + private static let logger = Logger(subsystem: "com.TablePro", category: "GitProcessRunner") + + static let defaultTimeout: TimeInterval = 20 + static let defaultOutputLimit = 128 * 1_024 * 1_024 + static let errorOutputLimit = 64 * 1_024 + + let executableURL: URL + var timeout: TimeInterval = defaultTimeout + var outputLimit: Int = defaultOutputLimit + + func run(_ command: GitCommand) async throws -> GitProcessResult { + try await withCheckedThrowingContinuation { continuation in + DispatchQueue.global(qos: .utility).async { + continuation.resume(with: Result { try runSynchronously(command) }) + } + } + } + + private func runSynchronously(_ command: GitCommand) throws -> GitProcessResult { + let process = Process() + process.executableURL = executableURL + process.arguments = command.processArguments + process.currentDirectoryURL = command.workingDirectory + process.environment = GitCommand.environment(base: ProcessInfo.processInfo.environment) + process.standardInput = FileHandle.nullDevice + let outputPipe = Pipe() + let errorPipe = Pipe() + process.standardOutput = outputPipe + process.standardError = errorPipe + + do { + try process.run() + } catch { + throw GitProcessError.launchFailed(error.localizedDescription) + } + + let handle = RunningProcess(process) + let output = BoundedBuffer(limit: outputLimit) + let errors = BoundedBuffer(limit: Self.errorOutputLimit) + let readers = DispatchGroup() + DispatchQueue.global(qos: .utility).async(group: readers) { + Self.drain(outputPipe.fileHandleForReading, into: output) { handle.terminate() } + } + DispatchQueue.global(qos: .utility).async(group: readers) { + Self.drain(errorPipe.fileHandleForReading, into: errors, onOverflow: nil) + } + + guard readers.wait(timeout: .now() + timeout) == .success else { + handle.terminate() + _ = readers.wait(timeout: .now() + 2) + Self.logger.warning("git \(command.arguments.first ?? "", privacy: .public) timed out after \(timeout, privacy: .public)s") + throw GitProcessError.timedOut + } + process.waitUntilExit() + + guard !output.overflowed else { throw GitProcessError.outputTooLarge } + return GitProcessResult( + exitCode: process.terminationStatus, + standardOutput: output.data, + standardError: errors.data + ) + } + + private static func drain(_ handle: FileHandle, into buffer: BoundedBuffer, onOverflow: (@Sendable () -> Void)?) { + while true { + let chunk: Data + do { + chunk = try handle.read(upToCount: 64 * 1_024) ?? Data() + } catch { + return + } + guard !chunk.isEmpty else { return } + guard buffer.append(chunk) || onOverflow == nil else { + onOverflow?() + return + } + } + } +} + +private final class RunningProcess: @unchecked Sendable { + private let process: Process + + init(_ process: Process) { + self.process = process + } + + func terminate() { + guard process.isRunning else { return } + process.terminate() + } +} + +private final class BoundedBuffer: @unchecked Sendable { + private let lock = NSLock() + private let limit: Int + private var storage = Data() + private var didOverflow = false + + init(limit: Int) { + self.limit = limit + } + + var data: Data { + lock.withLock { storage } + } + + var overflowed: Bool { + lock.withLock { didOverflow } + } + + func append(_ chunk: Data) -> Bool { + lock.withLock { + guard storage.count + chunk.count <= limit else { + didOverflow = true + return false + } + storage.append(chunk) + return true + } + } +} diff --git a/TablePro/Core/MCP/Protocol/Tools/MCPTabSnapshotProvider.swift b/TablePro/Core/MCP/Protocol/Tools/MCPTabSnapshotProvider.swift index 8a9dbdeb81..bb36a9ade9 100644 --- a/TablePro/Core/MCP/Protocol/Tools/MCPTabSnapshotProvider.swift +++ b/TablePro/Core/MCP/Protocol/Tools/MCPTabSnapshotProvider.swift @@ -138,6 +138,7 @@ private extension TabType { case .insights: "insights" case .usersRoles: "usersRoles" case .objectSource: "objectSource" + case .versionHistory: "versionHistory" } } } diff --git a/TablePro/Core/Scripting/ScriptEnumerations.swift b/TablePro/Core/Scripting/ScriptEnumerations.swift index a345040bb9..6ec52c90ea 100644 --- a/TablePro/Core/Scripting/ScriptEnumerations.swift +++ b/TablePro/Core/Scripting/ScriptEnumerations.swift @@ -42,6 +42,7 @@ internal enum ScriptEnumerations { case .usersRoles: fourCharCode("TPk6") case .insights: fourCharCode("TPk7") case .objectSource: fourCharCode("TPk8") + case .versionHistory: fourCharCode("TPk9") } } diff --git a/TablePro/Core/Services/Infrastructure/EditorTabOpener.swift b/TablePro/Core/Services/Infrastructure/EditorTabOpener.swift index 71d3638cbf..ba7a4bac0b 100644 --- a/TablePro/Core/Services/Infrastructure/EditorTabOpener.swift +++ b/TablePro/Core/Services/Infrastructure/EditorTabOpener.swift @@ -87,6 +87,9 @@ internal enum EditorTabOpener { case .objectSource: guard let objectRef = payload.objectRef else { return } tabManager.addObjectSourceTab(objectRef: objectRef) + case .versionHistory: + guard let subject = payload.versionHistorySubject else { return } + tabManager.addVersionHistoryTab(subject: subject, title: payload.tabTitle ?? QueryTabManager.versionHistoryFallbackTitle) } } diff --git a/TablePro/Core/Services/Infrastructure/MainSplitViewController.swift b/TablePro/Core/Services/Infrastructure/MainSplitViewController.swift index d1052f7ac2..e1ee794a1a 100644 --- a/TablePro/Core/Services/Infrastructure/MainSplitViewController.swift +++ b/TablePro/Core/Services/Infrastructure/MainSplitViewController.swift @@ -1342,7 +1342,7 @@ internal final class MainSplitViewController: NSSplitViewController { switch tabType { case .usersRoles: return UsersRolesLayoutMetrics.tabMinimumWidth - case .query, .table, .createTable, .erDiagram, .serverDashboard, .insights, .objectSource: + case .query, .table, .createTable, .erDiagram, .serverDashboard, .insights, .objectSource, .versionHistory: return defaultDetailMinThickness } } diff --git a/TablePro/Core/Services/Infrastructure/SQLFileService.swift b/TablePro/Core/Services/Infrastructure/SQLFileService.swift index 1c984303da..5c31a314d3 100644 --- a/TablePro/Core/Services/Infrastructure/SQLFileService.swift +++ b/TablePro/Core/Services/Infrastructure/SQLFileService.swift @@ -37,6 +37,12 @@ enum SQLFileService { }.value } + static func writeData(_ data: Data, to url: URL) async throws { + try await Task.detached { + try data.write(to: url, options: .atomic) + }.value + } + /// Shows a save panel for .sql files. @MainActor static func showSavePanel(suggestedName: String = "query.sql") async -> URL? { diff --git a/TablePro/Core/Services/Infrastructure/Toolbar/ToolbarContextResolver.swift b/TablePro/Core/Services/Infrastructure/Toolbar/ToolbarContextResolver.swift index 292a85583f..fd1c0c6536 100644 --- a/TablePro/Core/Services/Infrastructure/Toolbar/ToolbarContextResolver.swift +++ b/TablePro/Core/Services/Infrastructure/Toolbar/ToolbarContextResolver.swift @@ -60,7 +60,7 @@ internal enum ToolbarContextResolver { String(localized: "Create Table") case .usersRoles: String(localized: "Apply Changes") - case .query, .table, .erDiagram, .serverDashboard, .insights, .objectSource, nil: + case .query, .table, .erDiagram, .serverDashboard, .insights, .objectSource, .versionHistory, nil: String(localized: "Save Changes") } } @@ -93,8 +93,8 @@ internal enum ToolbarContextResolver { case .createTable: /// A definition that is not on the server yet has nothing to reload. return [MainWindowToolbar.refresh] - case .erDiagram, .serverDashboard, .insights, .objectSource: - /// None of these four can stage a change, so the commit control could only ever be dim. + case .erDiagram, .serverDashboard, .insights, .objectSource, .versionHistory: + /// None of these can stage a change, so the commit control could only ever be dim. return [MainWindowToolbar.saveChanges] case .query, .table, .usersRoles: return [] diff --git a/TablePro/Core/Services/Infrastructure/WindowTitleResolver.swift b/TablePro/Core/Services/Infrastructure/WindowTitleResolver.swift index 2adad5ac95..5b643970d7 100644 --- a/TablePro/Core/Services/Infrastructure/WindowTitleResolver.swift +++ b/TablePro/Core/Services/Infrastructure/WindowTitleResolver.swift @@ -155,6 +155,11 @@ enum WindowTitleResolver { return explicitTitle } return String(localized: "Source") + case .versionHistory: + if let explicitTitle, !explicitTitle.isBlank { + return explicitTitle + } + return QueryTabManager.versionHistoryFallbackTitle default: break } diff --git a/TablePro/Core/Services/SQL/GitRepositoryWatcher.swift b/TablePro/Core/Services/SQL/GitRepositoryWatcher.swift new file mode 100644 index 0000000000..3c2cb7be52 --- /dev/null +++ b/TablePro/Core/Services/SQL/GitRepositoryWatcher.swift @@ -0,0 +1,65 @@ +// +// GitRepositoryWatcher.swift +// TablePro +// + +import CoreServices +import Foundation +import os + +@MainActor +internal final class GitRepositoryWatcher { + nonisolated private static let logger = Logger(subsystem: "com.TablePro", category: "GitRepositoryWatcher") + + var onChange: (() -> Void)? + + private var eventStream: FSEventStreamRef? + private var watchedPaths: Set = [] + + nonisolated private static let eventCallback: FSEventStreamCallback = { _, info, _, _, _, _ in + guard let info else { return } + let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() + Task { @MainActor in + watcher.onChange?() + } + } + + func watch(_ paths: Set) { + guard paths != watchedPaths else { return } + cancel() + watchedPaths = paths + guard !paths.isEmpty else { return } + + var context = FSEventStreamContext( + version: 0, + info: Unmanaged.passUnretained(self).toOpaque(), + retain: nil, + release: nil, + copyDescription: nil + ) + guard let stream = FSEventStreamCreate( + kCFAllocatorDefault, + Self.eventCallback, + &context, + Array(paths) as CFArray, + FSEventStreamEventId(kFSEventStreamEventIdSinceNow), + 0.5, + UInt32(kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagWatchRoot) + ) else { + Self.logger.error("Failed to create the Git repository event stream") + return + } + FSEventStreamSetDispatchQueue(stream, .global(qos: .utility)) + FSEventStreamStart(stream) + eventStream = stream + } + + func cancel() { + watchedPaths = [] + guard let stream = eventStream else { return } + FSEventStreamStop(stream) + FSEventStreamInvalidate(stream) + FSEventStreamRelease(stream) + eventStream = nil + } +} diff --git a/TablePro/Core/Services/SQL/LinkedFolderGitStatusStore.swift b/TablePro/Core/Services/SQL/LinkedFolderGitStatusStore.swift new file mode 100644 index 0000000000..7359fa8148 --- /dev/null +++ b/TablePro/Core/Services/SQL/LinkedFolderGitStatusStore.swift @@ -0,0 +1,152 @@ +// +// LinkedFolderGitStatusStore.swift +// TablePro +// + +import AppKit +import Combine +import Foundation +import os + +internal enum LinkedFileGitState: Equatable, Sendable { + case clean + case changed(GitFileStatus) + + var status: GitFileStatus? { + guard case .changed(let status) = self else { return nil } + return status + } + + var hasCommittedHistory: Bool { + status?.hasCommittedHistory ?? true + } + + var canDiscardChanges: Bool { + status?.canDiscardChanges ?? false + } +} + +internal struct LinkedFolderGitSnapshot: Equatable, Sendable { + let repository: GitRepositoryInfo + let head: String? + let statuses: [String: GitFileStatus] + let trackedPaths: Set + + func state(forRelativePath path: String) -> LinkedFileGitState? { + if let status = statuses[path] { + return .changed(status) + } + return trackedPaths.contains(path) ? .clean : nil + } +} + +@MainActor +internal final class LinkedFolderGitStatusStore: ObservableObject { + static let shared = LinkedFolderGitStatusStore() + nonisolated private static let logger = Logger(subsystem: "com.TablePro", category: "LinkedFolderGitStatus") + + @Published private(set) var snapshots: [UUID: LinkedFolderGitSnapshot] = [:] + + private let clientFactory: @Sendable () -> GitClient? + private let foldersProvider: @MainActor () -> [LinkedSQLFolder] + private let repositoryWatcher = GitRepositoryWatcher() + private var cancellables: Set = [] + private var refreshTask: Task? + private var hasStarted = false + + init( + clientFactory: @escaping @Sendable () -> GitClient? = { GitClient.make() }, + foldersProvider: @escaping @MainActor () -> [LinkedSQLFolder] = { LinkedSQLFolderStorage.shared.loadFolders() } + ) { + self.clientFactory = clientFactory + self.foldersProvider = foldersProvider + } + + func start() { + guard !hasStarted else { return } + hasStarted = true + AppEvents.shared.linkedSQLFoldersDidUpdate + .sink { [weak self] _ in self?.scheduleRefresh() } + .store(in: &cancellables) + NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification) + .sink { [weak self] _ in self?.scheduleRefresh() } + .store(in: &cancellables) + repositoryWatcher.onChange = { [weak self] in self?.scheduleRefresh() } + scheduleRefresh(after: .zero) + } + + func state(for favorite: LinkedSQLFavorite) -> LinkedFileGitState? { + snapshots[favorite.folderId]?.state(forRelativePath: favorite.relativePath) + } + + func states(for favorites: [LinkedSQLFavorite]) -> [UUID: LinkedFileGitState] { + var states: [UUID: LinkedFileGitState] = [:] + for favorite in favorites { + states[favorite.id] = state(for: favorite) + } + return states + } + + func scheduleRefresh(after delay: Duration = .milliseconds(400)) { + refreshTask?.cancel() + refreshTask = Task { [weak self] in + do { + try await Task.sleep(for: delay) + } catch { + return + } + await self?.refresh() + } + } + + func refresh() async { + let folders = foldersProvider().filter(\.isEnabled) + let loaded = await Self.loadSnapshots(folders: folders, client: clientFactory(), previous: snapshots) + guard !Task.isCancelled else { return } + if loaded != snapshots { + snapshots = loaded + } + repositoryWatcher.watch(Set(loaded.values.map(\.repository.gitDirectory.path))) + } + + nonisolated static func loadSnapshots( + folders: [LinkedSQLFolder], + client: GitClient?, + previous: [UUID: LinkedFolderGitSnapshot] + ) async -> [UUID: LinkedFolderGitSnapshot] { + guard let client else { return [:] } + var loaded: [UUID: LinkedFolderGitSnapshot] = [:] + for folder in folders { + let directory = folder.expandedURL + do { + guard let repository = try await client.repositoryInfo(in: directory) else { continue } + let records = try await client.status(in: directory) + let tracked = try await client.trackedFiles(in: directory) + loaded[folder.id] = LinkedFolderGitSnapshot( + repository: repository, + head: try await client.headCommit(in: directory), + statuses: folderRelativeStatuses(records, prefix: repository.prefix), + trackedPaths: folderRelativePaths(tracked, prefix: repository.prefix) + ) + } catch { + logger.warning("Git status failed for a linked folder: \(error.publicLogShape, privacy: .public)") + if let kept = previous[folder.id] { + loaded[folder.id] = kept + } + } + } + return loaded + } + + nonisolated static func folderRelativeStatuses(_ records: [GitStatusRecord], prefix: String) -> [String: GitFileStatus] { + var statuses: [String: GitFileStatus] = [:] + for record in records where record.path.hasPrefix(prefix) { + statuses[String(record.path.dropFirst(prefix.count))] = record.status + } + return statuses + } + + nonisolated static func folderRelativePaths(_ paths: [String], prefix: String) -> Set { + Set(paths.filter { $0.hasPrefix(prefix) }.map { String($0.dropFirst(prefix.count)) }) + } +} diff --git a/TablePro/Core/Services/SQL/SQLFolderWatcher.swift b/TablePro/Core/Services/SQL/SQLFolderWatcher.swift index 98cab5b488..7fe8639279 100644 --- a/TablePro/Core/Services/SQL/SQLFolderWatcher.swift +++ b/TablePro/Core/Services/SQL/SQLFolderWatcher.swift @@ -19,14 +19,23 @@ internal final class SQLFolderWatcher: ObservableObject { private var debounceTask: Task? private var hasStarted = false - nonisolated private static let eventCallback: FSEventStreamCallback = { _, info, _, _, _, _ in + nonisolated private static let eventCallback: FSEventStreamCallback = { _, info, _, eventPaths, _, _ in guard let info else { return } + let paths = (Unmanaged.fromOpaque(eventPaths).takeUnretainedValue() as NSArray) as? [String] ?? [] + guard !touchesOnlyRepositoryMetadata(paths) else { return } let watcher = Unmanaged.fromOpaque(info).takeUnretainedValue() Task { @MainActor in watcher.scheduleDebouncedRescan() } } + nonisolated static func touchesOnlyRepositoryMetadata(_ paths: [String]) -> Bool { + guard !paths.isEmpty else { return false } + return paths.allSatisfy { path in + path.split(separator: "/").contains(".git") + } + } + private init() {} func start() { @@ -68,6 +77,7 @@ internal final class SQLFolderWatcher: ObservableObject { kFSEventStreamCreateFlagFileEvents | kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagWatchRoot + | kFSEventStreamCreateFlagUseCFTypes ) guard let stream = FSEventStreamCreate( diff --git a/TablePro/Core/Storage/SQLFavoriteManager.swift b/TablePro/Core/Storage/SQLFavoriteManager.swift index 5be28fc1c1..596bd5cc23 100644 --- a/TablePro/Core/Storage/SQLFavoriteManager.swift +++ b/TablePro/Core/Storage/SQLFavoriteManager.swift @@ -126,6 +126,24 @@ internal final class SQLFavoriteManager: @unchecked Sendable { ) } + // MARK: - Versions + + func fetchVersions(favoriteId: UUID) async -> [SQLFavoriteVersion] { + await storage.fetchVersions(favoriteId: favoriteId) + } + + func querySavedAt(favoriteId: UUID) async -> Date? { + await storage.querySavedAt(favoriteId: favoriteId) + } + + func restore(_ version: SQLFavoriteVersion) async -> Bool { + let result = await storage.replaceQuery(favoriteId: version.favoriteId, query: version.query, updatedAt: Date()) + guard result.succeeded else { return false } + syncTracker.markDirty(.favorite, id: version.favoriteId.uuidString) + postUpdateNotification(connectionId: result.retainedScope) + return true + } + // MARK: - Folders func addFolder(_ folder: SQLFavoriteFolder) async -> Bool { diff --git a/TablePro/Core/Storage/SQLFavoriteStorage+Versions.swift b/TablePro/Core/Storage/SQLFavoriteStorage+Versions.swift new file mode 100644 index 0000000000..bbf04c01ca --- /dev/null +++ b/TablePro/Core/Storage/SQLFavoriteStorage+Versions.swift @@ -0,0 +1,148 @@ +// +// SQLFavoriteStorage+Versions.swift +// TablePro +// + +import Foundation +import os +import SQLite3 + +extension SQLFavoriteStorage { + private static let versionsLogger = Logger(subsystem: "com.TablePro", category: "SQLFavoriteVersions") + + static let retainedVersionCount = 50 + + static var versionSchemaStatements: [String] { + [ + """ + CREATE TABLE IF NOT EXISTS favorite_versions ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + favorite_id TEXT NOT NULL, + name TEXT NOT NULL, + query TEXT NOT NULL, + saved_at REAL NOT NULL + ); + """, + "CREATE INDEX IF NOT EXISTS idx_favorite_versions_favorite ON favorite_versions(favorite_id, id);", + """ + CREATE TABLE IF NOT EXISTS favorite_query_times ( + favorite_id TEXT PRIMARY KEY, + saved_at REAL NOT NULL + ); + """, + """ + INSERT OR IGNORE INTO favorite_query_times (favorite_id, saved_at) + SELECT id, updated_at FROM favorites; + """, + """ + CREATE TRIGGER IF NOT EXISTS favorites_version_ai AFTER INSERT ON favorites BEGIN + DELETE FROM favorite_query_times WHERE favorite_id = new.id; + INSERT INTO favorite_query_times (favorite_id, saved_at) VALUES (new.id, new.updated_at); + END; + """, + """ + CREATE TRIGGER IF NOT EXISTS favorites_version_au AFTER UPDATE OF query ON favorites + WHEN old.query IS NOT new.query BEGIN + INSERT INTO favorite_versions (favorite_id, name, query, saved_at) + VALUES ( + old.id, old.name, old.query, + COALESCE((SELECT saved_at FROM favorite_query_times WHERE favorite_id = old.id), old.updated_at) + ); + DELETE FROM favorite_query_times WHERE favorite_id = new.id; + INSERT INTO favorite_query_times (favorite_id, saved_at) VALUES (new.id, new.updated_at); + DELETE FROM favorite_versions WHERE favorite_id = old.id AND id NOT IN ( + SELECT id FROM favorite_versions WHERE favorite_id = old.id + ORDER BY id DESC LIMIT \(retainedVersionCount) + ); + END; + """, + """ + CREATE TRIGGER IF NOT EXISTS favorites_version_ad AFTER DELETE ON favorites BEGIN + DELETE FROM favorite_versions WHERE favorite_id = old.id; + DELETE FROM favorite_query_times WHERE favorite_id = old.id; + END; + """, + ] + } + + func fetchVersions(favoriteId: UUID) -> [SQLFavoriteVersion] { + let sql = """ + SELECT id, favorite_id, name, query, saved_at FROM favorite_versions + WHERE favorite_id = ? ORDER BY id DESC; + """ + var statement: OpaquePointer? + guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else { + Self.versionsLogger.error("Failed to prepare version fetch: \(String(cString: sqlite3_errmsg(self.db)))") + return [] + } + + defer { sqlite3_finalize(statement) } + + let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self) + sqlite3_bind_text(statement, 1, favoriteId.uuidString, -1, SQLITE_TRANSIENT) + + var versions: [SQLFavoriteVersion] = [] + while sqlite3_step(statement) == SQLITE_ROW { + if let version = Self.parseVersion(from: statement) { + versions.append(version) + } + } + return versions + } + + func querySavedAt(favoriteId: UUID) -> Date? { + let sql = "SELECT saved_at FROM favorite_query_times WHERE favorite_id = ? LIMIT 1;" + var statement: OpaquePointer? + guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else { return nil } + defer { sqlite3_finalize(statement) } + + let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self) + sqlite3_bind_text(statement, 1, favoriteId.uuidString, -1, SQLITE_TRANSIENT) + guard sqlite3_step(statement) == SQLITE_ROW else { return nil } + return Date(timeIntervalSince1970: sqlite3_column_double(statement, 0)) + } + + func replaceQuery(favoriteId: UUID, query: String, updatedAt: Date) -> FavoriteScopeWrite { + guard case .found(let connectionId) = currentScope(table: "favorites", id: favoriteId) else { + return .failed + } + + let sql = "UPDATE favorites SET query = ?, updated_at = ? WHERE id = ?;" + var statement: OpaquePointer? + guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else { + return .failed + } + + defer { sqlite3_finalize(statement) } + + let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self) + sqlite3_bind_text(statement, 1, query, -1, SQLITE_TRANSIENT) + sqlite3_bind_double(statement, 2, updatedAt.timeIntervalSince1970) + sqlite3_bind_text(statement, 3, favoriteId.uuidString, -1, SQLITE_TRANSIENT) + + guard sqlite3_step(statement) == SQLITE_DONE else { + Self.versionsLogger.error("Failed to restore favorite: \(String(cString: sqlite3_errmsg(self.db)))") + return .failed + } + return .updatedExisting(previousConnectionId: connectionId) + } + + private static func parseVersion(from statement: OpaquePointer?) -> SQLFavoriteVersion? { + guard let statement, + let favoriteIdString = sqlite3_column_text(statement, 1).map({ String(cString: $0) }), + let favoriteId = UUID(uuidString: favoriteIdString), + let name = sqlite3_column_text(statement, 2).map({ String(cString: $0) }), + let query = sqlite3_column_text(statement, 3).map({ String(cString: $0) }) + else { + return nil + } + + return SQLFavoriteVersion( + id: sqlite3_column_int64(statement, 0), + favoriteId: favoriteId, + name: name, + query: query, + savedAt: Date(timeIntervalSince1970: sqlite3_column_double(statement, 4)) + ) + } +} diff --git a/TablePro/Core/Storage/SQLFavoriteStorage.swift b/TablePro/Core/Storage/SQLFavoriteStorage.swift index 94d5ce3957..3dcd259fc0 100644 --- a/TablePro/Core/Storage/SQLFavoriteStorage.swift +++ b/TablePro/Core/Storage/SQLFavoriteStorage.swift @@ -75,6 +75,7 @@ internal actor SQLFavoriteStorage { createTables() migrateIfNeeded() + Self.versionSchemaStatements.forEach { execute($0) } } // MARK: - Schema Migration diff --git a/TablePro/Core/Utilities/File/FileTextLoader.swift b/TablePro/Core/Utilities/File/FileTextLoader.swift index f811f76a51..692868dd0e 100644 --- a/TablePro/Core/Utilities/File/FileTextLoader.swift +++ b/TablePro/Core/Utilities/File/FileTextLoader.swift @@ -35,6 +35,23 @@ internal enum FileTextLoader { return nil } + static func decode(_ data: Data) -> String? { + let utf8ByteOrderMark: [UInt8] = [0xEF, 0xBB, 0xBF] + if data.starts(with: utf8ByteOrderMark) { + return String(data: data.dropFirst(utf8ByteOrderMark.count), encoding: .utf8) + } + if data.starts(with: [0xFF, 0xFE, 0x00, 0x00]) || data.starts(with: [0x00, 0x00, 0xFE, 0xFF]) { + return String(data: data, encoding: .utf32) + } + if data.starts(with: [0xFF, 0xFE]) || data.starts(with: [0xFE, 0xFF]) { + return String(data: data, encoding: .utf16) + } + if let content = String(data: data, encoding: .utf8) { + return content + } + return String(data: data, encoding: .isoLatin1) + } + static func modificationDate(of url: URL) -> Date? { (try? FileManager.default.attributesOfItem(atPath: url.path)[.modificationDate]) as? Date } diff --git a/TablePro/Core/VersionHistory/LinkedFileVersionHistoryProvider.swift b/TablePro/Core/VersionHistory/LinkedFileVersionHistoryProvider.swift new file mode 100644 index 0000000000..0aaeb0648d --- /dev/null +++ b/TablePro/Core/VersionHistory/LinkedFileVersionHistoryProvider.swift @@ -0,0 +1,169 @@ +// +// LinkedFileVersionHistoryProvider.swift +// TablePro +// + +import Foundation + +internal struct LinkedFileVersionHistoryProvider: VersionHistoryProvider { + static let commitLimit = 200 + static let largeFileStoragePointerPrefix = Data("version https://git-lfs.github.com/spec/v1".utf8) + + let fileURL: URL + var locator: GitExecutableLocator = .system + + private var directory: URL { + fileURL.deletingLastPathComponent() + } + + private var indexPath: String { + "./" + fileURL.lastPathComponent + } + + func loadHistory() async throws -> VersionHistoryPage { + guard FileManager.default.fileExists(atPath: fileURL.path) else { + throw VersionHistoryError.subjectNotFound + } + let client = try makeClient() + guard let info = try await gitCall({ try await client.repositoryInfo(in: directory) }) else { + throw VersionHistoryError.notInRepository + } + let records = try await gitCall { try await client.status(in: directory, pathspec: fileURL.lastPathComponent) } + let current = VersionHistoryEntry( + reference: .current, + date: FileTextLoader.modificationDate(of: fileURL), + hasUncommittedChanges: !records.isEmpty + ) + guard try await gitCall({ try await client.hasCommits(in: directory) }) else { + return VersionHistoryPage(entries: [current]) + } + + let commits = try await gitCall { try await client.history(of: fileURL, limit: Self.commitLimit + 1) } + let currentPath = info.prefix + fileURL.lastPathComponent + let past = commits.prefix(Self.commitLimit).map { commit in + VersionHistoryEntry( + reference: .gitRevision(commit: commit.hash, path: commit.path ?? currentPath), + summary: commit.subject, + author: commit.author, + date: commit.date + ) + } + return VersionHistoryPage( + entries: [current] + past, + notice: commits.count > Self.commitLimit ? .showsLatestCommits(Self.commitLimit) : nil + ) + } + + func content(of reference: VersionHistoryReference) async throws -> String { + switch reference { + case .current: + guard let loaded = FileTextLoader.load(fileURL) else { + throw VersionHistoryError.subjectNotFound + } + return loaded.content + case .gitRevision(let commit, let path): + let client = try makeClient() + let data = try await gitCall { try await client.blob(revision: commit, path: path, in: directory) } + guard let content = FileTextLoader.decode(data) else { + throw VersionHistoryError.undecodableContent + } + return content + case .savedQueryVersion: + throw VersionHistoryError.versionNotFound + } + } + + func prepareRestore(_ reference: VersionHistoryReference) async throws -> VersionRestorePlan { + guard case .gitRevision(let commit, let path) = reference else { + throw VersionHistoryError.versionNotFound + } + let client = try makeClient() + let current = try currentBytes() + let replacement = try await gitCall { try await client.blob(revision: commit, path: path, in: directory) } + try Self.rejectLargeFileStoragePointer(replacement) + let replacesUncommittedChanges = try await differsFromLastCommit(current, client: client) + return writePlan( + replacing: current, + with: replacement, + replacesUncommittedChanges: replacesUncommittedChanges, + sourceIsUnchanged: { true } + ) + } + + func prepareDiscard() async throws -> VersionRestorePlan { + let client = try makeClient() + let current = try currentBytes() + let staged = try await gitCall { try await client.blob(revision: "", path: indexPath, in: directory) } + try Self.rejectLargeFileStoragePointer(staged) + let directory = directory + let indexPath = indexPath + return writePlan( + replacing: current, + with: staged, + replacesUncommittedChanges: true, + sourceIsUnchanged: { (try? await client.blob(revision: "", path: indexPath, in: directory)) == staged } + ) + } + + static func rejectLargeFileStoragePointer(_ data: Data) throws { + guard !data.starts(with: largeFileStoragePointerPrefix) else { + throw VersionHistoryError.storedInLargeFileStorage + } + } + + private func writePlan( + replacing expected: Data, + with replacement: Data, + replacesUncommittedChanges: Bool, + sourceIsUnchanged: @escaping @Sendable () async -> Bool + ) -> VersionRestorePlan { + let fileURL = fileURL + return VersionRestorePlan(replacesUncommittedChanges: replacesUncommittedChanges) { + guard await sourceIsUnchanged(), (try? Data(contentsOf: fileURL)) == expected else { + throw VersionHistoryError.fileChangedBeforeWriting + } + do { + try await SQLFileService.writeData(replacement, to: fileURL) + } catch { + throw VersionHistoryError.restoreFailed(error.localizedDescription) + } + } + } + + private func currentBytes() throws -> Data { + do { + return try Data(contentsOf: fileURL) + } catch { + throw VersionHistoryError.subjectNotFound + } + } + + private func differsFromLastCommit(_ current: Data, client: GitClient) async throws -> Bool { + let records = try await gitCall { try await client.status(in: directory, pathspec: fileURL.lastPathComponent) } + guard records.isEmpty else { return true } + guard try await gitCall({ try await client.hasCommits(in: directory) }) else { return true } + let committed = try? await client.blob(revision: "HEAD", path: indexPath, in: directory) + return committed != current + } + + private func makeClient() throws -> GitClient { + guard let client = GitClient.make(locator: locator) else { + throw VersionHistoryError.gitUnavailable + } + return client + } + + private func gitCall(_ operation: () async throws -> T) async throws -> T { + do { + return try await operation() + } catch let failure as GitCommandFailure { + throw VersionHistoryError.commandFailed(failure.errorDescription ?? failure.message) + } catch GitProcessError.timedOut { + throw VersionHistoryError.commandFailed(String(localized: "Git did not respond in time.")) + } catch GitProcessError.outputTooLarge { + throw VersionHistoryError.commandFailed(String(localized: "The file is too large to read from Git.")) + } catch GitProcessError.launchFailed(let message) { + throw VersionHistoryError.commandFailed(message) + } + } +} diff --git a/TablePro/Core/VersionHistory/SavedQueryVersionHistoryProvider.swift b/TablePro/Core/VersionHistory/SavedQueryVersionHistoryProvider.swift new file mode 100644 index 0000000000..7e4cfc4571 --- /dev/null +++ b/TablePro/Core/VersionHistory/SavedQueryVersionHistoryProvider.swift @@ -0,0 +1,66 @@ +// +// SavedQueryVersionHistoryProvider.swift +// TablePro +// + +import Foundation + +internal struct SavedQueryVersionHistoryProvider: VersionHistoryProvider { + let favoriteId: UUID + let manager: SQLFavoriteManager + + func loadHistory() async throws -> VersionHistoryPage { + guard let favorite = await manager.fetchFavorite(id: favoriteId) else { + throw VersionHistoryError.subjectNotFound + } + let versions = await manager.fetchVersions(favoriteId: favoriteId) + let savedAt = await manager.querySavedAt(favoriteId: favoriteId) ?? favorite.updatedAt + let current = VersionHistoryEntry(reference: .current, date: savedAt) + let past = versions.map { version in + VersionHistoryEntry( + reference: .savedQueryVersion(id: version.id), + summary: version.name == favorite.name ? nil : version.name, + date: version.savedAt + ) + } + return VersionHistoryPage( + entries: [current] + past, + notice: .keepsLatestVersions(SQLFavoriteStorage.retainedVersionCount) + ) + } + + func content(of reference: VersionHistoryReference) async throws -> String { + switch reference { + case .current: + guard let favorite = await manager.fetchFavorite(id: favoriteId) else { + throw VersionHistoryError.subjectNotFound + } + return favorite.query + case .savedQueryVersion(let id): + return try await version(id: id).query + case .gitRevision: + throw VersionHistoryError.versionNotFound + } + } + + func prepareRestore(_ reference: VersionHistoryReference) async throws -> VersionRestorePlan { + guard case .savedQueryVersion(let id) = reference else { + throw VersionHistoryError.versionNotFound + } + let version = try await version(id: id) + let manager = manager + return VersionRestorePlan(replacesUncommittedChanges: false) { + guard await manager.restore(version) else { + throw VersionHistoryError.subjectNotFound + } + } + } + + private func version(id: Int64) async throws -> SQLFavoriteVersion { + let versions = await manager.fetchVersions(favoriteId: favoriteId) + guard let version = versions.first(where: { $0.id == id }) else { + throw VersionHistoryError.versionNotFound + } + return version + } +} diff --git a/TablePro/Core/VersionHistory/VersionComparison.swift b/TablePro/Core/VersionHistory/VersionComparison.swift new file mode 100644 index 0000000000..cd585e9389 --- /dev/null +++ b/TablePro/Core/VersionHistory/VersionComparison.swift @@ -0,0 +1,23 @@ +// +// VersionComparison.swift +// TablePro +// + +import Foundation + +internal enum VersionComparison: Equatable, Sendable { + case identical + case differs([DiffPair]) + case tooLarge + + static let maximumLineCount = 5_000 + + static func compare(baseline: String, current: String) -> VersionComparison { + guard baseline != current else { return .identical } + let before = FileConflictDiff.lines(baseline) + let after = FileConflictDiff.lines(current) + guard before != after else { return .identical } + guard before.count <= maximumLineCount, after.count <= maximumLineCount else { return .tooLarge } + return .differs(DiffComputer.computeSplit(before: before, after: after)) + } +} diff --git a/TablePro/Core/VersionHistory/VersionHistoryModels.swift b/TablePro/Core/VersionHistory/VersionHistoryModels.swift new file mode 100644 index 0000000000..a394028ad3 --- /dev/null +++ b/TablePro/Core/VersionHistory/VersionHistoryModels.swift @@ -0,0 +1,103 @@ +// +// VersionHistoryModels.swift +// TablePro +// + +import Foundation + +internal enum VersionHistorySubject: Codable, Hashable, Sendable { + case savedQuery(id: UUID) + case linkedFile(url: URL) +} + +internal enum VersionHistoryReference: Hashable, Sendable { + case current + case savedQueryVersion(id: Int64) + case gitRevision(commit: String, path: String) + + var shortRevision: String? { + guard case .gitRevision(let commit, _) = self else { return nil } + return String(commit.prefix(7)) + } +} + +internal struct VersionHistoryEntry: Identifiable, Hashable, Sendable { + let reference: VersionHistoryReference + var summary: String? + var author: String? + var date: Date? + var hasUncommittedChanges = false + + var id: VersionHistoryReference { reference } + var isCurrent: Bool { reference == .current } +} + +internal enum VersionHistoryNotice: Hashable, Sendable { + case keepsLatestVersions(Int) + case showsLatestCommits(Int) +} + +internal struct VersionHistoryPage: Equatable, Sendable { + let entries: [VersionHistoryEntry] + var notice: VersionHistoryNotice? + + static let empty = VersionHistoryPage(entries: []) + + var current: VersionHistoryEntry? { + entries.first(where: \.isCurrent) + } + + func baseline(for reference: VersionHistoryReference) -> VersionHistoryEntry? { + guard reference == .current else { return current } + return entries.first { !$0.isCurrent } + } +} + +internal enum VersionHistoryError: LocalizedError, Equatable { + case subjectNotFound + case versionNotFound + case gitUnavailable + case notInRepository + case noCommitsYet + case commandFailed(String) + case undecodableContent + case storedInLargeFileStorage + case fileChangedBeforeWriting + case restoreFailed(String) + + var errorDescription: String? { + switch self { + case .subjectNotFound: + return String(localized: "This item no longer exists.") + case .versionNotFound: + return String(localized: "This version is no longer available.") + case .gitUnavailable: + return String(localized: "Git is not installed. Install the Command Line Tools or Xcode to see file history.") + case .notInRepository: + return String(localized: "This file is not in a Git repository.") + case .noCommitsYet: + return String(localized: "This repository has no commits yet.") + case .commandFailed(let message): + return message + case .undecodableContent: + return String(localized: "This version is not readable as text.") + case .storedInLargeFileStorage: + return String(localized: "This file is stored with Git LFS. Restore it with your Git client.") + case .fileChangedBeforeWriting: + return String(localized: "The file or its staged version changed before it could be written. Nothing was replaced.") + case .restoreFailed(let message): + return String(format: String(localized: "The version could not be restored: %@"), message) + } + } +} + +internal struct VersionRestorePlan: Sendable { + let replacesUncommittedChanges: Bool + let apply: @Sendable () async throws -> Void +} + +internal protocol VersionHistoryProvider: Sendable { + func loadHistory() async throws -> VersionHistoryPage + func content(of reference: VersionHistoryReference) async throws -> String + func prepareRestore(_ reference: VersionHistoryReference) async throws -> VersionRestorePlan +} diff --git a/TablePro/Models/Query/EditorTabPayload.swift b/TablePro/Models/Query/EditorTabPayload.swift index d4e76f1c31..c461d5cb01 100644 --- a/TablePro/Models/Query/EditorTabPayload.swift +++ b/TablePro/Models/Query/EditorTabPayload.swift @@ -58,6 +58,7 @@ internal struct EditorTabPayload: Codable, Hashable { internal let erDiagramSchemaKey: String? /// The routine or trigger a .objectSource tab shows internal let objectRef: DatabaseObjectRef? + internal let versionHistorySubject: VersionHistorySubject? /// Tab title (for restoring persisted tabs with their original names) internal let tabTitle: String? /// The intent behind creating this tab @@ -68,7 +69,7 @@ internal struct EditorTabPayload: Codable, Hashable { case initialQuery, isView, objectType, showStructure, skipAutoExecute, isPreview case forcesNewTab case tabTitle - case initialFilterState, sourceFileURL, erDiagramSchemaKey, objectRef, intent + case initialFilterState, sourceFileURL, erDiagramSchemaKey, objectRef, versionHistorySubject, intent // Legacy key for backward decoding only case isNewTab } @@ -91,6 +92,7 @@ internal struct EditorTabPayload: Codable, Hashable { sourceFileURL: URL? = nil, erDiagramSchemaKey: String? = nil, objectRef: DatabaseObjectRef? = nil, + versionHistorySubject: VersionHistorySubject? = nil, tabTitle: String? = nil, intent: TabIntent = .openContent ) { @@ -111,6 +113,7 @@ internal struct EditorTabPayload: Codable, Hashable { self.sourceFileURL = sourceFileURL self.erDiagramSchemaKey = erDiagramSchemaKey self.objectRef = objectRef + self.versionHistorySubject = versionHistorySubject self.tabTitle = tabTitle self.intent = intent } @@ -137,6 +140,7 @@ internal struct EditorTabPayload: Codable, Hashable { sourceFileURL = try container.decodeIfPresent(URL.self, forKey: .sourceFileURL) erDiagramSchemaKey = try container.decodeIfPresent(String.self, forKey: .erDiagramSchemaKey) objectRef = try container.decodeIfPresent(DatabaseObjectRef.self, forKey: .objectRef) + versionHistorySubject = try container.decodeIfPresent(VersionHistorySubject.self, forKey: .versionHistorySubject) tabTitle = try container.decodeIfPresent(String.self, forKey: .tabTitle) if let decodedIntent = try container.decodeIfPresent(TabIntent.self, forKey: .intent) { intent = decodedIntent @@ -165,6 +169,7 @@ internal struct EditorTabPayload: Codable, Hashable { try container.encodeIfPresent(sourceFileURL, forKey: .sourceFileURL) try container.encodeIfPresent(erDiagramSchemaKey, forKey: .erDiagramSchemaKey) try container.encodeIfPresent(objectRef, forKey: .objectRef) + try container.encodeIfPresent(versionHistorySubject, forKey: .versionHistorySubject) try container.encodeIfPresent(tabTitle, forKey: .tabTitle) try container.encode(intent, forKey: .intent) } @@ -188,6 +193,7 @@ internal struct EditorTabPayload: Codable, Hashable { self.sourceFileURL = tab.content.sourceFileURL self.erDiagramSchemaKey = tab.display.erDiagramSchemaKey self.objectRef = tab.display.objectRef + self.versionHistorySubject = tab.display.versionHistorySubject self.tabTitle = tab.title self.intent = .openContent } diff --git a/TablePro/Models/Query/QueryTab.swift b/TablePro/Models/Query/QueryTab.swift index 4998fef612..12402c6322 100644 --- a/TablePro/Models/Query/QueryTab.swift +++ b/TablePro/Models/Query/QueryTab.swift @@ -233,7 +233,8 @@ struct QueryTab: Identifiable, Equatable { ) self.display = TabDisplayState( erDiagramSchemaKey: persisted.erDiagramSchemaKey, - objectRef: persisted.objectRef + objectRef: persisted.objectRef, + versionHistorySubject: persisted.versionHistorySubject ) self.pendingChanges = TabChangeSnapshot() self.selectedRowIndices = [] @@ -410,6 +411,7 @@ struct QueryTab: Identifiable, Equatable { sourceFileURL: content.sourceFileURL, erDiagramSchemaKey: display.erDiagramSchemaKey, objectRef: display.objectRef, + versionHistorySubject: display.versionHistorySubject, queryParameters: content.queryParameters.isEmpty ? nil : content.queryParameters, sortColumns: persistedSort, sortSource: persistedSortSource, diff --git a/TablePro/Models/Query/QueryTabManager.swift b/TablePro/Models/Query/QueryTabManager.swift index f6dd20a554..c0d94886df 100644 --- a/TablePro/Models/Query/QueryTabManager.swift +++ b/TablePro/Models/Query/QueryTabManager.swift @@ -508,6 +508,30 @@ final class QueryTabManager: ObservableObject { selectedTabId = newTab.id } + func addVersionHistoryTab(subject: VersionHistorySubject, title: String) { + if let existing = tabs.first(where: { + $0.tabType == .versionHistory && $0.display.versionHistorySubject == subject + }) { + selectedTabId = existing.id + return + } + var newTab = QueryTab(title: title, tabType: .versionHistory) + newTab.tableContext.isEditable = false + newTab.display.versionHistorySubject = subject + newTab.hasUserInteraction = true + tabs.append(newTab) + selectedTabId = newTab.id + } + + static var versionHistoryFallbackTitle: String { + String(localized: "History") + } + + static func versionHistoryTitle(for name: String) -> String { + guard !name.isBlank else { return versionHistoryFallbackTitle } + return String(format: String(localized: "History: %@"), name) + } + static func objectSourceTitle(for objectRef: DatabaseObjectRef) -> String { let format: String switch objectRef.kind { diff --git a/TablePro/Models/Query/QueryTabState.swift b/TablePro/Models/Query/QueryTabState.swift index 8f011c2818..76a0a38bbf 100644 --- a/TablePro/Models/Query/QueryTabState.swift +++ b/TablePro/Models/Query/QueryTabState.swift @@ -22,6 +22,7 @@ enum TabType: Equatable, Codable, Hashable { case usersRoles case insights case objectSource + case versionHistory } /// Minimal representation of a tab for persistence @@ -41,6 +42,7 @@ struct PersistedTab: Codable { var sourceFileURL: URL? var erDiagramSchemaKey: String? var objectRef: DatabaseObjectRef? + var versionHistorySubject: VersionHistorySubject? var queryParameters: [QueryParameter]? var sortColumns: [PersistedSortColumn]? /// Who chose the saved order. Absent in every file written before this existed, which decodes @@ -72,6 +74,7 @@ struct PersistedTab: Codable { sourceFileURL: URL? = nil, erDiagramSchemaKey: String? = nil, objectRef: DatabaseObjectRef? = nil, + versionHistorySubject: VersionHistorySubject? = nil, queryParameters: [QueryParameter]? = nil, sortColumns: [PersistedSortColumn]? = nil, sortSource: SortSource? = nil, @@ -96,6 +99,7 @@ struct PersistedTab: Codable { self.sourceFileURL = sourceFileURL self.erDiagramSchemaKey = erDiagramSchemaKey self.objectRef = objectRef + self.versionHistorySubject = versionHistorySubject self.queryParameters = queryParameters self.sortColumns = sortColumns self.sortSource = sortSource @@ -111,7 +115,7 @@ struct PersistedTab: Codable { private enum CodingKeys: String, CodingKey { case id, title, query, tabType, tableName, isView, objectTypeRawValue, databaseName, schemaName - case sourceFileURL, erDiagramSchemaKey, objectRef, queryParameters + case sourceFileURL, erDiagramSchemaKey, objectRef, versionHistorySubject, queryParameters case sortColumns, sortSource, restoredPage, restoredPageSize, cursorOffset, cursorLength case collapsedFoldRanges case columnWidths, columnContentWidths, windowGroupIndex @@ -132,6 +136,7 @@ struct PersistedTab: Codable { sourceFileURL = try container.decodeIfPresent(URL.self, forKey: .sourceFileURL) erDiagramSchemaKey = try container.decodeIfPresent(String.self, forKey: .erDiagramSchemaKey) objectRef = try container.decodeIfPresent(DatabaseObjectRef.self, forKey: .objectRef) + versionHistorySubject = try container.decodeIfPresent(VersionHistorySubject.self, forKey: .versionHistorySubject) queryParameters = try container.decodeIfPresent([QueryParameter].self, forKey: .queryParameters) sortColumns = try container.decodeIfPresent([PersistedSortColumn].self, forKey: .sortColumns) sortSource = try container.decodeIfPresent(SortSource.self, forKey: .sortSource) @@ -685,6 +690,7 @@ struct TabDisplayState: Equatable { var spatialColumns: [SpatialColumn] = [] var erDiagramSchemaKey: String? var objectRef: DatabaseObjectRef? + var versionHistorySubject: VersionHistorySubject? var isResultsCollapsed: Bool = false var resultSets: [ResultSet] = [] var activeResultSetId: UUID? diff --git a/TablePro/Models/Query/SQLFavoriteVersion.swift b/TablePro/Models/Query/SQLFavoriteVersion.swift new file mode 100644 index 0000000000..e499ebb945 --- /dev/null +++ b/TablePro/Models/Query/SQLFavoriteVersion.swift @@ -0,0 +1,14 @@ +// +// SQLFavoriteVersion.swift +// TablePro +// + +import Foundation + +internal struct SQLFavoriteVersion: Identifiable, Hashable, Sendable { + let id: Int64 + let favoriteId: UUID + let name: String + let query: String + let savedAt: Date +} diff --git a/TablePro/Models/UI/GridSelectionOwner.swift b/TablePro/Models/UI/GridSelectionOwner.swift index a4fb7acfd3..070af19998 100644 --- a/TablePro/Models/UI/GridSelectionOwner.swift +++ b/TablePro/Models/UI/GridSelectionOwner.swift @@ -41,7 +41,7 @@ internal enum GridSelectionOwner: Equatable { /// indices it writes are the data grid's display positions, resolved through /// `DisplayRowMapping`. return .dataGrid - case .createTable, .erDiagram, .serverDashboard, .usersRoles, .insights, .objectSource: + case .createTable, .erDiagram, .serverDashboard, .usersRoles, .insights, .objectSource, .versionHistory: return .none } } diff --git a/TablePro/Models/UI/PendingChangeKind.swift b/TablePro/Models/UI/PendingChangeKind.swift index 23f2bf68f7..a93840100b 100644 --- a/TablePro/Models/UI/PendingChangeKind.swift +++ b/TablePro/Models/UI/PendingChangeKind.swift @@ -46,7 +46,7 @@ internal enum PendingChangeKind: Equatable, Hashable, Sendable { return hasCreateTablePending ? .createTable : nil case .usersRoles: return hasPrincipalChanges ? .principals : nil - case .query, .table, .erDiagram, .serverDashboard, .insights, .objectSource: + case .query, .table, .erDiagram, .serverDashboard, .insights, .objectSource, .versionHistory: return contentKind( hasDataChanges: hasDataChanges, hasStructureChanges: hasStructureChanges, diff --git a/TablePro/Resources/TablePro.sdef b/TablePro/Resources/TablePro.sdef index d2eb114f8b..7af1f3b144 100644 --- a/TablePro/Resources/TablePro.sdef +++ b/TablePro/Resources/TablePro.sdef @@ -31,6 +31,7 @@ + diff --git a/TablePro/ViewModels/FavoritesSidebarViewModel+LinkedFolders.swift b/TablePro/ViewModels/FavoritesSidebarViewModel+LinkedFolders.swift index 8f4e705938..b985919b67 100644 --- a/TablePro/ViewModels/FavoritesSidebarViewModel+LinkedFolders.swift +++ b/TablePro/ViewModels/FavoritesSidebarViewModel+LinkedFolders.swift @@ -20,6 +20,7 @@ extension FavoritesSidebarViewModel { internal func startWatchingLinkedFolders() { SQLFolderWatcher.shared.start() + LinkedFolderGitStatusStore.shared.start() } internal func reloadLinkedFolders() { diff --git a/TablePro/ViewModels/VersionHistoryViewModel.swift b/TablePro/ViewModels/VersionHistoryViewModel.swift new file mode 100644 index 0000000000..6d275ca2b5 --- /dev/null +++ b/TablePro/ViewModels/VersionHistoryViewModel.swift @@ -0,0 +1,196 @@ +// +// VersionHistoryViewModel.swift +// TablePro +// + +import Combine +import Foundation +import os + +internal struct VersionHistoryComparison: Equatable { + let older: VersionHistoryEntry + let newer: VersionHistoryEntry + let outcome: VersionComparison +} + +internal struct VersionHistoryDetail: Equatable { + let entry: VersionHistoryEntry + let content: String + let comparison: VersionHistoryComparison? +} + +@MainActor +internal final class VersionHistoryViewModel: ObservableObject { + private static let logger = Logger(subsystem: "com.TablePro", category: "VersionHistory") + + internal enum ListState: Equatable { + case loading + case failed(String) + case loaded + } + + internal enum DetailState: Equatable { + case empty + case loading + case failed(String) + case loaded(VersionHistoryDetail) + } + + internal enum DisplayMode: Hashable { + case changes + case content + } + + @Published private(set) var listState: ListState = .loading + @Published private(set) var page: VersionHistoryPage = .empty + @Published private(set) var detailState: DetailState = .empty + @Published private(set) var isRestoring = false + @Published var displayMode: DisplayMode = .changes + @Published var diffLayout: TextDiffLayout = .split + @Published var selection: VersionHistoryReference? { + didSet { + guard selection != oldValue else { return } + loadDetail() + } + } + + var onRestored: () -> Void = {} + var confirmReplacingUncommittedChanges: () async -> Bool = { true } + var reportRestoreFailure: (String) -> Void = { _ in } + + let subject: VersionHistorySubject + private let provider: any VersionHistoryProvider + private var pastContentCache: [VersionHistoryReference: String] = [:] + private var listTask: Task? + private(set) var detailTask: Task? + private var cancellables: Set = [] + + init( + subject: VersionHistorySubject, + provider: any VersionHistoryProvider, + refreshSignal: AnyPublisher + ) { + self.subject = subject + self.provider = provider + refreshSignal + .debounce(for: .milliseconds(250), scheduler: DispatchQueue.main) + .sink { [weak self] in self?.reload() } + .store(in: &cancellables) + } + + var selectedEntry: VersionHistoryEntry? { + guard let selection else { return nil } + return page.entries.first { $0.reference == selection } + } + + private var shownReference: VersionHistoryReference? { + guard case .loaded(let detail) = detailState else { return nil } + return detail.entry.reference + } + + var canRestoreSelection: Bool { + guard let entry = selectedEntry else { return false } + return !entry.isCurrent && !isRestoring + } + + func reload() { + listTask?.cancel() + listTask = Task { [weak self] in + await self?.loadList() + } + } + + func loadList() async { + if page.entries.isEmpty { + listState = .loading + } + do { + let loaded = try await provider.loadHistory() + guard !Task.isCancelled else { return } + page = loaded + listState = .loaded + if let selection, loaded.entries.contains(where: { $0.reference == selection }) { + loadDetail() + } else { + selection = loaded.entries.first?.reference + } + } catch { + guard !Task.isCancelled else { return } + Self.logger.warning("Version history failed to load: \(error.publicLogShape, privacy: .public)") + let subjectIsGone = (error as? VersionHistoryError) == .subjectNotFound + guard page.entries.isEmpty || subjectIsGone else { return } + page = .empty + selection = nil + detailState = .empty + listState = .failed(error.localizedDescription) + } + } + + func restore(_ entry: VersionHistoryEntry) async { + guard !entry.isCurrent, !isRestoring else { return } + isRestoring = true + defer { isRestoring = false } + do { + let plan = try await provider.prepareRestore(entry.reference) + if plan.replacesUncommittedChanges { + guard await confirmReplacingUncommittedChanges() else { return } + } + try await plan.apply() + onRestored() + selection = .current + await loadList() + } catch { + reportRestoreFailure(error.localizedDescription) + } + } + + private func loadDetail() { + detailTask?.cancel() + guard let entry = selectedEntry else { + detailState = .empty + return + } + if shownReference != entry.reference { + detailState = .loading + } + let baseline = page.baseline(for: entry.reference) + detailTask = Task { [weak self] in + guard let self else { return } + do { + let content = try await content(of: entry.reference) + let comparison = try await comparison(for: entry, content: content, baseline: baseline) + guard !Task.isCancelled else { return } + detailState = .loaded(VersionHistoryDetail(entry: entry, content: content, comparison: comparison)) + } catch { + guard !Task.isCancelled else { return } + detailState = .failed(error.localizedDescription) + } + } + } + + private func comparison( + for entry: VersionHistoryEntry, + content: String, + baseline: VersionHistoryEntry? + ) async throws -> VersionHistoryComparison? { + guard let baseline else { return nil } + let baselineContent = try await self.content(of: baseline.reference) + let (older, newer) = entry.isCurrent ? (baseline, entry) : (entry, baseline) + let (olderContent, newerContent) = entry.isCurrent ? (baselineContent, content) : (content, baselineContent) + let outcome = await Task.detached(priority: .userInitiated) { + VersionComparison.compare(baseline: olderContent, current: newerContent) + }.value + return VersionHistoryComparison(older: older, newer: newer, outcome: outcome) + } + + private func content(of reference: VersionHistoryReference) async throws -> String { + if let cached = pastContentCache[reference] { + return cached + } + let content = try await provider.content(of: reference) + if reference != .current { + pastContentCache[reference] = content + } + return content + } +} diff --git a/TablePro/Views/Compare/StructureDefinitionDiffView.swift b/TablePro/Views/Compare/StructureDefinitionDiffView.swift index 518791e2b2..c18a9b8501 100644 --- a/TablePro/Views/Compare/StructureDefinitionDiffView.swift +++ b/TablePro/Views/Compare/StructureDefinitionDiffView.swift @@ -18,8 +18,6 @@ internal struct StructureDefinitionDiffView: View { @State private var isUnified = false - @Environment(\.accessibilityDifferentiateWithoutColor) private var differentiateWithoutColor - private var pairs: [DiffPair] { DiffComputer.computeSplit(before: targetLines, after: sourceLines) } @@ -40,109 +38,12 @@ internal struct StructureDefinitionDiffView: View { } .padding(.bottom, 6) - if isUnified { - unifiedBody - } else { - splitBody - } - } - } - - private var splitBody: some View { - VStack(spacing: 0) { - HStack(spacing: 0) { - columnHeader(targetLabel) - columnHeader(sourceLabel) - } - ForEach(Array(pairs.enumerated()), id: \.offset) { _, pair in - HStack(spacing: 0) { - diffCell(pair.before, kind: pair.kind, isBefore: true) - diffCell(pair.after, kind: pair.kind, isBefore: false) - } - } - } - .background(RoundedRectangle(cornerRadius: 4).stroke(Color.secondary.opacity(0.2))) - } - - private var unifiedBody: some View { - VStack(alignment: .leading, spacing: 0) { - ForEach(DiffComputer.computeUnified(from: pairs)) { line in - HStack(spacing: 6) { - Text(marker(for: line.kind)) - .font(.system(.caption2, design: .monospaced)) - .frame(width: 12) - Text(line.text) - .font(.system(.caption, design: .monospaced)) - .textSelection(.enabled) - Spacer(minLength: 0) - } - .padding(.horizontal, 6) - .padding(.vertical, 1) - .background(background(for: line.kind)) - } - } - .background(RoundedRectangle(cornerRadius: 4).stroke(Color.secondary.opacity(0.2))) - } - - private func columnHeader(_ title: String) -> some View { - Text(title) - .font(.caption.weight(.semibold)) - .foregroundStyle(.secondary) - .frame(maxWidth: .infinity, alignment: .leading) - .padding(.horizontal, 6) - .padding(.vertical, 3) - } - - private func diffCell(_ text: String?, kind: DiffPair.Kind, isBefore: Bool) -> some View { - HStack(spacing: 4) { - Text(glyph(for: kind, isBefore: isBefore)) - .font(.system(.caption2, design: .monospaced)) - .frame(width: 10) - Text(text ?? "") - .font(.system(.caption, design: .monospaced)) - .textSelection(.enabled) - Spacer(minLength: 0) - } - .padding(.horizontal, 6) - .padding(.vertical, 1) - .frame(maxWidth: .infinity, alignment: .leading) - .background(splitBackground(kind: kind, isBefore: isBefore, isEmpty: text == nil)) - } - - private func glyph(for kind: DiffPair.Kind, isBefore: Bool) -> String { - switch kind { - case .unchanged: return " " - case .changed: return "~" - case .added: return isBefore ? " " : "+" - case .removed: return isBefore ? "-" : " " - } - } - - private func marker(for kind: DiffUnifiedLine.Kind) -> String { - switch kind { - case .context: return " " - case .added: return "+" - case .removed: return "-" - } - } - - private func splitBackground(kind: DiffPair.Kind, isBefore: Bool, isEmpty: Bool) -> Color { - guard !differentiateWithoutColor else { return .clear } - guard !isEmpty else { return Color.secondary.opacity(0.05) } - switch kind { - case .unchanged: return .clear - case .changed: return CompareStatusStyle.rowTint(for: .update) - case .added: return isBefore ? .clear : CompareStatusStyle.rowTint(for: .insert) - case .removed: return isBefore ? CompareStatusStyle.rowTint(for: .delete) : .clear - } - } - - private func background(for kind: DiffUnifiedLine.Kind) -> Color { - guard !differentiateWithoutColor else { return .clear } - switch kind { - case .context: return .clear - case .added: return CompareStatusStyle.rowTint(for: .insert) - case .removed: return CompareStatusStyle.rowTint(for: .delete) + TextDiffView( + pairs: pairs, + beforeLabel: targetLabel, + afterLabel: sourceLabel, + layout: isUnified ? .unified : .split + ) } } } diff --git a/TablePro/Views/Main/Child/MainEditorContentView.swift b/TablePro/Views/Main/Child/MainEditorContentView.swift index 96a5e6b017..4ff31557d6 100644 --- a/TablePro/Views/Main/Child/MainEditorContentView.swift +++ b/TablePro/Views/Main/Child/MainEditorContentView.swift @@ -255,6 +255,40 @@ struct MainEditorContentView: View { queryInsightsContent(tab: tab) case .objectSource: objectSourceContent(tab: tab) + case .versionHistory: + versionHistoryContent(tab: tab) + } + } + + // MARK: - Version History Tab Content + + @ViewBuilder + private func versionHistoryContent(tab: QueryTab) -> some View { + if let subject = tab.display.versionHistorySubject { + VersionHistoryTabView( + tabId: tab.id, + subject: subject, + databaseType: connection.type, + exportFileName: Self.versionHistoryExportName(for: subject, title: tab.title), + onOpenInEditor: { content in + coordinator.openVersionInEditor(content) + } + ) + .id(subject) + } else { + UnavailableStateView( + String(localized: "No History"), + systemImage: "clock.arrow.circlepath" + ) + } + } + + private static func versionHistoryExportName(for subject: VersionHistorySubject, title: String) -> String { + switch subject { + case .linkedFile(let url): + return url.lastPathComponent + case .savedQuery: + return "query.sql" } } diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift index 09faf0c415..a968b11ac8 100644 --- a/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift +++ b/TablePro/Views/Main/Extensions/MainContentCoordinator+Refresh.swift @@ -6,6 +6,7 @@ // import AppKit +import Combine import Foundation extension MainContentCoordinator { @@ -41,6 +42,10 @@ extension MainContentCoordinator { onDiscard: @escaping () -> Void ) { guard let (tab, _) = tabManager.selectedTabAndIndex else { return } + if tab.tabType == .versionHistory { + AppEvents.shared.versionHistoryRefreshRequested.send(tab.id) + return + } if tab.display.resultsViewMode == .structure { structureActions?.refresh?() return diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+VersionHistory.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+VersionHistory.swift new file mode 100644 index 0000000000..0d8313d732 --- /dev/null +++ b/TablePro/Views/Main/Extensions/MainContentCoordinator+VersionHistory.swift @@ -0,0 +1,68 @@ +// +// MainContentCoordinator+VersionHistory.swift +// TablePro +// + +import Foundation +import os + +extension MainContentCoordinator { + private static let versionHistoryLogger = Logger(subsystem: "com.TablePro", category: "VersionHistory") + + func showVersionHistory(of favorite: SQLFavorite) { + openVersionHistory(subject: .savedQuery(id: favorite.id), name: favorite.name) + } + + func showVersionHistory(of linked: LinkedSQLFavorite) { + openVersionHistory(subject: .linkedFile(url: linked.fileURL), name: linked.fileURL.lastPathComponent) + } + + func openVersionInEditor(_ content: String) { + let payload = EditorTabPayload( + connectionId: connectionId, + tabType: .query, + databaseName: browseDatabaseName, + initialQuery: content, + skipAutoExecute: true + ) + WindowManager.shared.openTab(payload: payload) + } + + func discardChanges(to linked: LinkedSQLFavorite, confirm: () async -> Bool) async { + do { + let plan = try await LinkedFileVersionHistoryProvider(fileURL: linked.fileURL).prepareDiscard() + guard await confirm() else { return } + try await plan.apply() + Self.reloadUnmodifiedFileTabs(at: linked.fileURL) + LinkedFolderGitStatusStore.shared.scheduleRefresh(after: .zero) + } catch { + Self.versionHistoryLogger.error("Discarding changes failed: \(error.publicLogShape, privacy: .public)") + AlertHelper.showErrorSheet( + title: String(localized: "Couldn't Discard Changes"), + message: error.localizedDescription, + window: nil + ) + } + } + + static func reloadUnmodifiedFileTabs(at url: URL) { + let target = url.standardizedFileURL + for coordinator in activeCoordinators.values { + for tab in coordinator.tabManager.tabs + where tab.content.sourceFileURL?.standardizedFileURL == target && !tab.content.isFileDirty { + coordinator.commandActions?.reloadFileFromDisk(tabId: tab.id, url: url) + } + } + } + + private func openVersionHistory(subject: VersionHistorySubject, name: String) { + let payload = EditorTabPayload( + connectionId: connectionId, + tabType: .versionHistory, + databaseName: browseDatabaseName, + versionHistorySubject: subject, + tabTitle: QueryTabManager.versionHistoryTitle(for: name) + ) + WindowManager.shared.openTab(payload: payload) + } +} diff --git a/TablePro/Views/Shared/TextDiffView.swift b/TablePro/Views/Shared/TextDiffView.swift new file mode 100644 index 0000000000..4c8a5d8946 --- /dev/null +++ b/TablePro/Views/Shared/TextDiffView.swift @@ -0,0 +1,143 @@ +// +// TextDiffView.swift +// TablePro +// + +import SwiftUI + +internal enum TextDiffLayout: Hashable { + case split + case unified +} + +internal struct TextDiffView: View { + internal let pairs: [DiffPair] + internal let beforeLabel: String + internal let afterLabel: String + internal let layout: TextDiffLayout + internal var textFont: Font = .system(.caption, design: .monospaced) + + @Environment(\.accessibilityDifferentiateWithoutColor) private var differentiateWithoutColor + + internal var body: some View { + switch layout { + case .split: + splitBody + case .unified: + unifiedBody + } + } + + private var splitBody: some View { + LazyVStack(spacing: 0) { + HStack(spacing: 0) { + columnHeader(beforeLabel) + columnHeader(afterLabel) + } + ForEach(Array(pairs.enumerated()), id: \.offset) { _, pair in + HStack(spacing: 0) { + diffCell(pair.before, kind: pair.kind, side: .before) + diffCell(pair.after, kind: pair.kind, side: .after) + } + } + } + .background(RoundedRectangle(cornerRadius: 4).stroke(Color.secondary.opacity(0.2))) + } + + private var unifiedBody: some View { + LazyVStack(alignment: .leading, spacing: 0) { + ForEach(DiffComputer.computeUnified(from: pairs)) { line in + HStack(spacing: 6) { + Text(verbatim: marker(for: line.kind)) + .font(.system(.caption2, design: .monospaced)) + .frame(width: 12) + .accessibilityHidden(true) + Text(verbatim: line.text) + .font(textFont) + .textSelection(.enabled) + Spacer(minLength: 0) + } + .padding(.horizontal, 6) + .padding(.vertical, 1) + .background(background(for: line.kind)) + .accessibilityElement(children: .combine) + .accessibilityLabel(accessibilityLabel(for: line)) + } + } + .background(RoundedRectangle(cornerRadius: 4).stroke(Color.secondary.opacity(0.2))) + } + + private func columnHeader(_ title: String) -> some View { + Text(title) + .font(.caption.weight(.semibold)) + .foregroundStyle(.secondary) + .frame(maxWidth: .infinity, alignment: .leading) + .padding(.horizontal, 6) + .padding(.vertical, 3) + } + + private func diffCell(_ text: String?, kind: DiffPair.Kind, side: SqlWalkthroughAnchor.Side) -> some View { + HStack(spacing: 4) { + Text(verbatim: SplitDiffMarker.resolve(kind: kind, side: side)?.glyph ?? " ") + .font(.system(.caption2, design: .monospaced)) + .frame(width: 10) + .accessibilityHidden(true) + Text(verbatim: text ?? "") + .font(textFont) + .textSelection(.enabled) + Spacer(minLength: 0) + } + .padding(.horizontal, 6) + .padding(.vertical, 1) + .frame(maxWidth: .infinity, alignment: .leading) + .background(splitBackground(kind: kind, side: side, isEmpty: text == nil)) + .accessibilityElement(children: .combine) + .accessibilityLabel(accessibilityLabel(for: text, kind: kind, side: side)) + } + + private func marker(for kind: DiffUnifiedLine.Kind) -> String { + switch kind { + case .context: return " " + case .added: return SplitDiffMarker.added.glyph + case .removed: return SplitDiffMarker.removed.glyph + } + } + + private func accessibilityLabel(for line: DiffUnifiedLine) -> String { + switch line.kind { + case .context: + return line.text + case .added: + return String(format: String(localized: "%@: %@"), SplitDiffMarker.added.label, line.text) + case .removed: + return String(format: String(localized: "%@: %@"), SplitDiffMarker.removed.label, line.text) + } + } + + private func accessibilityLabel(for text: String?, kind: DiffPair.Kind, side: SqlWalkthroughAnchor.Side) -> String { + guard let text else { return "" } + guard let marker = SplitDiffMarker.resolve(kind: kind, side: side) else { return text } + return String(format: String(localized: "%@: %@"), marker.label, text) + } + + private func splitBackground(kind: DiffPair.Kind, side: SqlWalkthroughAnchor.Side, isEmpty: Bool) -> Color { + guard !differentiateWithoutColor else { return .clear } + guard !isEmpty else { return Color.secondary.opacity(0.05) } + switch (kind, side) { + case (.unchanged, _): return .clear + case (.changed, _): return CompareStatusStyle.rowTint(for: .update) + case (.added, .after): return CompareStatusStyle.rowTint(for: .insert) + case (.removed, .before): return CompareStatusStyle.rowTint(for: .delete) + default: return .clear + } + } + + private func background(for kind: DiffUnifiedLine.Kind) -> Color { + guard !differentiateWithoutColor else { return .clear } + switch kind { + case .context: return .clear + case .added: return CompareStatusStyle.rowTint(for: .insert) + case .removed: return CompareStatusStyle.rowTint(for: .delete) + } + } +} diff --git a/TablePro/Views/Sidebar/FavoritesOutlineCoordinator.swift b/TablePro/Views/Sidebar/FavoritesOutlineCoordinator.swift index 2df3154b3f..fcf6540a01 100644 --- a/TablePro/Views/Sidebar/FavoritesOutlineCoordinator.swift +++ b/TablePro/Views/Sidebar/FavoritesOutlineCoordinator.swift @@ -324,7 +324,8 @@ internal final class FavoritesOutlineCoordinator: NSObject, NSOutline allFolders: owner.input.allFolders, teamLibraryAvailable: owner.input.teamLibraryAvailable, databaseEntityName: owner.input.databaseEntityName, - activeDatabase: owner.input.activeDatabase + activeDatabase: owner.input.activeDatabase, + linkedFileGitStates: owner.input.linkedFileGitStates ) SidebarMenuBuilder.fill( menu, diff --git a/TablePro/Views/Sidebar/FavoritesOutlineView.swift b/TablePro/Views/Sidebar/FavoritesOutlineView.swift index dafc557b60..635cac5e43 100644 --- a/TablePro/Views/Sidebar/FavoritesOutlineView.swift +++ b/TablePro/Views/Sidebar/FavoritesOutlineView.swift @@ -21,6 +21,7 @@ internal struct FavoritesOutlineInput { internal let renamingFolderId: UUID? internal let allFolders: [SQLFavoriteFolder] internal let teamLibraryAvailable: Bool + internal var linkedFileGitStates: [UUID: LinkedFileGitState] = [:] } internal struct FavoritesOutlineTeamQuery { diff --git a/TablePro/Views/Sidebar/FavoritesTabView.swift b/TablePro/Views/Sidebar/FavoritesTabView.swift index 8f0d57e476..88ee0b4655 100644 --- a/TablePro/Views/Sidebar/FavoritesTabView.swift +++ b/TablePro/Views/Sidebar/FavoritesTabView.swift @@ -5,6 +5,7 @@ internal struct FavoritesTabView: View { @ObservedObject private var teamLibrarySync = TeamLibrarySyncCoordinator.shared @ObservedObject private var licenseManager = LicenseManager.shared @ObservedObject private var settingsManager = AppSettingsManager.shared + @ObservedObject private var gitStatusStore = LinkedFolderGitStatusStore.shared @Environment(\.sidebarRowSize) private var systemRowSize @StateObject private var viewModel: FavoritesSidebarViewModel @@ -300,7 +301,8 @@ internal struct FavoritesTabView: View { }, renamingFolderId: viewModel.renamingFolderId, allFolders: viewModel.nodes.collectFolders(), - teamLibraryAvailable: licenseManager.isFeatureAvailable(.teamLibrary) + teamLibraryAvailable: licenseManager.isFeatureAvailable(.teamLibrary), + linkedFileGitStates: gitStatusStore.states(for: Self.linkedFavorites(in: items)) ), selection: $sharedSidebarState.selectedFavorite, rowSizePreference: settingsManager.general.sidebarRowSize, @@ -396,7 +398,13 @@ internal struct FavoritesTabView: View { case .linkedSubfolder(_, let displayName, _): LinkedSubfolderRowLabel(displayName: displayName) case .linkedFavorite(let linked): - LinkedFavoriteRowView(favorite: linked) + LinkedFavoriteRowView(favorite: linked, gitState: gitStatusStore.state(for: linked)) + } + } + + private static func linkedFavorites(in nodes: [FavoriteNode]) -> [LinkedSQLFavorite] { + nodes.flatMap { node in + [node.asLinkedFavorite].compactMap { $0 } + linkedFavorites(in: node.children ?? []) } } @@ -547,6 +555,8 @@ internal struct FavoritesTabView: View { } case .deleteFavorite(let favorite): viewModel.deleteFavorite(favorite) + case .showFavoriteHistory(let favorite): + coordinator?.showVersionHistory(of: favorite) case .openLinkedFavorite(let favorite): coordinator?.openLinkedFavorite(favorite) case .editLinkedMetadata(let favorite): @@ -559,6 +569,10 @@ internal struct FavoritesTabView: View { case .trashLinkedFavorite(let favorite): linkedFileToTrash = favorite showTrashLinkedFileAlert = true + case .showLinkedFileHistory(let favorite): + coordinator?.showVersionHistory(of: favorite) + case .discardLinkedFileChanges(let favorite): + discardChanges(to: favorite) case .revealLinkedFolder(let folder): viewModel.revealLinkedFolder(folder) case .setLinkedFolderEnabled(let folder, let isEnabled): @@ -588,6 +602,21 @@ internal struct FavoritesTabView: View { } } + private func discardChanges(to favorite: LinkedSQLFavorite) { + let keepsStagedChanges = gitStatusStore.state(for: favorite)?.status?.hasStagedChanges == true + Task { @MainActor in + await coordinator?.discardChanges(to: favorite) { + await AlertHelper.confirmDestructive( + title: String(format: String(localized: "Discard changes to \"%@\"?"), favorite.fileURL.lastPathComponent), + message: keepsStagedChanges + ? String(localized: "The file goes back to its staged version. You can't undo this action.") + : String(localized: "The file goes back to its last committed version. You can't undo this action."), + confirmButton: String(localized: "Discard Changes") + ) + } + } + } + private func useDatabase(_ entry: FavoriteDatabaseEntry) { guard entry.database != activeDatabase else { return } Task { await coordinator?.switchDatabase(to: entry.database) } diff --git a/TablePro/Views/Sidebar/LinkedFavoriteRowView.swift b/TablePro/Views/Sidebar/LinkedFavoriteRowView.swift index 59e926d9f0..021950634d 100644 --- a/TablePro/Views/Sidebar/LinkedFavoriteRowView.swift +++ b/TablePro/Views/Sidebar/LinkedFavoriteRowView.swift @@ -7,6 +7,7 @@ import SwiftUI internal struct LinkedFavoriteRowView: View { let favorite: LinkedSQLFavorite + var gitState: LinkedFileGitState? var body: some View { HStack(spacing: 6) { @@ -38,6 +39,15 @@ internal struct LinkedFavoriteRowView: View { .background(Capsule().fill(.quaternary)) .accessibilityHidden(true) } + + if let status = gitState?.status { + Text(verbatim: status.badge.letter) + .font(.system(.caption, design: .monospaced).weight(.semibold)) + .foregroundStyle(.secondary) + .frame(minWidth: 12) + .help(status.accessibilityDescription) + .accessibilityHidden(true) + } } .accessibilityElement(children: .combine) .accessibilityLabel(accessibilityDescription) @@ -51,6 +61,9 @@ internal struct LinkedFavoriteRowView: View { if let keyword = favorite.keyword, !keyword.isEmpty { desc += ", " + String(format: String(localized: "keyword: %@"), keyword) } + if let status = gitState?.status { + desc += ", " + status.accessibilityDescription + } return desc } } diff --git a/TablePro/Views/Sidebar/Menu/FavoritesMenuCommand.swift b/TablePro/Views/Sidebar/Menu/FavoritesMenuCommand.swift index 0e64a14ffe..14c43940c9 100644 --- a/TablePro/Views/Sidebar/Menu/FavoritesMenuCommand.swift +++ b/TablePro/Views/Sidebar/Menu/FavoritesMenuCommand.swift @@ -25,12 +25,15 @@ internal enum FavoritesMenuCommand: Equatable { case editFavorite(SQLFavorite) case moveFavorite(id: UUID, toFolder: UUID?) case deleteFavorite(SQLFavorite) + case showFavoriteHistory(SQLFavorite) case openLinkedFavorite(LinkedSQLFavorite) case editLinkedMetadata(LinkedSQLFavorite) case copyLinkedFavoriteQuery(LinkedSQLFavorite) case revealLinkedFavorite(LinkedSQLFavorite) case trashLinkedFavorite(LinkedSQLFavorite) + case showLinkedFileHistory(LinkedSQLFavorite) + case discardLinkedFileChanges(LinkedSQLFavorite) case revealLinkedFolder(LinkedSQLFolder) case setLinkedFolderEnabled(LinkedSQLFolder, Bool) diff --git a/TablePro/Views/Sidebar/Menu/FavoritesMenuSpec.swift b/TablePro/Views/Sidebar/Menu/FavoritesMenuSpec.swift index a86807f6db..4ca256b55e 100644 --- a/TablePro/Views/Sidebar/Menu/FavoritesMenuSpec.swift +++ b/TablePro/Views/Sidebar/Menu/FavoritesMenuSpec.swift @@ -12,19 +12,22 @@ internal struct FavoritesMenuContext { internal let teamLibraryAvailable: Bool internal let databaseEntityName: String internal let activeDatabase: String? + internal let linkedFileGitStates: [UUID: LinkedFileGitState] internal init( clicked: FavoritesOutlineNode.Kind?, allFolders: [SQLFavoriteFolder] = [], teamLibraryAvailable: Bool = false, databaseEntityName: String = "Database", - activeDatabase: String? = nil + activeDatabase: String? = nil, + linkedFileGitStates: [UUID: LinkedFileGitState] = [:] ) { self.clicked = clicked self.allFolders = allFolders self.teamLibraryAvailable = teamLibraryAvailable self.databaseEntityName = databaseEntityName self.activeDatabase = activeDatabase + self.linkedFileGitStates = linkedFileGitStates } } @@ -100,7 +103,7 @@ internal enum FavoritesMenuSpec { case .favorite(let favorite): return favoriteSections(favorite, context: context) case .linkedFavorite(let linked): - return linkedFavoriteSections(linked) + return linkedFavoriteSections(linked, gitState: context.linkedFileGitStates[linked.id]) case .folder(let folder): return folderSections(folder) case .linkedFolder(let folder): @@ -118,7 +121,8 @@ internal enum FavoritesMenuSpec { ) -> [FavoritesMenuSection] { var edits: [FavoritesMenuItem] = [ .command(String(localized: "Copy Query"), .copyText(favorite.query)), - .command(String(localized: "Edit…"), .editFavorite(favorite)) + .command(String(localized: "Edit…"), .editFavorite(favorite)), + .command(String(localized: "Show History"), .showFavoriteHistory(favorite)) ] if let moveTo = moveToSubmenu(favorite, folders: context.allFolders) { edits.append(moveTo) @@ -163,12 +167,16 @@ internal enum FavoritesMenuSpec { ) } - private static func linkedFavoriteSections(_ favorite: LinkedSQLFavorite) -> [FavoritesMenuSection] { + private static func linkedFavoriteSections( + _ favorite: LinkedSQLFavorite, + gitState: LinkedFileGitState? + ) -> [FavoritesMenuSection] { [ FavoritesMenuSection([ .command(String(localized: "Open in Editor"), .openLinkedFavorite(favorite)), .command(String(localized: "Edit Metadata…"), .editLinkedMetadata(favorite)) ]), + FavoritesMenuSection(gitItems(favorite, gitState: gitState)), FavoritesMenuSection([ .command(String(localized: "Copy Query"), .copyLinkedFavoriteQuery(favorite)), .command(String(localized: "Show in Finder"), .revealLinkedFavorite(favorite)) @@ -179,6 +187,18 @@ internal enum FavoritesMenuSpec { ] } + private static func gitItems(_ favorite: LinkedSQLFavorite, gitState: LinkedFileGitState?) -> [FavoritesMenuItem] { + guard let gitState else { return [] } + var items: [FavoritesMenuItem] = [] + if gitState.hasCommittedHistory { + items.append(.command(String(localized: "Show History"), .showLinkedFileHistory(favorite))) + } + if gitState.canDiscardChanges { + items.append(.command(String(localized: "Discard Changes…"), .discardLinkedFileChanges(favorite))) + } + return items + } + private static func linkedFolderSections(_ folder: LinkedSQLFolder) -> [FavoritesMenuSection] { [ FavoritesMenuSection([ diff --git a/TablePro/Views/VersionHistory/VersionHistoryChangesView.swift b/TablePro/Views/VersionHistory/VersionHistoryChangesView.swift new file mode 100644 index 0000000000..a0204f47fb --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryChangesView.swift @@ -0,0 +1,64 @@ +// +// VersionHistoryChangesView.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryChangesView: View { + let detail: VersionHistoryDetail + let layout: TextDiffLayout + let databaseType: DatabaseType + let exportFileName: String + let onOpenInEditor: (String) -> Void + + var body: some View { + if let comparison = detail.comparison { + switch comparison.outcome { + case .identical: + UnavailableStateView( + String(localized: "No Changes"), + systemImage: "equal.circle", + description: Text(String( + format: String(localized: "This version matches %@."), + VersionHistoryFormatting.shortLabel(for: detail.entry.isCurrent ? comparison.older : comparison.newer) + )) + ) + case .tooLarge: + VStack(spacing: 0) { + Text("This version is too large to compare. Showing its content instead.") + .font(.callout) + .foregroundStyle(.secondary) + .frame(maxWidth: .infinity, alignment: .leading) + .padding(.horizontal, 12) + .padding(.vertical, 6) + Divider() + VersionHistoryContentView( + content: detail.content, + databaseType: databaseType, + exportFileName: exportFileName, + onOpenInEditor: onOpenInEditor + ) + } + case .differs(let pairs): + ScrollView { + TextDiffView( + pairs: pairs, + beforeLabel: VersionHistoryFormatting.shortLabel(for: comparison.older), + afterLabel: VersionHistoryFormatting.shortLabel(for: comparison.newer), + layout: layout, + textFont: .system(.body, design: .monospaced) + ) + .padding(12) + } + .accessibilityIdentifier("version-history-diff") + } + } else { + UnavailableStateView( + String(localized: "No Earlier Version"), + systemImage: "clock", + description: Text("There is nothing earlier to compare this version with.") + ) + } + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryContentView.swift b/TablePro/Views/VersionHistory/VersionHistoryContentView.swift new file mode 100644 index 0000000000..63cfcd81e7 --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryContentView.swift @@ -0,0 +1,22 @@ +// +// VersionHistoryContentView.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryContentView: View { + let content: String + let databaseType: DatabaseType + let exportFileName: String + let onOpenInEditor: (String) -> Void + + var body: some View { + ObjectSourceView( + source: content, + databaseType: databaseType, + exportFileName: exportFileName, + onOpenInEditor: { onOpenInEditor(content) } + ) + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryDetailHeader.swift b/TablePro/Views/VersionHistory/VersionHistoryDetailHeader.swift new file mode 100644 index 0000000000..616e25d36c --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryDetailHeader.swift @@ -0,0 +1,62 @@ +// +// VersionHistoryDetailHeader.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryDetailHeader: View { + @ObservedObject var viewModel: VersionHistoryViewModel + + var body: some View { + HStack(spacing: 12) { + if let entry = viewModel.selectedEntry { + VStack(alignment: .leading, spacing: 2) { + Text(VersionHistoryFormatting.title(for: entry)) + .font(.headline) + .lineLimit(1) + .truncationMode(.tail) + .textSelection(.enabled) + let subtitle = VersionHistoryFormatting.subtitle(for: entry) + if !subtitle.isEmpty { + Text(subtitle) + .font(.caption) + .foregroundStyle(.secondary) + .lineLimit(1) + .textSelection(.enabled) + } + } + } + Spacer(minLength: 8) + Picker(String(localized: "Show"), selection: $viewModel.displayMode) { + Text("Changes").tag(VersionHistoryViewModel.DisplayMode.changes) + Text("Content").tag(VersionHistoryViewModel.DisplayMode.content) + } + .pickerStyle(.segmented) + .labelsHidden() + .fixedSize() + .accessibilityIdentifier("version-history-display-mode") + if viewModel.displayMode == .changes { + Picker(String(localized: "Layout"), selection: $viewModel.diffLayout) { + Text("Split").tag(TextDiffLayout.split) + Text("Unified").tag(TextDiffLayout.unified) + } + .pickerStyle(.segmented) + .labelsHidden() + .fixedSize() + } + Button(String(localized: "Restore This Version"), action: restoreSelection) + .disabled(!viewModel.canRestoreSelection) + .help(String(localized: "Replace the current text with this version")) + .accessibilityIdentifier("version-history-restore") + } + .padding(.horizontal, 12) + .padding(.vertical, 8) + .background(Color(nsColor: .controlBackgroundColor)) + } + + private func restoreSelection() { + guard let entry = viewModel.selectedEntry else { return } + Task { await viewModel.restore(entry) } + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryDetailPane.swift b/TablePro/Views/VersionHistory/VersionHistoryDetailPane.swift new file mode 100644 index 0000000000..8c1bd58f88 --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryDetailPane.swift @@ -0,0 +1,57 @@ +// +// VersionHistoryDetailPane.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryDetailPane: View { + @ObservedObject var viewModel: VersionHistoryViewModel + let databaseType: DatabaseType + let exportFileName: String + let onOpenInEditor: (String) -> Void + + var body: some View { + VStack(spacing: 0) { + VersionHistoryDetailHeader(viewModel: viewModel) + Divider() + detail + .frame(maxWidth: .infinity, maxHeight: .infinity) + } + } + + @ViewBuilder + private var detail: some View { + switch viewModel.detailState { + case .empty: + UnavailableStateView(String(localized: "No Version Selected"), systemImage: "clock.arrow.circlepath") + case .loading: + ProgressView() + .frame(maxWidth: .infinity, maxHeight: .infinity) + case .failed(let message): + UnavailableStateView { + Label(String(localized: "Version Unavailable"), systemImage: "exclamationmark.triangle") + } description: { + Text(message) + } + case .loaded(let loaded): + switch viewModel.displayMode { + case .changes: + VersionHistoryChangesView( + detail: loaded, + layout: viewModel.diffLayout, + databaseType: databaseType, + exportFileName: exportFileName, + onOpenInEditor: onOpenInEditor + ) + case .content: + VersionHistoryContentView( + content: loaded.content, + databaseType: databaseType, + exportFileName: exportFileName, + onOpenInEditor: onOpenInEditor + ) + } + } + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryFactory.swift b/TablePro/Views/VersionHistory/VersionHistoryFactory.swift new file mode 100644 index 0000000000..cd08b4b162 --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryFactory.swift @@ -0,0 +1,49 @@ +// +// VersionHistoryFactory.swift +// TablePro +// + +import Combine +import Foundation + +@MainActor +internal enum VersionHistoryFactory { + static func makeViewModel(for subject: VersionHistorySubject) -> VersionHistoryViewModel { + let viewModel: VersionHistoryViewModel + switch subject { + case .savedQuery(let id): + viewModel = VersionHistoryViewModel( + subject: subject, + provider: SavedQueryVersionHistoryProvider(favoriteId: id, manager: .shared), + refreshSignal: AppEvents.shared.sqlFavoritesDidUpdate.map { _ in () }.eraseToAnyPublisher() + ) + case .linkedFile(let url): + viewModel = VersionHistoryViewModel( + subject: subject, + provider: LinkedFileVersionHistoryProvider(fileURL: url), + refreshSignal: AppEvents.shared.linkedSQLFoldersDidUpdate.map { _ in () } + .merge(with: LinkedFolderGitStatusStore.shared.$snapshots.dropFirst().map { _ in () }) + .eraseToAnyPublisher() + ) + viewModel.onRestored = { + MainContentCoordinator.reloadUnmodifiedFileTabs(at: url) + LinkedFolderGitStatusStore.shared.scheduleRefresh(after: .zero) + } + viewModel.confirmReplacingUncommittedChanges = { + await AlertHelper.confirmDestructive( + title: String(format: String(localized: "Restore this version of \"%@\"?"), url.lastPathComponent), + message: String(localized: "The file has uncommitted changes. Restoring this version replaces them, and you can't undo this action."), + confirmButton: String(localized: "Restore") + ) + } + } + viewModel.reportRestoreFailure = { message in + AlertHelper.showErrorSheet( + title: String(localized: "Couldn't Restore Version"), + message: message, + window: nil + ) + } + return viewModel + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryFormatting.swift b/TablePro/Views/VersionHistory/VersionHistoryFormatting.swift new file mode 100644 index 0000000000..7aadf83fdf --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryFormatting.swift @@ -0,0 +1,80 @@ +// +// VersionHistoryFormatting.swift +// TablePro +// + +import Foundation + +internal enum VersionHistoryFormatting { + static func title(for entry: VersionHistoryEntry) -> String { + if entry.isCurrent { + return String(localized: "Current Version") + } + if let summary = entry.summary, !summary.isBlank { + return summary + } + return dateText(for: entry) ?? String(localized: "Earlier Version") + } + + static func subtitle(for entry: VersionHistoryEntry) -> String { + var parts: [String] = [] + if entry.isCurrent, entry.hasUncommittedChanges { + parts.append(String(localized: "Uncommitted changes")) + } + if let author = entry.author, !author.isBlank { + parts.append(author) + } + let showsDateInTitle = !entry.isCurrent && (entry.summary ?? "").isBlank + if !showsDateInTitle, let date = dateText(for: entry) { + parts.append(date) + } + if let revision = entry.reference.shortRevision { + parts.append(revision) + } + return parts.joined(separator: " · ") + } + + static func rowSubtitle(for entry: VersionHistoryEntry) -> String { + var parts: [String] = [] + if entry.isCurrent, entry.hasUncommittedChanges { + parts.append(String(localized: "Uncommitted changes")) + } + if let author = entry.author, !author.isBlank { + parts.append(author) + } + let showsDateInTitle = !entry.isCurrent && (entry.summary ?? "").isBlank + if !showsDateInTitle, let date = entry.date { + parts.append(date.formatted(date: .abbreviated, time: .omitted)) + } + return parts.joined(separator: " · ") + } + + static func shortLabel(for entry: VersionHistoryEntry) -> String { + if entry.isCurrent { + return String(localized: "Current Version") + } + if let revision = entry.reference.shortRevision { + return revision + } + return dateText(for: entry) ?? String(localized: "Earlier Version") + } + + static func accessibilityLabel(for entry: VersionHistoryEntry) -> String { + let subtitle = subtitle(for: entry) + guard !subtitle.isEmpty else { return title(for: entry) } + return String(format: String(localized: "%@, %@"), title(for: entry), subtitle) + } + + static func noticeText(_ notice: VersionHistoryNotice) -> String { + switch notice { + case .keepsLatestVersions(let count): + return String(format: String(localized: "Keeps the last %d versions on this Mac."), count) + case .showsLatestCommits(let count): + return String(format: String(localized: "Showing the %d most recent commits."), count) + } + } + + private static func dateText(for entry: VersionHistoryEntry) -> String? { + entry.date?.formatted(date: .abbreviated, time: .shortened) + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryListPane.swift b/TablePro/Views/VersionHistory/VersionHistoryListPane.swift new file mode 100644 index 0000000000..0074899d40 --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryListPane.swift @@ -0,0 +1,62 @@ +// +// VersionHistoryListPane.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryListPane: View { + @ObservedObject var viewModel: VersionHistoryViewModel + + var body: some View { + FieldDrivenList( + sections: [FieldDrivenListSection(id: "versions", items: viewModel.page.entries)], + selection: selectionBinding, + rowHeight: 44, + menuItems: { ids in menuItems(for: ids) }, + acceptsFocus: true, + accessibilityIdentifier: "version-history-list", + row: { entry in VersionHistoryRowView(entry: entry) } + ) + .safeAreaInset(edge: .bottom, spacing: 0) { + if let notice = viewModel.page.notice { + VStack(spacing: 0) { + Divider() + Text(VersionHistoryFormatting.noticeText(notice)) + .font(.caption) + .foregroundStyle(.secondary) + .frame(maxWidth: .infinity, alignment: .leading) + .padding(.horizontal, 10) + .padding(.vertical, 6) + } + .background(Color(nsColor: .controlBackgroundColor)) + } + } + } + + private var selectionBinding: Binding> { + Binding( + get: { viewModel.selection.map { [$0] } ?? [] }, + set: { viewModel.selection = $0.first } + ) + } + + private func menuItems(for ids: Set) -> [FieldDrivenMenuItem] { + guard let id = ids.first, + let entry = viewModel.page.entries.first(where: { $0.reference == id }), + !entry.isCurrent + else { return [] } + return [ + FieldDrivenMenuItem( + title: String(localized: "Restore This Version"), + isEnabled: !viewModel.isRestoring + ) { + restore(entry) + } + ] + } + + private func restore(_ entry: VersionHistoryEntry) { + Task { await viewModel.restore(entry) } + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryRowView.swift b/TablePro/Views/VersionHistory/VersionHistoryRowView.swift new file mode 100644 index 0000000000..68053490af --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryRowView.swift @@ -0,0 +1,37 @@ +// +// VersionHistoryRowView.swift +// TablePro +// + +import SwiftUI + +internal struct VersionHistoryRowView: View { + let entry: VersionHistoryEntry + + var body: some View { + HStack(spacing: 8) { + Image(systemName: entry.isCurrent ? "doc.text" : "clock.arrow.circlepath") + .foregroundStyle(.secondary) + .frame(width: 16) + .accessibilityHidden(true) + VStack(alignment: .leading, spacing: 2) { + Text(VersionHistoryFormatting.title(for: entry)) + .bold(entry.isCurrent) + .lineLimit(1) + .truncationMode(.tail) + let subtitle = VersionHistoryFormatting.rowSubtitle(for: entry) + if !subtitle.isEmpty { + Text(subtitle) + .font(.caption) + .foregroundStyle(.secondary) + .lineLimit(1) + .truncationMode(.tail) + } + } + Spacer(minLength: 0) + } + .padding(.horizontal, 6) + .accessibilityElement(children: .ignore) + .accessibilityLabel(VersionHistoryFormatting.accessibilityLabel(for: entry)) + } +} diff --git a/TablePro/Views/VersionHistory/VersionHistoryTabView.swift b/TablePro/Views/VersionHistory/VersionHistoryTabView.swift new file mode 100644 index 0000000000..c0f1ec1289 --- /dev/null +++ b/TablePro/Views/VersionHistory/VersionHistoryTabView.swift @@ -0,0 +1,75 @@ +// +// VersionHistoryTabView.swift +// TablePro +// + +import Combine +import SwiftUI + +internal struct VersionHistoryTabView: View { + let tabId: UUID + let databaseType: DatabaseType + let exportFileName: String + let onOpenInEditor: (String) -> Void + + @StateObject private var viewModel: VersionHistoryViewModel + + init( + tabId: UUID, + subject: VersionHistorySubject, + databaseType: DatabaseType, + exportFileName: String, + onOpenInEditor: @escaping (String) -> Void + ) { + self.tabId = tabId + self.databaseType = databaseType + self.exportFileName = exportFileName + self.onOpenInEditor = onOpenInEditor + _viewModel = StateObject(wrappedValue: VersionHistoryFactory.makeViewModel(for: subject)) + } + + var body: some View { + content + .frame(maxWidth: .infinity, maxHeight: .infinity) + .background(Color(nsColor: .textBackgroundColor)) + .task { await viewModel.loadList() } + .onReceive(AppEvents.shared.versionHistoryRefreshRequested) { requestedTabId in + guard requestedTabId == tabId else { return } + viewModel.reload() + } + } + + @ViewBuilder + private var content: some View { + switch viewModel.listState { + case .failed(let message): + UnavailableStateView { + Label(String(localized: "History Unavailable"), systemImage: "clock.arrow.circlepath") + } description: { + Text(message) + } actions: { + Button(String(localized: "Try Again")) { viewModel.reload() } + } + case .loading where viewModel.page.entries.isEmpty: + ProgressView() + .frame(maxWidth: .infinity, maxHeight: .infinity) + default: + AutosavingSplitView( + autosaveName: "com.TablePro.versionHistory.listDetail", + primaryMinimum: 220, + secondaryMinimum: 360, + primaryThicknessFraction: 0.3, + primaryAutomaticMaximum: 360 + ) { + VersionHistoryListPane(viewModel: viewModel) + } secondary: { + VersionHistoryDetailPane( + viewModel: viewModel, + databaseType: databaseType, + exportFileName: exportFileName, + onOpenInEditor: onOpenInEditor + ) + } + } + } +} diff --git a/TableProTests/Core/Git/GitIntegrationTests.swift b/TableProTests/Core/Git/GitIntegrationTests.swift new file mode 100644 index 0000000000..050db63c03 --- /dev/null +++ b/TableProTests/Core/Git/GitIntegrationTests.swift @@ -0,0 +1,268 @@ +// +// GitIntegrationTests.swift +// TableProTests +// + +import Foundation +import Testing + +@testable import TablePro + +private struct ScratchRepository { + let root: URL + let client: GitClient + + init(client: GitClient) throws { + self.client = client + root = FileManager.default.temporaryDirectory + .appendingPathComponent("tablepro-git-tests") + .appendingPathComponent(UUID().uuidString) + .resolvingSymlinksInPath() + try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) + } + + func remove() { + try? FileManager.default.removeItem(at: root) + } + + func url(_ relativePath: String) -> URL { + root.appendingPathComponent(relativePath) + } + + func write(_ text: String, to relativePath: String) throws { + let url = url(relativePath) + try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true) + try Data(text.utf8).write(to: url) + } + + func read(_ relativePath: String) throws -> String { + try String(contentsOf: url(relativePath), encoding: .utf8) + } + + @discardableResult + func git(_ arguments: String...) async throws -> GitProcessResult { + let identity = [ + "-c", "user.name=Ann Author", "-c", "user.email=ann@example.com", + "-c", "commit.gpgsign=false", "-c", "init.defaultBranch=main", + ] + let result = try await client.runner.run(GitCommand(arguments: identity + arguments, workingDirectory: root)) + guard result.succeeded else { throw GitCommandFailure(exitCode: result.exitCode, message: result.errorMessage) } + return result + } + + func indexIdentity() throws -> [FileAttributeKey: Any] { + let attributes = try FileManager.default.attributesOfItem(atPath: url(".git/index").path) + return [ + .systemFileNumber: attributes[.systemFileNumber] ?? 0, + .modificationDate: attributes[.modificationDate] ?? Date.distantPast, + ] + } +} + +@Suite("Git against a real repository", .enabled(if: GitClient.make() != nil), .serialized) +struct GitIntegrationTests { + private let client: GitClient + + init() throws { + client = try #require(GitClient.make()) + } + + @Test("Status from a linked subfolder maps paths into the folder and never writes the index") + func statusFromSubfolder() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("SELECT 1;\n", to: "sql queries/a b.sql") + try repo.write("SELECT 2;\n", to: "sql queries/clean.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "first") + try repo.write("SELECT 10;\n", to: "sql queries/a b.sql") + try repo.write("new\n", to: "sql queries/日本.sql") + try repo.write("elsewhere\n", to: "other/x.sql") + try await Task.sleep(for: .milliseconds(1_100)) + let before = try repo.indexIdentity() + + let folder = repo.url("sql queries") + let info = try #require(try await client.repositoryInfo(in: folder)) + let records = try await client.status(in: folder) + let statuses = LinkedFolderGitStatusStore.folderRelativeStatuses(records, prefix: info.prefix) + + let tracked = LinkedFolderGitStatusStore.folderRelativePaths( + try await client.trackedFiles(in: folder), + prefix: info.prefix + ) + #expect(tracked == ["a b.sql", "clean.sql"]) + #expect(info.prefix == "sql queries/") + #expect(statuses["a b.sql"]?.canDiscardChanges == true) + #expect(statuses["日本.sql"]?.isUntracked == true) + #expect(statuses["clean.sql"] == nil) + #expect(statuses.count == 2) + let after = try repo.indexIdentity() + #expect(before[.systemFileNumber] as? Int == after[.systemFileNumber] as? Int) + #expect(before[.modificationDate] as? Date == after[.modificationDate] as? Date) + } + + @Test("A folder outside any repository is not one") + func notARepository() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try repo.write("SELECT 1;\n", to: "q.sql") + + #expect(try await client.repositoryInfo(in: repo.root) == nil) + await #expect(throws: VersionHistoryError.notInRepository) { + try await LinkedFileVersionHistoryProvider(fileURL: repo.url("q.sql")).loadHistory() + } + } + + @Test("History follows a rename, reads each version, and restores one into the current file") + func historyAcrossRename() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("v1\n", to: "q/old name.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "add") + try repo.write("v2\n", to: "q/old name.sql") + try await repo.git("commit", "-qam", "second") + try await repo.git("mv", "q/old name.sql", "q/new name.sql") + try await repo.git("commit", "-qm", "rename") + try repo.write("v3\n", to: "q/new name.sql") + try await repo.git("commit", "-qam", "third") + try repo.write("working\n", to: "q/new name.sql") + + let provider = LinkedFileVersionHistoryProvider(fileURL: repo.url("q/new name.sql")) + let page = try await provider.loadHistory() + + #expect(page.entries.first?.isCurrent == true) + #expect(page.entries.first?.hasUncommittedChanges == true) + #expect(page.entries.dropFirst().compactMap(\.summary) == ["third", "rename", "second", "add"]) + #expect(page.notice == nil) + let oldest = try #require(page.entries.last) + #expect(try await provider.content(of: oldest.reference) == "v1\n") + #expect(try await provider.content(of: .current) == "working\n") + + let plan = try await provider.prepareRestore(oldest.reference) + #expect(plan.replacesUncommittedChanges) + try await plan.apply() + + #expect(try repo.read("q/new name.sql") == "v1\n") + #expect(FileManager.default.fileExists(atPath: repo.url("q/old name.sql").path) == false) + } + + @Test("Discard puts back the staged text, keeps the stage, and leaves an unstaged-only file at its commit") + func discardKeepsStagedChanges() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("committed\n", to: "staged.sql") + try repo.write("committed\n", to: "plain.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "first") + try repo.write("staged\n", to: "staged.sql") + try await repo.git("add", "staged.sql") + try repo.write("unstaged\n", to: "staged.sql") + try repo.write("unstaged\n", to: "plain.sql") + + try await LinkedFileVersionHistoryProvider(fileURL: repo.url("staged.sql")).prepareDiscard().apply() + try await LinkedFileVersionHistoryProvider(fileURL: repo.url("plain.sql")).prepareDiscard().apply() + + #expect(try repo.read("staged.sql") == "staged\n") + #expect(try repo.read("plain.sql") == "committed\n") + let records = try await client.status(in: repo.root) + let staged = try #require(records.first { $0.path == "staged.sql" }) + #expect(staged.status == GitFileStatus(staged: .modified, unstaged: .unmodified)) + #expect(records.contains { $0.path == "plain.sql" } == false) + } + + @Test("A repository with no commits shows only the current version") + func unbornRepository() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("SELECT 1;\n", to: "q.sql") + + let page = try await LinkedFileVersionHistoryProvider(fileURL: repo.url("q.sql")).loadHistory() + + #expect(page.entries.count == 1) + #expect(page.entries.first?.isCurrent == true) + #expect(page.entries.first?.hasUncommittedChanges == true) + } + + @Test("A deleted file reports that it is gone") + func missingFile() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + + await #expect(throws: VersionHistoryError.subjectNotFound) { + try await LinkedFileVersionHistoryProvider(fileURL: repo.url("gone.sql")).loadHistory() + } + } + + @Test("A write that finds the file changed since it was prepared replaces nothing") + func restoreRefusesAFileThatChanged() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("v1\n", to: "q.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "first") + try repo.write("v2\n", to: "q.sql") + try await repo.git("commit", "-qam", "second") + let provider = LinkedFileVersionHistoryProvider(fileURL: repo.url("q.sql")) + let first = try #require(try await provider.loadHistory().entries.last) + + let plan = try await provider.prepareRestore(first.reference) + #expect(!plan.replacesUncommittedChanges) + try repo.write("edited meanwhile\n", to: "q.sql") + + await #expect(throws: VersionHistoryError.fileChangedBeforeWriting) { try await plan.apply() } + #expect(try repo.read("q.sql") == "edited meanwhile\n") + } + + @Test("A file git is told to ignore changes to still counts as changed when its bytes differ") + func assumeUnchangedStillAsks() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("v1\n", to: "q.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "first") + try await repo.git("update-index", "--assume-unchanged", "q.sql") + try repo.write("local edit\n", to: "q.sql") + let provider = LinkedFileVersionHistoryProvider(fileURL: repo.url("q.sql")) + let first = try #require(try await provider.loadHistory().entries.last) + + let plan = try await provider.prepareRestore(first.reference) + + #expect(plan.replacesUncommittedChanges) + } + + @Test("A Git LFS pointer is never written over the file") + func largeFileStoragePointerIsRefused() { + let pointer = Data("version https://git-lfs.github.com/spec/v1\noid sha256:abc\nsize 12\n".utf8) + #expect(throws: VersionHistoryError.storedInLargeFileStorage) { + try LinkedFileVersionHistoryProvider.rejectLargeFileStoragePointer(pointer) + } + #expect(throws: Never.self) { + try LinkedFileVersionHistoryProvider.rejectLargeFileStoragePointer(Data("SELECT 1;\n".utf8)) + } + } + + @Test("Discard writes nothing when the staged version changed after it was prepared") + func discardRefusesAChangedIndex() async throws { + let repo = try ScratchRepository(client: client) + defer { repo.remove() } + try await repo.git("init", "-q") + try repo.write("committed\n", to: "q.sql") + try await repo.git("add", "-A") + try await repo.git("commit", "-qm", "first") + try repo.write("edited\n", to: "q.sql") + let plan = try await LinkedFileVersionHistoryProvider(fileURL: repo.url("q.sql")).prepareDiscard() + + try await repo.git("add", "q.sql") + + await #expect(throws: VersionHistoryError.fileChangedBeforeWriting) { try await plan.apply() } + #expect(try repo.read("q.sql") == "edited\n") + } +} diff --git a/TableProTests/Core/Git/GitOutputParserTests.swift b/TableProTests/Core/Git/GitOutputParserTests.swift new file mode 100644 index 0000000000..88a06f4bce --- /dev/null +++ b/TableProTests/Core/Git/GitOutputParserTests.swift @@ -0,0 +1,302 @@ +// +// GitOutputParserTests.swift +// TableProTests +// + +import Foundation +import Testing + +@testable import TablePro + +@Suite("Git output parsers") +struct GitOutputParserTests { + private func bytes(_ string: String) -> Data { + Data(string.utf8) + } + + @Test("Porcelain v2 records keep spaces and non-ASCII in paths, and a rename carries its original path") + func statusRecords() { + let output = bytes( + "1 .M N... 100644 100644 100644 aaaa bbbb sql queries/a b.sql\0" + + "1 MM N... 100644 100644 100644 aaaa bbbb sql queries/staged.sql\0" + + "1 A. N... 000000 100644 100644 0000 bbbb sql queries/added.sql\0" + + "2 R. N... 100644 100644 100644 aaaa aaaa R100 sql queries/new name.sql\0sql queries/old name.sql\0" + + "u UU N... 100644 100644 100644 100644 aaaa bbbb cccc sql queries/conflict.sql\0" + + "? sql queries/日本.sql\0" + ) + + let records = GitStatusParser.parse(output) + + #expect(records.map(\.path) == [ + "sql queries/a b.sql", + "sql queries/staged.sql", + "sql queries/added.sql", + "sql queries/new name.sql", + "sql queries/conflict.sql", + "sql queries/日本.sql", + ]) + #expect(records[0].status == GitFileStatus(staged: .unmodified, unstaged: .modified)) + #expect(records[1].status == GitFileStatus(staged: .modified, unstaged: .modified)) + #expect(records[2].status == GitFileStatus(staged: .added, unstaged: .unmodified)) + #expect(records[3].originalPath == "sql queries/old name.sql") + #expect(records[3].status.staged == .renamed) + #expect(records[4].status.isConflicted) + #expect(records[5].status.isUntracked) + } + + @Test("Every unmerged record is a conflict, including add/add where XY has no U") + func addAddConflict() throws { + let output = bytes("u AA N... 000000 100644 100644 100644 0000 6178 7898 q/c.sql\0") + let record = try #require(GitStatusParser.parse(output).first) + #expect(record.status.isConflicted) + #expect(record.status.badge == .conflicted) + #expect(!record.status.canDiscardChanges) + } + + @Test("An empty status is no records") + func emptyStatus() { + #expect(GitStatusParser.parse(Data()).isEmpty) + } + + @Test("A followed log reports each commit with the path the file had at that commit") + func logFollowsRenames() throws { + let output = bytes( + "\u{1E}4e3138764045879d706b709d7f4dd42897109548\u{1F}Ann Author\u{1F}2026-09-23T10:09:04+07:00" + + "\u{1F}subject with \u{1F}? no; tab\there\0\nM\0sub dir/new name.sql\0" + + "\u{1E}1189ca3714ed5cee0a4b5885a64adb10d8bcb830\u{1F}Ann Author\u{1F}2026-09-23T10:09:04+07:00" + + "\u{1F}rename it\0\nR100\0sub dir/old name.sql\0sub dir/new name.sql\0" + + "\u{1E}9362855bae5a38735f19ddcfc763bba0cf5a2df2\u{1F}Ann Author\u{1F}2026-09-23T10:09:03+07:00\u{1F}second\0\nM\0sub dir/old name.sql\0" + + "\u{1E}d5fc769941d0c335980f7be7b6df3a2bcefdd9fd\u{1F}Ann Author\u{1F}2026-09-23T10:09:03+07:00\u{1F}first: add\0\nA\0sub dir/old name.sql\0" + ) + + let commits = GitLogParser.parse(output) + + #expect(commits.map { String($0.hash.prefix(4)) } == ["4e31", "1189", "9362", "d5fc"]) + #expect(commits.map(\.path) == [ + "sub dir/new name.sql", + "sub dir/new name.sql", + "sub dir/old name.sql", + "sub dir/old name.sql", + ]) + #expect(commits[0].subject == "subject with \u{1F}? no; tab\there") + #expect(commits[3].subject == "first: add") + #expect(commits[0].author == "Ann Author") + let date = try #require(commits[0].date) + #expect(date == Date(timeIntervalSince1970: 1_790_132_944)) + } + + @Test("A commit with no file entry keeps its header and leaves the path unknown") + func logCommitWithoutPath() { + let output = bytes("\u{1E}abcd\(String(repeating: "0", count: 36))\u{1F}Ann\u{1F}2026-09-23T10:09:04+07:00\u{1F}merge\0") + let commits = GitLogParser.parse(output) + #expect(commits.count == 1) + #expect(commits[0].path == nil) + } + + @Test("A commit that deleted the file has no version to show and is skipped") + func logSkipsDeletions() { + let deleted = "b".padding(toLength: 40, withPad: "b", startingAt: 0) + let added = "c".padding(toLength: 40, withPad: "c", startingAt: 0) + let output = bytes( + "\u{1E}\(deleted)\u{1F}Ann\u{1F}2026-09-23T10:09:04+07:00\u{1F}drop it\0\nD\0q.sql\0" + + "\u{1E}\(added)\u{1F}Ann\u{1F}2026-09-22T10:09:04+07:00\u{1F}add it\0\nA\0q.sql\0" + ) + #expect(GitLogParser.parse(output).map(\.hash) == [added]) + } + + @Test("A header whose hash is not a commit id is dropped, so it can never reach a cat-file argument") + func logRejectsNonHashHeaders() { + let output = bytes("\u{1E}--batch-check\u{1F}Ann\u{1F}2026-09-23T10:09:04+07:00\u{1F}x\0\nM\0q.sql\0") + #expect(GitLogParser.parse(output).isEmpty) + #expect(GitLogParser.isCommitHash(Substring(String(repeating: "a", count: 64)))) + #expect(!GitLogParser.isCommitHash("HEAD")) + } + + @Test("rev-parse output maps to the top level, the git directory and the prefix, which is empty at the root") + func repositoryInfo() throws { + let nested = try #require(GitRepositoryInfoParser.parse(bytes("/tmp/repo\n/tmp/repo/.git\nsql queries/\n"))) + #expect(nested.topLevel.path == "/tmp/repo") + #expect(nested.gitDirectory.path == "/tmp/repo/.git") + #expect(nested.prefix == "sql queries/") + + let root = try #require(GitRepositoryInfoParser.parse(bytes("/tmp/repo\n/tmp/repo/.git\n\n"))) + #expect(root.prefix.isEmpty) + + #expect(GitRepositoryInfoParser.parse(Data()) == nil) + } + + @Test("A file with no status is clean only when the index tracks it") + func trackedVersusIgnored() throws { + let snapshot = LinkedFolderGitSnapshot( + repository: try #require(GitRepositoryInfoParser.parse(bytes("/r\n/r/.git\n\n"))), + head: nil, + statuses: ["new.sql": .untracked], + trackedPaths: ["clean.sql"] + ) + #expect(snapshot.state(forRelativePath: "clean.sql") == .clean) + #expect(snapshot.state(forRelativePath: "new.sql") == .changed(.untracked)) + #expect(snapshot.state(forRelativePath: "ignored.sql") == nil) + #expect(LinkedFolderGitStatusStore.folderRelativePaths(["q/a.sql", "other/b.sql"], prefix: "q/") == ["a.sql"]) + } + + @Test("Statuses are keyed by the path inside the linked folder, and files outside it are dropped") + func folderRelativeStatuses() { + let records = [ + GitStatusRecord(path: "sql queries/a.sql", originalPath: nil, status: .untracked), + GitStatusRecord(path: "sql queries/nested/b.sql", originalPath: nil, status: GitFileStatus(staged: .unmodified, unstaged: .modified)), + GitStatusRecord(path: "other/c.sql", originalPath: nil, status: .untracked), + ] + + let statuses = LinkedFolderGitStatusStore.folderRelativeStatuses(records, prefix: "sql queries/") + + #expect(Set(statuses.keys) == ["a.sql", "nested/b.sql"]) + #expect(LinkedFolderGitStatusStore.folderRelativeStatuses(records, prefix: "").count == 3) + } +} + +@Suite("GitFileStatus") +struct GitFileStatusTests { + @Test("Badge letters follow the change, with conflict and untracked first") + func badges() { + #expect(GitFileStatus(staged: .unmodified, unstaged: .modified).badge == .modified) + #expect(GitFileStatus(staged: .modified, unstaged: .unmodified).badge == .modified) + #expect(GitFileStatus(staged: .added, unstaged: .modified).badge == .added) + #expect(GitFileStatus(staged: .renamed, unstaged: .unmodified).badge == .renamed) + #expect(GitFileStatus(staged: .unmerged, unstaged: .unmerged).badge == .conflicted) + #expect(GitFileStatus.untracked.badge == .untracked) + #expect(GitFileStatus.untracked.badge.letter == "U") + } + + @Test("Discard is offered only when the working copy differs from the index") + func discardGating() { + #expect(GitFileStatus(staged: .unmodified, unstaged: .modified).canDiscardChanges) + #expect(GitFileStatus(staged: .modified, unstaged: .modified).canDiscardChanges) + #expect(GitFileStatus(staged: .added, unstaged: .modified).canDiscardChanges) + #expect(!GitFileStatus(staged: .modified, unstaged: .unmodified).canDiscardChanges) + #expect(!GitFileStatus(staged: .added, unstaged: .unmodified).canDiscardChanges) + #expect(!GitFileStatus.untracked.canDiscardChanges) + #expect(!GitFileStatus(staged: .unmerged, unstaged: .unmerged).canDiscardChanges) + } + + @Test("History is offered only for a file that exists in a commit under this name") + func committedHistory() { + #expect(GitFileStatus(staged: .unmodified, unstaged: .modified).hasCommittedHistory) + #expect(GitFileStatus(staged: .modified, unstaged: .unmodified).hasCommittedHistory) + #expect(!GitFileStatus(staged: .added, unstaged: .unmodified).hasCommittedHistory) + #expect(!GitFileStatus(staged: .renamed, unstaged: .unmodified).hasCommittedHistory) + #expect(!GitFileStatus.untracked.hasCommittedHistory) + #expect(LinkedFileGitState.clean.hasCommittedHistory) + #expect(!LinkedFileGitState.clean.canDiscardChanges) + } + + @Test("The spoken status says whether the change is staged") + func accessibilityDescription() { + #expect(GitFileStatus(staged: .modified, unstaged: .unmodified).accessibilityDescription + == String(format: String(localized: "%@, staged"), GitFileStatus.Badge.modified.label)) + #expect(GitFileStatus(staged: .modified, unstaged: .modified).accessibilityDescription + == String(format: String(localized: "%@, partly staged"), GitFileStatus.Badge.modified.label)) + #expect(GitFileStatus(staged: .unmodified, unstaged: .modified).accessibilityDescription + == GitFileStatus.Badge.modified.label) + } +} + +@Suite("Git executable and command hardening") +struct GitCommandHardeningTests { + @Test("The locator never offers the installer shim, and reads the developer directory without running anything") + func locatorSkipsShim() { + let locator = GitExecutableLocator( + isExecutable: { _ in true }, + developerDirectory: { "/Applications/Xcode.app/Contents/Developer" } + ) + let candidates = locator.candidates() + #expect(!candidates.contains("/usr/bin/git")) + #expect(candidates.contains("/Applications/Xcode.app/Contents/Developer/usr/bin/git")) + #expect(locator.locate()?.path == "/opt/homebrew/bin/git") + } + + @Test("A developer directory at the volume root cannot smuggle the shim back in") + func locatorRejectsShimViaDeveloperDirectory() { + let locator = GitExecutableLocator(isExecutable: { _ in true }, developerDirectory: { "/" }) + #expect(!locator.candidates().contains("/usr/bin/git")) + } + + @Test("No git installed means no git, not the shim") + func locatorWithoutGit() { + let locator = GitExecutableLocator(isExecutable: { $0 == "/usr/bin/git" }, developerDirectory: { nil }) + #expect(locator.locate() == nil) + } + + @Test("Every command carries the flags that stop a repository from running its own programs or taking locks") + func everyCommandIsHardened() { + let file = URL(fileURLWithPath: "/tmp/repo/a.sql") + let directory = file.deletingLastPathComponent() + let commands: [GitCommand] = [ + .repositoryInfo(in: directory), + .verifyHead(in: directory), + .status(in: directory), + .fileHistory(of: file, limit: 10), + .blob(revision: "HEAD", path: "a.sql", in: directory), + .trackedFiles(in: directory), + ] + for command in commands { + let arguments = command.processArguments + #expect(arguments.starts(with: GitCommand.hardeningArguments)) + #expect(arguments.contains("core.fsmonitor=false")) + #expect(arguments.contains("core.hooksPath=/dev/null")) + #expect(arguments.contains("--no-optional-locks")) + #expect(arguments.contains("--literal-pathspecs")) + #expect(!arguments.contains("--filters")) + #expect(!arguments.contains("checkout-index")) + } + #expect(GitCommand.blob(revision: "HEAD", path: "a.sql", in: directory).arguments.contains("--end-of-options")) + } + + @Test("A file history never asks git to verify signatures or colour its output") + func historyArguments() { + let command = GitCommand.fileHistory(of: URL(fileURLWithPath: "/tmp/repo/sub dir/a b.sql"), limit: 201) + #expect(command.arguments.contains("--follow")) + #expect(command.arguments.contains("--no-show-signature")) + #expect(command.arguments.contains("--no-color")) + #expect(command.arguments.contains("--max-count=201")) + #expect(command.arguments.last == "a b.sql") + #expect(command.workingDirectory.path == "/tmp/repo/sub dir") + } + + @Test("Inherited repository variables are dropped and the lock and prompt overrides win") + func environment() { + let environment = GitCommand.environment(base: [ + "GIT_DIR": "/elsewhere/.git", + "GIT_WORK_TREE": "/elsewhere", + "GIT_OPTIONAL_LOCKS": "1", + "PATH": "/usr/bin", + ]) + #expect(environment["GIT_DIR"] == nil) + #expect(environment["GIT_WORK_TREE"] == nil) + #expect(environment["GIT_OPTIONAL_LOCKS"] == "0") + #expect(environment["GIT_TERMINAL_PROMPT"] == "0") + #expect(environment["PATH"] == "/usr/bin") + } + + @Test("Folder watcher events inside .git do not count as SQL file changes") + func repositoryMetadataEvents() { + #expect(SQLFolderWatcher.touchesOnlyRepositoryMetadata(["/repo/.git/index", "/repo/.git/refs/heads/main"])) + #expect(!SQLFolderWatcher.touchesOnlyRepositoryMetadata(["/repo/.git/index", "/repo/queries/a.sql"])) + #expect(!SQLFolderWatcher.touchesOnlyRepositoryMetadata(["/repo/.gitignore"])) + #expect(!SQLFolderWatcher.touchesOnlyRepositoryMetadata([])) + } +} + +@Suite("FileTextLoader.decode") +struct FileTextLoaderDecodeTests { + @Test("Byte order marks pick the encoding, UTF-32 before the UTF-16 prefix it shares") + func byteOrderMarks() throws { + let text = "SELECT 'é';" + let utf32 = try #require(text.data(using: .utf32LittleEndian)) + let utf16 = try #require(text.data(using: .utf16LittleEndian)) + #expect(FileTextLoader.decode(Data([0xFF, 0xFE, 0x00, 0x00]) + utf32) == text) + #expect(FileTextLoader.decode(Data([0xFF, 0xFE]) + utf16) == text) + #expect(FileTextLoader.decode(Data([0xEF, 0xBB, 0xBF]) + Data(text.utf8)) == text) + #expect(FileTextLoader.decode(Data(text.utf8)) == text) + #expect(FileTextLoader.decode(Data([0x53, 0xE9])) == "Sé") + } +} diff --git a/TableProTests/Core/Scripting/ScriptingDictionaryTests.swift b/TableProTests/Core/Scripting/ScriptingDictionaryTests.swift index 288fd5303d..11e2caa11d 100644 --- a/TableProTests/Core/Scripting/ScriptingDictionaryTests.swift +++ b/TableProTests/Core/Scripting/ScriptingDictionaryTests.swift @@ -328,7 +328,7 @@ struct ScriptingDictionaryTests { } for kind in [ TabType.query, .table, .createTable, .erDiagram, - .serverDashboard, .usersRoles, .insights, .objectSource + .serverDashboard, .usersRoles, .insights, .objectSource, .versionHistory ] { #expect(declared.contains(ScriptEnumerations.code(for: kind)), "no enumerator for \(kind)") } diff --git a/TableProTests/Core/Services/PersistedTabRoundTripTests.swift b/TableProTests/Core/Services/PersistedTabRoundTripTests.swift index 40049b9539..ebed65762d 100644 --- a/TableProTests/Core/Services/PersistedTabRoundTripTests.swift +++ b/TableProTests/Core/Services/PersistedTabRoundTripTests.swift @@ -537,4 +537,34 @@ struct PersistedTabRoundTripTests { #expect(!json.contains("CREATE")) #expect(json.contains("orders")) } + + @Test("A history tab round-trips the saved query or file it shows") + func versionHistoryTabRoundTripsItsSubject() throws { + let favoriteId = UUID() + let subjects: [VersionHistorySubject] = [ + .savedQuery(id: favoriteId), + .linkedFile(url: URL(fileURLWithPath: "/Users/me/queries/sub dir/orders.sql")), + ] + for subject in subjects { + let tab = PersistedTab( + id: UUID(), + title: "History: orders.sql", + query: "", + tabType: .versionHistory, + tableName: nil, + versionHistorySubject: subject + ) + let decoded = try JSONDecoder().decode(PersistedTab.self, from: try JSONEncoder().encode(tab)) + #expect(decoded.tabType == .versionHistory) + #expect(decoded.versionHistorySubject == subject) + #expect(decoded.title == "History: orders.sql") + } + } + + @Test("A tab written before history tabs existed decodes with no subject") + func olderTabHasNoHistorySubject() throws { + let json = #"{"id":"\#(UUID().uuidString)","title":"Query 1","query":"SELECT 1","tabType":{"query":{}}}"# + let decoded = try JSONDecoder().decode(PersistedTab.self, from: Data(json.utf8)) + #expect(decoded.versionHistorySubject == nil) + } } diff --git a/TableProTests/Core/Storage/SQLFavoriteVersionTests.swift b/TableProTests/Core/Storage/SQLFavoriteVersionTests.swift new file mode 100644 index 0000000000..da4b87c6fb --- /dev/null +++ b/TableProTests/Core/Storage/SQLFavoriteVersionTests.swift @@ -0,0 +1,226 @@ +// +// SQLFavoriteVersionTests.swift +// TableProTests +// + +import Foundation +import SQLite3 +import TableProSyncTransport +import Testing + +@testable import TablePro + +@Suite("SQLFavorite versions") +struct SQLFavoriteVersionTests { + private let storage: SQLFavoriteStorage + private let defaults: UserDefaults + private let tracker: SyncChangeTracker + + init() throws { + let url = FileManager.default.temporaryDirectory + .appendingPathComponent("tablepro-tests") + .appendingPathComponent("sql_favorites_versions_\(UUID().uuidString).db") + try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true) + storage = SQLFavoriteStorage(databaseURL: url, removeDatabaseOnDeinit: true) + defaults = try #require(UserDefaults(suiteName: "com.TablePro.tests.SQLFavoriteVersions.\(UUID().uuidString)")) + tracker = SyncChangeTracker(metadataStorage: SyncMetadataStorage(userDefaults: defaults)) + } + + private func makeFavorite(name: String = "Revenue", query: String = "SELECT 1", updatedAt: Date = Date(timeIntervalSince1970: 100)) -> SQLFavorite { + SQLFavorite(name: name, query: query, createdAt: updatedAt, updatedAt: updatedAt) + } + + @Test("Changing the query records the text it replaced, with the time that text was saved") + func changingQueryRecordsPreviousText() async throws { + var favorite = makeFavorite(query: "SELECT 1") + #expect(await storage.addFavorite(favorite)) + + favorite.query = "SELECT 2" + favorite.updatedAt = Date(timeIntervalSince1970: 200) + #expect(await storage.updateFavorite(favorite).succeeded) + + let versions = await storage.fetchVersions(favoriteId: favorite.id) + let version = try #require(versions.first) + #expect(versions.count == 1) + #expect(version.query == "SELECT 1") + #expect(version.name == "Revenue") + #expect(version.savedAt == Date(timeIntervalSince1970: 100)) + } + + @Test("A write that leaves the query text alone records nothing") + func unchangedQueryRecordsNothing() async { + var favorite = makeFavorite() + #expect(await storage.addFavorite(favorite)) + + favorite.name = "Renamed" + favorite.keyword = "rev" + favorite.updatedAt = Date(timeIntervalSince1970: 300) + #expect(await storage.updateFavorite(favorite).succeeded) + + #expect(await storage.fetchVersions(favoriteId: favorite.id).isEmpty) + } + + @Test("A sync upsert that changes the text records the local text it replaced") + func syncUpsertRecordsPreviousText() async { + var favorite = makeFavorite(query: "SELECT local") + #expect(await storage.addFavorite(favorite)) + + favorite.query = "SELECT remote" + #expect(await storage.upsertFavorite(favorite).succeeded) + #expect(await storage.upsertFavorite(favorite).succeeded) + + let versions = await storage.fetchVersions(favoriteId: favorite.id) + #expect(versions.map(\.query) == ["SELECT local"]) + } + + @Test("Each query keeps only its most recent versions, newest first, without touching other queries") + func pruningIsPerFavorite() async { + var favorite = makeFavorite(query: "SELECT 0") + let other = makeFavorite(name: "Other", query: "SELECT other") + #expect(await storage.addFavorite(favorite)) + #expect(await storage.addFavorite(other)) + + var otherEdit = other + otherEdit.query = "SELECT other 2" + #expect(await storage.updateFavorite(otherEdit).succeeded) + + let limit = SQLFavoriteStorage.retainedVersionCount + for index in 1...(limit + 5) { + favorite.query = "SELECT \(index)" + #expect(await storage.updateFavorite(favorite).succeeded) + } + + let versions = await storage.fetchVersions(favoriteId: favorite.id) + #expect(versions.count == limit) + #expect(versions.first?.query == "SELECT \(limit + 4)") + #expect(versions.last?.query == "SELECT 5") + #expect(await storage.fetchVersions(favoriteId: other.id).map(\.query) == ["SELECT other"]) + } + + @Test("Deleting a query deletes its versions") + func deletingFavoriteDeletesVersions() async { + var favorite = makeFavorite() + #expect(await storage.addFavorite(favorite)) + favorite.query = "SELECT 2" + #expect(await storage.updateFavorite(favorite).succeeded) + #expect(await storage.fetchVersions(favoriteId: favorite.id).count == 1) + + #expect(await storage.deleteFavorite(id: favorite.id)) + + #expect(await storage.fetchVersions(favoriteId: favorite.id).isEmpty) + } + + @Test("Restoring writes the old text, records the text it replaced, and marks the query for sync") + func restoreRecordsReplacedTextAndMarksDirty() async throws { + let manager = SQLFavoriteManager(storage: storage, syncTracker: tracker) + var favorite = makeFavorite(query: "SELECT old") + #expect(await storage.addFavorite(favorite)) + favorite.query = "SELECT new" + #expect(await storage.updateFavorite(favorite).succeeded) + let old = try #require(await manager.fetchVersions(favoriteId: favorite.id).first) + + #expect(await manager.restore(old)) + + let restored = try #require(await manager.fetchFavorite(id: favorite.id)) + #expect(restored.query == "SELECT old") + #expect(restored.name == "Revenue") + #expect(await manager.fetchVersions(favoriteId: favorite.id).map(\.query) == ["SELECT new", "SELECT old"]) + #expect(tracker.dirtyRecords(for: .favorite).contains(favorite.id.uuidString)) + } + + @Test("Restoring a version of a deleted query fails") + func restoreOfDeletedFavoriteFails() async throws { + let manager = SQLFavoriteManager(storage: storage, syncTracker: tracker) + var favorite = makeFavorite(query: "SELECT old") + #expect(await storage.addFavorite(favorite)) + favorite.query = "SELECT new" + #expect(await storage.updateFavorite(favorite).succeeded) + let old = try #require(await manager.fetchVersions(favoriteId: favorite.id).first) + #expect(await storage.deleteFavorite(id: favorite.id)) + + #expect(await manager.restore(old) == false) + } + + @Test("Reopening the database keeps the versions and does not duplicate the triggers") + func reopeningKeepsVersions() async throws { + let url = FileManager.default.temporaryDirectory + .appendingPathComponent("tablepro-tests") + .appendingPathComponent("sql_favorites_reopen_\(UUID().uuidString).db") + defer { + for suffix in ["", "-wal", "-shm"] { + try? FileManager.default.removeItem(atPath: url.path + suffix) + } + } + var favorite = makeFavorite(query: "SELECT 1") + do { + let first = SQLFavoriteStorage(databaseURL: url) + #expect(await first.addFavorite(favorite)) + favorite.query = "SELECT 2" + #expect(await first.updateFavorite(favorite).succeeded) + } + + let reopened = SQLFavoriteStorage(databaseURL: url) + favorite.query = "SELECT 3" + #expect(await reopened.updateFavorite(favorite).succeeded) + + #expect(await reopened.fetchVersions(favoriteId: favorite.id).map(\.query) == ["SELECT 2", "SELECT 1"]) + } + + @Test("A database upgraded from the first schema records versions on its first launch") + func upgradeFromFirstSchemaKeepsVersionTriggers() async throws { + let url = FileManager.default.temporaryDirectory + .appendingPathComponent("tablepro-tests") + .appendingPathComponent("sql_favorites_v1_\(UUID().uuidString).db") + defer { + for suffix in ["", "-wal", "-shm"] { + try? FileManager.default.removeItem(atPath: url.path + suffix) + } + } + let id = UUID() + var handle: OpaquePointer? + #expect(sqlite3_open(url.path, &handle) == SQLITE_OK) + let seed = """ + CREATE TABLE favorites (id TEXT PRIMARY KEY, name TEXT NOT NULL, query TEXT NOT NULL, keyword TEXT, + folder_id TEXT, connection_id TEXT, sort_order INTEGER NOT NULL DEFAULT 0, + created_at REAL NOT NULL, updated_at REAL NOT NULL); + CREATE TABLE folders (id TEXT PRIMARY KEY, name TEXT NOT NULL, parent_id TEXT, connection_id TEXT, + sort_order INTEGER NOT NULL DEFAULT 0, created_at REAL NOT NULL, updated_at REAL NOT NULL); + INSERT INTO favorites VALUES ('\(id.uuidString)', 'Revenue', 'SELECT 1', NULL, NULL, NULL, 0, 1, 1); + PRAGMA user_version = 1; + """ + #expect(sqlite3_exec(handle, seed, nil, nil, nil) == SQLITE_OK) + sqlite3_close(handle) + + let upgraded = SQLFavoriteStorage(databaseURL: url) + var favorite = try #require(await upgraded.fetchFavorite(id: id)) + favorite.name = "Renamed" + favorite.updatedAt = Date(timeIntervalSince1970: 5) + #expect(await upgraded.updateFavorite(favorite).succeeded) + favorite.query = "SELECT 2" + favorite.updatedAt = Date(timeIntervalSince1970: 9) + #expect(await upgraded.updateFavorite(favorite).succeeded) + + let version = try #require(await upgraded.fetchVersions(favoriteId: id).first) + #expect(version.query == "SELECT 1") + #expect(version.savedAt == Date(timeIntervalSince1970: 1)) + } + + @Test("A rename or keyword change does not move the saved time of the SQL it did not touch") + func metadataEditsKeepTheQuerySaveTime() async throws { + var favorite = makeFavorite(query: "SELECT 1", updatedAt: Date(timeIntervalSince1970: 100)) + #expect(await storage.addFavorite(favorite)) + + favorite.name = "Renamed" + favorite.updatedAt = Date(timeIntervalSince1970: 200) + #expect(await storage.updateFavorite(favorite).succeeded) + #expect(await storage.querySavedAt(favoriteId: favorite.id) == Date(timeIntervalSince1970: 100)) + + favorite.query = "SELECT 2" + favorite.updatedAt = Date(timeIntervalSince1970: 300) + #expect(await storage.upsertFavorite(favorite).succeeded) + + let version = try #require(await storage.fetchVersions(favoriteId: favorite.id).first) + #expect(version.savedAt == Date(timeIntervalSince1970: 100)) + #expect(await storage.querySavedAt(favoriteId: favorite.id) == Date(timeIntervalSince1970: 300)) + } +} diff --git a/TableProTests/Services/WindowTitleResolverTests.swift b/TableProTests/Services/WindowTitleResolverTests.swift index 881e0b9cdf..4291d1d39c 100644 --- a/TableProTests/Services/WindowTitleResolverTests.swift +++ b/TableProTests/Services/WindowTitleResolverTests.swift @@ -38,6 +38,28 @@ struct WindowTitleResolverPayloadTitleTests { #expect(title == String(localized: "Create Table")) } + @Test("A history payload takes its tab title, and a blank one falls back to History") + func versionHistoryLabel() { + let named = EditorTabPayload( + connectionId: UUID(), + tabType: .versionHistory, + versionHistorySubject: .savedQuery(id: UUID()), + tabTitle: "History: Revenue" + ) + let blank = EditorTabPayload( + connectionId: UUID(), + tabType: .versionHistory, + versionHistorySubject: .savedQuery(id: UUID()), + tabTitle: " " + ) + #expect(WindowTitleResolver.resolveTitle( + payload: named, databaseType: .postgresql, queryLanguageName: "PostgreSQL" + ) == "History: Revenue") + #expect(WindowTitleResolver.resolveTitle( + payload: blank, databaseType: .postgresql, queryLanguageName: "PostgreSQL" + ) == String(localized: "History")) + } + @Test("Explicit tabTitle wins for query payloads") func explicitTabTitleWins() { let payload = EditorTabPayload( diff --git a/TableProTests/ViewModels/VersionHistoryViewModelTests.swift b/TableProTests/ViewModels/VersionHistoryViewModelTests.swift new file mode 100644 index 0000000000..186774bb11 --- /dev/null +++ b/TableProTests/ViewModels/VersionHistoryViewModelTests.swift @@ -0,0 +1,280 @@ +// +// VersionHistoryViewModelTests.swift +// TableProTests +// + +import Combine +import Foundation +import Testing + +@testable import TablePro + +private actor FakeVersionHistoryProvider: VersionHistoryProvider { + var page: VersionHistoryPage + var contents: [VersionHistoryReference: String] + var loadError: VersionHistoryError? + var isDirtyOnDisk: Bool + private(set) var contentRequests: [VersionHistoryReference] = [] + private(set) var restored: [VersionHistoryReference] = [] + + init(page: VersionHistoryPage, contents: [VersionHistoryReference: String]) { + self.page = page + self.contents = contents + isDirtyOnDisk = page.current?.hasUncommittedChanges ?? false + } + + func setDirtyOnDisk(_ isDirty: Bool) { + isDirtyOnDisk = isDirty + } + + func prepareRestore(_ reference: VersionHistoryReference) async throws -> VersionRestorePlan { + let isDirty = isDirtyOnDisk + return VersionRestorePlan(replacesUncommittedChanges: isDirty) { [self] in + await self.recordRestore(reference) + } + } + + private func recordRestore(_ reference: VersionHistoryReference) { + restored.append(reference) + if let text = contents[reference] { + contents[.current] = text + } + } + + func setLoadError(_ error: VersionHistoryError?) { + loadError = error + } + + func setCurrent(_ text: String) { + contents[.current] = text + } + + func loadHistory() async throws -> VersionHistoryPage { + if let loadError { throw loadError } + return page + } + + func content(of reference: VersionHistoryReference) async throws -> String { + contentRequests.append(reference) + guard let content = contents[reference] else { throw VersionHistoryError.versionNotFound } + return content + } +} + +@MainActor +@Suite("VersionHistoryViewModel") +struct VersionHistoryViewModelTests { + private static let past = VersionHistoryReference.savedQueryVersion(id: 7) + private static let older = VersionHistoryReference.savedQueryVersion(id: 3) + + private func makeProvider(uncommitted: Bool = false) -> FakeVersionHistoryProvider { + FakeVersionHistoryProvider( + page: VersionHistoryPage(entries: [ + VersionHistoryEntry(reference: .current, date: Date(timeIntervalSince1970: 300), hasUncommittedChanges: uncommitted), + VersionHistoryEntry(reference: Self.past, date: Date(timeIntervalSince1970: 200)), + VersionHistoryEntry(reference: Self.older, date: Date(timeIntervalSince1970: 100)), + ]), + contents: [ + .current: "SELECT 3\n", + Self.past: "SELECT 2\n", + Self.older: "SELECT 3\n", + ] + ) + } + + private func makeViewModel(_ provider: FakeVersionHistoryProvider) -> VersionHistoryViewModel { + VersionHistoryViewModel( + subject: .savedQuery(id: UUID()), + provider: provider, + refreshSignal: Empty().eraseToAnyPublisher() + ) + } + + private func loadedDetail(_ viewModel: VersionHistoryViewModel) async throws -> VersionHistoryDetail { + await viewModel.detailTask?.value + guard case .loaded(let detail) = viewModel.detailState else { + Issue.record("Detail did not load: \(viewModel.detailState)") + throw VersionHistoryError.versionNotFound + } + return detail + } + + @Test("Loading selects the current version and compares it with the version before it") + func currentComparesWithPrevious() async throws { + let viewModel = makeViewModel(makeProvider()) + + await viewModel.loadList() + let detail = try await loadedDetail(viewModel) + + #expect(viewModel.listState == .loaded) + #expect(viewModel.selection == .current) + #expect(detail.content == "SELECT 3\n") + let comparison = try #require(detail.comparison) + #expect(comparison.older.reference == Self.past) + #expect(comparison.newer.reference == .current) + guard case .differs(let pairs) = comparison.outcome else { + Issue.record("Expected a difference") + return + } + #expect(pairs.contains { $0.before == "SELECT 2" && $0.after == "SELECT 3" }) + } + + @Test("A past version is compared with the current one, older side first") + func pastComparesWithCurrent() async throws { + let viewModel = makeViewModel(makeProvider()) + await viewModel.loadList() + await viewModel.detailTask?.value + + viewModel.selection = Self.older + let detail = try await loadedDetail(viewModel) + + #expect(detail.content == "SELECT 3\n") + let comparison = try #require(detail.comparison) + #expect(comparison.older.reference == Self.older) + #expect(comparison.newer.reference == .current) + #expect(comparison.outcome == .identical) + } + + @Test("A past version is read once, the current text every time") + func onlyPastContentIsCached() async throws { + let provider = makeProvider() + let viewModel = makeViewModel(provider) + await viewModel.loadList() + await viewModel.detailTask?.value + await provider.setCurrent("SELECT 4\n") + + await viewModel.loadList() + let detail = try await loadedDetail(viewModel) + + #expect(detail.content == "SELECT 4\n") + let requests = await provider.contentRequests + #expect(requests.filter { $0 == .current }.count == 2) + #expect(requests.filter { $0 == Self.past }.count == 1) + } + + @Test("Restoring with nothing unsaved needs no confirmation and selects the current version") + func restoreWithoutUncommittedChanges() async throws { + let provider = makeProvider() + let viewModel = makeViewModel(provider) + var asked = false + var restoredCalls = 0 + viewModel.confirmReplacingUncommittedChanges = { + asked = true + return true + } + viewModel.onRestored = { restoredCalls += 1 } + await viewModel.loadList() + viewModel.selection = Self.past + + await viewModel.restore(try #require(viewModel.selectedEntry)) + + #expect(!asked) + #expect(restoredCalls == 1) + #expect(await provider.restored == [Self.past]) + #expect(viewModel.selection == .current) + #expect(!viewModel.isRestoring) + } + + @Test("Restoring over uncommitted changes asks first, and a refusal changes nothing") + func restoreOverUncommittedChangesAsks() async throws { + let provider = makeProvider(uncommitted: true) + let viewModel = makeViewModel(provider) + viewModel.confirmReplacingUncommittedChanges = { false } + await viewModel.loadList() + let entry = try #require(viewModel.page.entries.first { $0.reference == Self.past }) + + await viewModel.restore(entry) + #expect(await provider.restored.isEmpty) + + viewModel.confirmReplacingUncommittedChanges = { true } + await viewModel.restore(entry) + #expect(await provider.restored == [Self.past]) + } + + @Test("A change made after the list loaded still asks before it is replaced") + func restoreRechecksAtTheMomentOfWriting() async throws { + let provider = makeProvider(uncommitted: false) + let viewModel = makeViewModel(provider) + var asked = false + viewModel.confirmReplacingUncommittedChanges = { + asked = true + return false + } + await viewModel.loadList() + await provider.setDirtyOnDisk(true) + + await viewModel.restore(try #require(viewModel.page.entries.first { $0.reference == Self.past })) + + #expect(asked) + #expect(await provider.restored.isEmpty) + } + + @Test("The current version cannot be restored") + func currentIsNotRestorable() async throws { + let provider = makeProvider() + let viewModel = makeViewModel(provider) + await viewModel.loadList() + + #expect(!viewModel.canRestoreSelection) + await viewModel.restore(try #require(viewModel.page.current)) + #expect(await provider.restored.isEmpty) + } + + @Test("A failed refresh keeps what is shown, but a subject that is gone clears it") + func refreshFailures() async throws { + let provider = makeProvider() + let viewModel = makeViewModel(provider) + await viewModel.loadList() + await viewModel.detailTask?.value + + await provider.setLoadError(.commandFailed("git timed out")) + await viewModel.loadList() + #expect(viewModel.listState == .loaded) + #expect(viewModel.page.entries.count == 3) + + await provider.setLoadError(.subjectNotFound) + await viewModel.loadList() + #expect(viewModel.page.entries.isEmpty) + #expect(viewModel.listState == .failed(VersionHistoryError.subjectNotFound.localizedDescription)) + } +} + +@Suite("VersionComparison") +struct VersionComparisonTests { + @Test("Equal text is identical, different text is a line diff that keeps blank lines") + func outcomes() { + #expect(VersionComparison.compare(baseline: "a\n", current: "a\n") == .identical) + guard case .differs(let pairs) = VersionComparison.compare(baseline: "a\n\nb", current: "a\nb") else { + Issue.record("Expected a difference") + return + } + #expect(pairs.contains { $0.kind == .removed && $0.before == "" }) + } + + @Test("Text that differs only in line endings is identical") + func lineEndingsOnly() { + #expect(VersionComparison.compare(baseline: "a\nb\n", current: "a\r\nb\r\n") == .identical) + } + + @Test("Text past the line limit is not diffed") + func tooLarge() { + let big = Array(repeating: "x", count: VersionComparison.maximumLineCount + 1).joined(separator: "\n") + #expect(VersionComparison.compare(baseline: big, current: big + "\ny") == .tooLarge) + } +} + +@Suite("VersionHistoryPage") +struct VersionHistoryPageTests { + @Test("The current version's baseline is the newest past version, a past version's is the current one") + func baselines() { + let page = VersionHistoryPage(entries: [ + VersionHistoryEntry(reference: .current), + VersionHistoryEntry(reference: .gitRevision(commit: "b", path: "q.sql")), + VersionHistoryEntry(reference: .gitRevision(commit: "a", path: "q.sql")), + ]) + #expect(page.baseline(for: .current)?.reference == .gitRevision(commit: "b", path: "q.sql")) + #expect(page.baseline(for: .gitRevision(commit: "a", path: "q.sql"))?.reference == .current) + #expect(VersionHistoryPage(entries: [VersionHistoryEntry(reference: .current)]).baseline(for: .current) == nil) + #expect(VersionHistoryReference.gitRevision(commit: "0123456789", path: "q.sql").shortRevision == "0123456") + } +} diff --git a/TableProTests/Views/Main/MainContentCoordinatorRefreshTests.swift b/TableProTests/Views/Main/MainContentCoordinatorRefreshTests.swift index 6ebe8c8dd4..164cdb2932 100644 --- a/TableProTests/Views/Main/MainContentCoordinatorRefreshTests.swift +++ b/TableProTests/Views/Main/MainContentCoordinatorRefreshTests.swift @@ -8,6 +8,7 @@ // cancellation cleared isExecuting asynchronously. // +import Combine import Foundation import Testing @@ -375,4 +376,18 @@ struct MainContentCoordinatorRefreshTests { #expect(coordinator.refreshPendingTrailing == false) #expect(coordinator.refreshCoalesceTask == nil) } + + @Test("Refresh on a history tab asks that tab to reload its versions") + func refreshOnHistoryTabReloadsHistory() { + let (coordinator, tabManager) = makeCoordinator() + tabManager.addVersionHistoryTab(subject: .savedQuery(id: UUID()), title: "History: Revenue") + let tabId = tabManager.selectedTabId + var requested: [UUID] = [] + let subscription = AppEvents.shared.versionHistoryRefreshRequested.sink { requested.append($0) } + defer { subscription.cancel() } + + coordinator.handleRefresh(hasPendingTableOps: false, onDiscard: {}) + + #expect(requested == [tabId].compactMap { $0 }) + } } diff --git a/TableProTests/Views/Sidebar/FavoritesMenuSpecTests.swift b/TableProTests/Views/Sidebar/FavoritesMenuSpecTests.swift index 3ddc4d9875..266876cb4d 100644 --- a/TableProTests/Views/Sidebar/FavoritesMenuSpecTests.swift +++ b/TableProTests/Views/Sidebar/FavoritesMenuSpecTests.swift @@ -279,4 +279,64 @@ struct FavoritesMenuSpecTests { #expect(enabled.contains(.setLinkedFolderEnabled(folder, false)) == false) #expect(disabled.contains(.setLinkedFolderEnabled(folder, true))) } + + @Test("A saved query offers its history") + func savedQueryOffersHistory() { + let query = favorite() + let issued = commands(FavoritesMenuSpec.sections(for: context(clicked: .query(.favorite(query))))) + #expect(issued.contains(.showFavoriteHistory(query))) + } + + private func linkedFile() -> LinkedSQLFavorite { + LinkedSQLFavorite( + folderId: UUID(), + fileURL: URL(fileURLWithPath: "/tmp/queries/orders.sql"), + relativePath: "orders.sql", + name: "orders", + mtime: Date(), + fileSize: 10 + ) + } + + private func linkedCommands(_ file: LinkedSQLFavorite, gitState: LinkedFileGitState?) -> [FavoritesMenuCommand] { + let states = gitState.map { [file.id: $0] } ?? [:] + return commands(FavoritesMenuSpec.sections(for: FavoritesMenuContext( + clicked: .query(.linkedFavorite(file)), + linkedFileGitStates: states + ))) + } + + @Test("A linked file outside a repository offers no Git commands") + func linkedFileOutsideRepository() { + let file = linkedFile() + let issued = linkedCommands(file, gitState: nil) + #expect(!issued.contains(.showLinkedFileHistory(file))) + #expect(!issued.contains(.discardLinkedFileChanges(file))) + #expect(issued.contains(.openLinkedFavorite(file))) + } + + @Test("A clean tracked file offers history but nothing to discard") + func cleanTrackedFile() { + let file = linkedFile() + let issued = linkedCommands(file, gitState: .clean) + #expect(issued.contains(.showLinkedFileHistory(file))) + #expect(!issued.contains(.discardLinkedFileChanges(file))) + } + + @Test("A modified file offers history and Discard Changes") + func modifiedFile() { + let file = linkedFile() + let issued = linkedCommands(file, gitState: .changed(GitFileStatus(staged: .unmodified, unstaged: .modified))) + #expect(issued.contains(.showLinkedFileHistory(file))) + #expect(issued.contains(.discardLinkedFileChanges(file))) + } + + @Test("An untracked file offers neither history nor Discard Changes") + func untrackedFile() { + let file = linkedFile() + let issued = linkedCommands(file, gitState: .changed(.untracked)) + #expect(!issued.contains(.showLinkedFileHistory(file))) + #expect(!issued.contains(.discardLinkedFileChanges(file))) + #expect(issued.contains(.trashLinkedFavorite(file))) + } } diff --git a/TableProUITests/SavedQueryHistoryUITests.swift b/TableProUITests/SavedQueryHistoryUITests.swift new file mode 100644 index 0000000000..d8e4699a7b --- /dev/null +++ b/TableProUITests/SavedQueryHistoryUITests.swift @@ -0,0 +1,78 @@ +import AppKit +import XCTest + +/// Issue #2505. Editing a saved query keeps the SQL it replaced, Show History lists it, and +/// Restore This Version puts it back while keeping the text it replaced as another version. +final class SavedQueryHistoryUITests: UITestCase { + func testAnEditedSavedQueryCanBeRestoredFromItsHistory() throws { + let app = try launchWithSampleDatabase() + let window = app.windows.firstMatch + XCTAssertTrue(window.waitToExist(timeout: 30)) + showFavorites(in: app) + + let newFavorite = window.buttons["New Favorite…"] + XCTAssertTrue(newFavorite.waitToExist(timeout: 15), "The empty Favorites tab offers New Favorite…") + newFavorite.click() + fillFavoriteSheet(in: app, name: "Revenue", query: "SELECT 1", confirm: "Add") + + let row = window.outlines.staticTexts["Revenue"] + XCTAssertTrue(row.waitToExist(timeout: 15), "The new saved query appears in the sidebar") + row.rightClick() + let edit = contextMenuItem("Edit…", in: app) + XCTAssertTrue(edit.waitToExist(timeout: 5)) + edit.click() + fillFavoriteSheet(in: app, name: nil, query: "SELECT 2", confirm: "Save") + + XCTAssertTrue(row.waitToExist(timeout: 10)) + row.rightClick() + let showHistory = contextMenuItem("Show History", in: app) + XCTAssertTrue(showHistory.waitToExist(timeout: 5), "A saved query's menu offers Show History") + showHistory.click() + + let versions = window.tables["version-history-list"] + XCTAssertTrue(versions.waitToExist(timeout: 15), "Show History opens the history tab") + XCTAssertTrue( + waitForPredicate(timeout: 10) { versions.tableRows.count == 2 }, + "The current version and the SQL the edit replaced" + ) + + versions.tableRows.element(boundBy: 1).click() + let restore = window.buttons["version-history-restore"] + XCTAssertTrue(waitForPredicate(timeout: 10) { restore.isEnabled }, "An earlier version can be restored") + restore.click() + + XCTAssertTrue( + waitForPredicate(timeout: 10) { versions.tableRows.count == 3 }, + "Restoring keeps the SQL it replaced as another version" + ) + } + + private func fillFavoriteSheet(in app: XCUIApplication, name: String?, query: String, confirm: String) { + let sheet = app.sheets.firstMatch + XCTAssertTrue(sheet.waitToExist(timeout: 10), "The saved query sheet opens") + if let name { + let nameField = sheet.textFields.firstMatch + XCTAssertTrue(nameField.waitToExist(timeout: 5)) + nameField.click() + nameField.typeText(name) + } + let queryEditor = sheet.textViews.firstMatch + XCTAssertTrue(queryEditor.waitToExist(timeout: 5)) + queryEditor.click() + queryEditor.typeKey("a", modifierFlags: .command) + queryEditor.typeText(query) + let confirmButton = sheet.buttons[confirm] + XCTAssertTrue(waitForPredicate(timeout: 5) { confirmButton.isEnabled }) + confirmButton.click() + XCTAssertTrue(waitForPredicate(timeout: 10) { !sheet.exists }, "The sheet closes after \(confirm)") + } + + private func showFavorites(in app: XCUIApplication) { + let menuBar = app.menuBars.firstMatch + XCTAssertTrue(menuBar.waitToExist(timeout: 10)) + menuBar.menuBarItems["View"].click() + let showFavorites = menuBar.menuItems["Show Favorites"] + XCTAssertTrue(showFavorites.waitToExist(timeout: 5), "View > Show Favorites must be reachable") + showFavorites.click() + } +} diff --git a/docs/external-api/applescript.mdx b/docs/external-api/applescript.mdx index b703e467a2..bb44002867 100644 --- a/docs/external-api/applescript.mdx +++ b/docs/external-api/applescript.mdx @@ -81,7 +81,7 @@ No credential is reachable from a script, and neither is the account name. Every | Property | Type | | |---|---|---| | `id`, `name` | text | | -| `kind` | enumeration | `query editor`, `table`, `create table`, `diagram`, `server dashboard`, `users and roles`, `query insights`, `object source` | +| `kind` | enumeration | `query editor`, `table`, `create table`, `diagram`, `server dashboard`, `users and roles`, `query insights`, `object source`, `version history` | | `table name`, `database name`, `schema name` | text | | | `query` | text | The SQL of a query tab | | `current result` | query result | The rows the tab is showing | diff --git a/docs/features/connection-window.mdx b/docs/features/connection-window.mdx index 814c058979..9edfb15843 100644 --- a/docs/features/connection-window.mdx +++ b/docs/features/connection-window.mdx @@ -29,11 +29,11 @@ A control the tab cannot use leaves the toolbar rather than standing there dimme | Where you are | Not there | |---|---| | A new table's tab | Refresh. The definition is not on the server yet | -| ER diagram, Server Dashboard, Query Insights, a DDL tab | The commit control. None of the four stages an edit of its own | +| ER diagram, Server Dashboard, Query Insights, a DDL tab, a history tab | The commit control. None of them stages an edit of its own | | [Agent mode](/features/agent-mode) | Refresh and the commit control. The grid and the object browser are behind the conversation | | An engine with nothing to switch between | The database control. On [SQLite](/databases/sqlite) and [DuckDB](/databases/duckdb) the file beside it is the database; on an engine with a single namespace there is no second level to name | -That needs macOS 15. On macOS 13 and 14 the same eight stand in every context and dim where they cannot act, except in two places. Refresh stays enabled on a new table's tab. So does the commit control on an ER diagram, Server Dashboard, Query Insights or DDL tab while a **Truncate** or a **Delete** is staged in the sidebar: that queue belongs to the connection, not to the tab in front of it. +That needs macOS 15. On macOS 13 and 14 the same eight stand in every context and dim where they cannot act, except in two places. Refresh stays enabled on a new table's tab. So does the commit control on an ER diagram, Server Dashboard, Query Insights, DDL or history tab while a **Truncate** or a **Delete** is staged in the sidebar: that queue belongs to the connection, not to the tab in front of it. The shape settles on a tab switch, a mode switch and a connection switch, and at no other moment. A staged edit, a running query or a dropped connection dims a control; it never moves one. diff --git a/docs/features/favorites.mdx b/docs/features/favorites.mdx index 8bc62034ab..a5fd9d0f80 100644 --- a/docs/features/favorites.mdx +++ b/docs/features/favorites.mdx @@ -91,10 +91,20 @@ The cursor lands right after `orders.`, ready for a column name. Only the first ## Working with saved queries -Double-click a favorite, or press `Return`, to insert it into the editor. The right-click menu has **Insert in Editor**, **Run in New Tab**, **Copy Query**, **Edit…**, **Move to**, and **Delete**. Arrow keys move between rows, typing jumps to a name, and `Delete` asks first. +Double-click a favorite, or press `Return`, to insert it into the editor. The right-click menu has **Insert in Editor**, **Run in New Tab**, **Copy Query**, **Edit…**, **Show History**, **Move to**, and **Delete**. Arrow keys move between rows, typing jumps to a name, and `Delete` asks first. Folders come from the same background menu. A folder's own menu has **New Favorite…**, **New Subfolder**, **Rename**, **Global**, and **Delete Folder**; deleting one moves what was inside up to the parent level. A global folder carries a globe, and **Global** changes that folder alone: the queries inside keep the scope they had, so mark them global too if you want them everywhere. Anything kept in a folder a connection cannot see is listed at that connection's top level, whether it is a global query or a global subfolder. Drag a query or a linked file out of the sidebar to drop its SQL into the editor or another app. +## Saved query versions + +Each time a saved query's SQL changes, the text it replaced is kept. That includes an edit arriving from another Mac through iCloud, so a sync that overwrites your change leaves it recoverable. + +Right-click a saved query and choose **Show History**. A tab opens with the versions down the left, newest first. **Changes** compares the selected version with the current SQL; **Content** shows it read-only, with **Copy**, **Export…**, and **Open in Editor**. + +Choose **Restore This Version** to put it back. The SQL it replaces becomes a version too, so a restore is undone the same way. + +Each query keeps its last 50 versions, on this Mac only: versions never sync. Renaming, moving, or changing a keyword records nothing, and deleting a saved query deletes its versions. + ## Team Library On a Team license the Favorites tab gains a **Team Library** section holding what your team published. Double-click one, or press `Return`, to run it in a new tab. @@ -146,8 +156,43 @@ Right-click a row and choose **Edit Metadata…** to change frontmatter without ### Managing linked files -Press `Delete` on a linked file, or right-click and choose **Move File to Trash**: it goes to the macOS Trash and stays recoverable. The rest of that menu is **Open in Editor**, **Edit Metadata…**, **Copy Query**, and **Show in Finder**. +Press `Delete` on a linked file, or right-click and choose **Move File to Trash**: it goes to the macOS Trash and stays recoverable. The rest of that menu is **Open in Editor**, **Edit Metadata…**, **Copy Query**, and **Show in Finder**, plus the [Git commands](#git-status-and-history) inside a repository. A folder's root row carries **Show in Finder**, **Copy Path**, **Disable**, **Reload**, **Add Another SQL Folder…**, and **Remove from Sidebar**. Removing unlinks the folder and leaves the files where they are. Linked folder paths are the one part of Favorites that does not sync, so each Mac links its own copy. + +### Git status and history + +When a linked folder sits inside a Git working copy, a changed file carries a letter at the end of its row. Hover it to see whether the change is staged. + +| Letter | Meaning | +|--------|---------| +| M | Modified | +| A | Added to the index, not yet committed | +| R | Renamed in the index | +| U | Untracked | +| ! | Merge conflict | + +A file with no letter matches its last commit. Letters refresh when a file changes, when the repository changes, and when you switch back to TablePro. + + + Sidebar with M and U letters beside linked files, next to a history tab listing three commits and a split diff + Sidebar with M and U letters beside linked files, next to a history tab listing three commits and a split diff + + +Right-click a file for the Git commands: + +- **Show History** opens a tab listing the commits that changed the file, following it across renames, up to the 200 most recent. The top row is the file on disk; select it to see what changed since the last commit. +- **Restore This Version**, in that tab, writes the selected commit's text into the file. It asks first when the file has uncommitted changes, because those are lost. +- **Discard Changes…** puts the file back to its staged version, or to its last commit when nothing is staged. It cannot be undone. + +Both write the text exactly as Git stores it, without line-ending conversion or filters. A file stored with Git LFS cannot be restored or discarded here; use your Git client. If the file, or for Discard its staged version, changes while you confirm, nothing is written. + +Stage, commit, and push in your Git client. The sidebar reads the repository and never touches the index. + +Git comes from Xcode, the Command Line Tools, or Homebrew. When none is installed the letters and commands stay hidden, and the Command Line Tools installer never opens. + + +Link only repositories you trust. Reading a file's status runs the repository's own content filters, exactly as `git status` in Terminal does. + diff --git a/docs/images/linked-file-history-dark.png b/docs/images/linked-file-history-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..c4b891c373cdd397fefaa14f00b29f3b89538fd4 GIT binary patch literal 295220 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�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%0A>abP0+n6v!x=08 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 a+GSTgM0XL1aJMAJs9n{(lB;~z@BaWlb>q(f literal 0 HcmV?d00001 diff --git a/docs/images/linked-file-history.png b/docs/images/linked-file-history.png new file mode 100644 index 0000000000000000000000000000000000000000..1fe6b2399f787d25040f45309e70b2bcd78421c5 GIT binary patch literal 273506 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 z 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 literal 0 HcmV?d00001