Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.
Swift cache-cleanercleanerclideveloper-toolsdisk-cleanupdisk-spaceduplicate-finderhomebrewliquid-glassmac-cleanermacosmacos-appmacos-golden-gatemacos-tahoemacos-tweaksswiftswiftuiterminal-themesuninstalluninstaller
Let the Git tab change Git's settings through git config and put them back
Țugui Dragoș8eef69c3baff
diff --git a/Packages/PeelCore/Sources/PeelCore/Terminal/GitConfig.swift b/Packages/PeelCore/Sources/PeelCore/Terminal/GitConfig.swiftnew file mode 100644index 00000000..ef6e430a--- /dev/null+++ b/Packages/PeelCore/Sources/PeelCore/Terminal/GitConfig.swift@@ -0,0 +1,72 @@+public import Foundation+import PeelPrivileged++/// Git's global settings, read and changed through `git config --global`, Git's own command, in the home Peel+/// serves. `/usr/bin/git` is never run, since without the developer tools it asks macOS to install them.+public struct GitConfig: Sendable {+ public let executable: URL+ let home: URL++ public static func find(home: URL = .homeDirectory) async -> GitConfig? {+ let developer = await Subprocess.run("/usr/bin/xcode-select", ["-p"], environment: [:], timeout: 10)+ let folder: URL? = if case .success(let output) = developer, output.status == 0 {+ URL(filePath: output.text.trimmingCharacters(in: .whitespacesAndNewlines), directoryHint: .isDirectory)+ } else {+ nil+ }+ let homebrew = Homebrew.executableURL?.deletingLastPathComponent().deletingLastPathComponent()+ return find(developerFolder: folder, homebrewPrefix: homebrew, home: home)+ }++ static func find(developerFolder: URL?, homebrewPrefix: URL?, home: URL) -> GitConfig? {+ [developerFolder?.appending(path: "usr/bin/git"), homebrewPrefix?.appending(path: "bin/git")]+ .compactMap { $0 }+ .first { FileManager.default.isExecutableFile(atPath: $0.path(percentEncoded: false)) }+ .map { GitConfig(executable: $0, home: home) }+ }++ /// The global settings by their names in lowercase, a key written with no value as `.some(nil)`. None when+ /// there is no global file, and nil when Git could not read them.+ public func settings() async -> [String: String?]? {+ let files = [home.appending(path: ".gitconfig"), home.appending(path: ".config/git/config")]+ guard files.contains(where: { !$0.isMissing }) else { return [:] }+ guard case .success(let output) = await run(["config", "--global", "--list", "-z"]), output.status == 0 else { return nil }+ var settings: [String: String?] = [:]+ for entry in output.standardOutput.split(separator: 0) {+ let text = String(decoding: entry, as: UTF8.self)+ if let newline = text.firstIndex(of: "\n") {+ settings[text[..<newline].lowercased()] = String(text[text.index(after: newline)...])+ } else {+ settings[text.lowercased()] = .some(nil)+ }+ }+ return settings+ }++ /// Every setting this Git knows, in lowercase, as `git help --config` lists them. A setting whose keys are not+ /// all known is never offered, so a Git that renames or drops one never gets a key it would ignore.+ public func knownKeys() async -> Set<String>? {+ guard case .success(let output) = await run(["help", "--config"]), output.status == 0 else { return nil }+ return Set(output.text.split(separator: "\n").map { $0.lowercased() })+ }++ public func set(_ key: String, to value: String) async -> Bool {+ guard case .success(let output) = await run(["config", "--global", "--replace-all", key, value]) else { return false }+ return output.status == 0+ }++ /// Removes every value of `key`. Git answers 5 when there is none, which is what was asked.+ public func remove(_ key: String) async -> Bool {+ guard case .success(let output) = await run(["config", "--global", "--unset-all", key]) else { return false }+ return output.status == 0 || output.status == 5+ }++ private func run(_ arguments: [String]) async -> Result<Subprocess.Output, Subprocess.Failure> {+ await Subprocess.run(+ executable.path(percentEncoded: false),+ arguments,+ environment: ["HOME": home.path(percentEncoded: false), "PATH": "/usr/bin:/bin:/usr/sbin:/sbin"],+ timeout: 10+ )+ }+}diff --git a/Packages/PeelCore/Sources/PeelCore/Terminal/GitLedger.swift b/Packages/PeelCore/Sources/PeelCore/Terminal/GitLedger.swiftnew file mode 100644index 00000000..4a444f22--- /dev/null+++ b/Packages/PeelCore/Sources/PeelCore/Terminal/GitLedger.swift@@ -0,0 +1,70 @@+/// What Peel wrote to Git's settings and what each key held before, so turning a setting off puts back what the+/// person had. A key the person changed after Peel did is theirs, and is left as it is.+public struct GitLedger {+ public enum Outcome: Sendable, Equatable {+ case changed+ case unchanged+ case refused+ }++ public private(set) var previous: [String: String]+ public private(set) var written: [String: String]++ public init(stored: [String: Any] = [:]) {+ previous = stored["previous"] as? [String: String] ?? [:]+ written = stored["written"] as? [String: String] ?? [:]+ }++ public var stored: [String: Any] {+ ["previous": previous, "written": written]+ }++ public mutating func turnOn(_ setting: GitSetting, signingKey: String?, in config: GitConfig) async -> Outcome {+ let values = setting.values(signingKey: signingKey)+ guard !values.isEmpty, let settings = await config.settings() else { return .refused }+ var outcome = Outcome.unchanged+ for wanted in values {+ let name = wanted.key.lowercased()+ let before = settings[name]+ guard before != .some(.some(wanted.value)) else { continue }+ let isPeels = written[name].map { before == .some(.some($0)) } ?? false+ guard await config.set(wanted.key, to: wanted.value) else { return .refused }+ if !isPeels {+ switch before {+ case .none: previous.removeValue(forKey: name)+ case .some(.none): previous[name] = "true"+ case .some(.some(let value)): previous[name] = value+ }+ }+ written[name] = wanted.value+ outcome = .changed+ }+ return outcome+ }++ public mutating func turnOff(_ setting: GitSetting, in config: GitConfig) async -> Outcome {+ guard let settings = await config.settings() else { return .refused }+ var outcome = Outcome.unchanged+ for key in setting.keys {+ let name = key.lowercased()+ let now = settings[name]+ if let mine = written[name] {+ if now == .some(.some(mine)) {+ let restored = if let before = previous[name] {+ await config.set(key, to: before)+ } else {+ await config.remove(key)+ }+ guard restored else { return .refused }+ outcome = .changed+ }+ written.removeValue(forKey: name)+ previous.removeValue(forKey: name)+ } else if setting.switchKeys.contains(key), now != nil {+ guard await config.remove(key) else { return .refused }+ outcome = .changed+ }+ }+ return outcome+ }+}diff --git a/Packages/PeelCore/Sources/PeelCore/Terminal/GitSetting.swift b/Packages/PeelCore/Sources/PeelCore/Terminal/GitSetting.swiftnew file mode 100644index 00000000..e24302b6--- /dev/null+++ b/Packages/PeelCore/Sources/PeelCore/Terminal/GitSetting.swift@@ -0,0 +1,113 @@+public import Foundation++public enum GitSetting: CaseIterable, Sendable {+ case rebaseOnPull+ case pushNewBranches+ case pruneOnFetch+ case stashBeforeRebase+ case histogramDiff+ case colorMovedLines+ case zdiff3Conflicts+ case reuseResolutions+ case mainBranch+ case branchesByDate+ case columns+ case signCommits++ public enum Group: CaseIterable, Sendable {+ case pullAndPush, diffsAndMerges, branches, signing+ }++ public struct Value: Equatable, Sendable {+ public let key: String+ public let value: String+ }++ public var group: Group {+ switch self {+ case .rebaseOnPull, .pushNewBranches, .pruneOnFetch, .stashBeforeRebase: .pullAndPush+ case .histogramDiff, .colorMovedLines, .zdiff3Conflicts, .reuseResolutions: .diffsAndMerges+ case .mainBranch, .branchesByDate, .columns: .branches+ case .signCommits: .signing+ }+ }++ /// The public key to sign commits with: the first default key `ssh-keygen` makes that is in `~/.ssh`.+ public static func signingKey(in home: URL) -> String? {+ ["id_ed25519.pub", "id_ecdsa.pub", "id_rsa.pub"]+ .map { home.appending(path: ".ssh/\($0)").path(percentEncoded: false) }+ .first { FileManager.default.fileExists(atPath: $0) }+ }++ /// What turning the setting on writes. Signing needs a public key, so without one it writes nothing.+ public func values(signingKey: String?) -> [Value] {+ switch self {+ case .rebaseOnPull: [Value(key: "pull.rebase", value: "true")]+ case .pushNewBranches: [Value(key: "push.autoSetupRemote", value: "true")]+ case .pruneOnFetch: [Value(key: "fetch.prune", value: "true")]+ case .stashBeforeRebase: [Value(key: "rebase.autoStash", value: "true")]+ case .histogramDiff: [Value(key: "diff.algorithm", value: "histogram")]+ case .colorMovedLines: [Value(key: "diff.colorMoved", value: "default")]+ case .zdiff3Conflicts: [Value(key: "merge.conflictStyle", value: "zdiff3")]+ case .reuseResolutions: [Value(key: "rerere.enabled", value: "true")]+ case .mainBranch: [Value(key: "init.defaultBranch", value: "main")]+ case .branchesByDate: [Value(key: "branch.sort", value: "-committerdate")]+ case .columns: [Value(key: "column.ui", value: "auto")]+ case .signCommits:+ signingKey.map {+ [+ Value(key: "gpg.format", value: "ssh"),+ Value(key: "user.signingKey", value: $0),+ Value(key: "commit.gpgSign", value: "true"),+ ]+ } ?? []+ }+ }++ var keys: [String] {+ switch self {+ case .signCommits: ["gpg.format", "user.signingKey", "commit.gpgSign"]+ default: values(signingKey: nil).map(\.key)+ }+ }++ /// The keys that make the setting take effect, which turning it off removes when Peel did not write them.+ /// Signing keeps the format and the key the person chose for themselves, and stops only `commit.gpgSign`.+ var switchKeys: [String] {+ switch self {+ case .signCommits: ["commit.gpgSign"]+ default: values(signingKey: nil).map(\.key)+ }+ }++ public func isKnown(by keys: Set<String>) -> Bool {+ self.keys.allSatisfy { keys.contains($0.lowercased()) }+ }++ /// Whether Git's global settings, keyed by their names in lowercase, have this setting in effect.+ public func isOn(in settings: [String: String?]) -> Bool {+ switch self {+ case .signCommits:+ Self.value(settings["gpg.format"]) == "ssh" && Self.isTrue(settings["commit.gpgsign"])+ && !(Self.value(settings["user.signingkey"]) ?? "").isEmpty+ default:+ values(signingKey: nil).allSatisfy { wanted in+ let found = settings[wanted.key.lowercased()]+ return wanted.value == "true" ? Self.isTrue(found) : Self.value(found)?.lowercased() == wanted.value.lowercased()+ }+ }+ }++ /// A key that is not there is nil, and a key written with no value is `.some(nil)`, which Git reads as true.+ private static func value(_ found: String??) -> String? {+ found.flatMap { $0 }+ }++ private static func isTrue(_ found: String??) -> Bool {+ switch found {+ case .none: false+ case .some(.none): true+ case .some(.some(let text)): ["true", "yes", "on", "1"].contains(text.lowercased())+ }+ }+}diff --git a/Packages/PeelCore/Tests/PeelCoreTests/GitSettingsTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/GitSettingsTests.swiftnew file mode 100644index 00000000..f7bd77d8--- /dev/null+++ b/Packages/PeelCore/Tests/PeelCoreTests/GitSettingsTests.swift@@ -0,0 +1,140 @@+import Foundation+@testable import PeelCore+import Testing++private struct GitHome {+ let home: URL+ let config: GitConfig++ init() async throws {+ home = FileManager.default.temporaryDirectory.appending(path: "GitSettingsTests-\(UUID().uuidString)", directoryHint: .isDirectory)+ try FileManager.default.createDirectory(at: home, withIntermediateDirectories: true)+ config = try #require(await GitConfig.find(home: home))+ }++ var file: String {+ (try? String(contentsOf: home.appending(path: ".gitconfig"), encoding: .utf8)) ?? ""+ }++ func settings() async throws -> [String: String?] {+ try #require(await config.settings())+ }++ func publicKey(_ name: String) throws -> String {+ let key = home.appending(path: ".ssh/\(name)")+ try FileManager.default.createDirectory(at: key.deletingLastPathComponent(), withIntermediateDirectories: true)+ try "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIExample org.example\n".write(to: key, atomically: true, encoding: .utf8)+ return key.path(percentEncoded: false)+ }+}++struct GitSettingsTests {+ @Test func everySettingTurnsOnAndOffThroughGitAndLeavesNothingBehind() async throws {+ let git = try await GitHome()+ let key = try git.publicKey("id_ed25519.pub")+ for setting in GitSetting.allCases {+ var ledger = GitLedger()+ #expect(!setting.isOn(in: try await git.settings()), "\(setting)")+ #expect(await ledger.turnOn(setting, signingKey: key, in: git.config) == .changed, "\(setting)")+ #expect(setting.isOn(in: try await git.settings()), "\(setting)")+ #expect(await ledger.turnOff(setting, in: git.config) == .changed, "\(setting)")+ #expect(!setting.isOn(in: try await git.settings()), "\(setting)")+ #expect(ledger.written.isEmpty && ledger.previous.isEmpty, "\(setting)")+ }+ #expect(git.file.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, "\(git.file)")+ }++ @Test func whatThePersonHadBeforeComesBack() async throws {+ let git = try await GitHome()+ #expect(await git.config.set("pull.rebase", to: "false"))+ #expect(await git.config.set("merge.conflictStyle", to: "diff3"))+ var ledger = GitLedger()+ #expect(await ledger.turnOn(.rebaseOnPull, signingKey: nil, in: git.config) == .changed)+ #expect(await ledger.turnOn(.zdiff3Conflicts, signingKey: nil, in: git.config) == .changed)+ #expect(try await git.settings()["pull.rebase"] == "true")+ #expect(await ledger.turnOff(.rebaseOnPull, in: git.config) == .changed)+ #expect(await ledger.turnOff(.zdiff3Conflicts, in: git.config) == .changed)+ let settings = try await git.settings()+ #expect(settings["pull.rebase"] == "false")+ #expect(settings["merge.conflictstyle"] == "diff3")+ }++ @Test func aValueThePersonChangedAfterPeelStaysTheirs() async throws {+ let git = try await GitHome()+ var ledger = GitLedger()+ #expect(await ledger.turnOn(.rebaseOnPull, signingKey: nil, in: git.config) == .changed)+ #expect(await git.config.set("pull.rebase", to: "merges"))+ #expect(await ledger.turnOff(.rebaseOnPull, in: git.config) == .unchanged)+ #expect(try await git.settings()["pull.rebase"] == "merges")+ #expect(ledger.written.isEmpty)+ }++ @Test func turningOffSigningThePersonSetUpStopsOnlyTheSigning() async throws {+ let git = try await GitHome()+ let key = try git.publicKey("id_ed25519.pub")+ for value in GitSetting.signCommits.values(signingKey: key) {+ #expect(await git.config.set(value.key, to: value.value))+ }+ #expect(GitSetting.signCommits.isOn(in: try await git.settings()))+ var ledger = GitLedger()+ #expect(await ledger.turnOff(.signCommits, in: git.config) == .changed)+ let settings = try await git.settings()+ #expect(settings["commit.gpgsign"] == nil)+ #expect(settings["gpg.format"] == "ssh")+ #expect(settings["user.signingkey"] == .some(key))+ }++ @Test func everyWayGitWritesTrueCountsAsOn() {+ for written in ["true", "TRUE", "yes", "on", "1"] {+ #expect(GitSetting.pruneOnFetch.isOn(in: ["fetch.prune": written]), "\(written)")+ }+ let valueless: [String: String?] = ["fetch.prune": nil]+ #expect(GitSetting.pruneOnFetch.isOn(in: valueless))+ for written in ["false", "no", "off", "0"] {+ #expect(!GitSetting.pruneOnFetch.isOn(in: ["fetch.prune": written]), "\(written)")+ }+ #expect(GitSetting.histogramDiff.isOn(in: ["diff.algorithm": "Histogram"]))+ }++ @Test func aGlobalFileGitCannotReadIsNotKnownAndNothingIsWritten() async throws {+ let git = try await GitHome()+ try "[pull\n\trebase = false\n".write(to: git.home.appending(path: ".gitconfig"), atomically: true, encoding: .utf8)+ #expect(await git.config.settings() == nil)+ var ledger = GitLedger()+ #expect(await ledger.turnOn(.rebaseOnPull, signingKey: nil, in: git.config) == .refused)+ #expect(git.file == "[pull\n\trebase = false\n")+ }++ @Test func signingUsesTheFirstDefaultKeyAndNeedsOne() async throws {+ let git = try await GitHome()+ #expect(GitSetting.signingKey(in: git.home) == nil)+ var ledger = GitLedger()+ #expect(await ledger.turnOn(.signCommits, signingKey: nil, in: git.config) == .refused)+ let rsa = try git.publicKey("id_rsa.pub")+ #expect(GitSetting.signingKey(in: git.home) == rsa)+ let ed25519 = try git.publicKey("id_ed25519.pub")+ #expect(GitSetting.signingKey(in: git.home) == ed25519)+ }++ @Test func theGitOnThisMacKnowsEverySettingAndASettingItDoesNotKnowIsNotOffered() async throws {+ let git = try await GitHome()+ let known = try #require(await git.config.knownKeys())+ for setting in GitSetting.allCases {+ #expect(setting.isKnown(by: known), "\(setting)")+ }+ #expect(!GitSetting.pushNewBranches.isKnown(by: known.subtracting(["push.autosetupremote"])))+ }++ @Test func gitIsTheOneTheDeveloperToolsOrHomebrewInstalledAndNeverTheShim() throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "GitSettingsTests-\(UUID().uuidString)", directoryHint: .isDirectory)+ let developer = folder.appending(path: "Developer", directoryHint: .isDirectory)+ let homebrew = folder.appending(path: "homebrew", directoryHint: .isDirectory)+ for git in [developer.appending(path: "usr/bin/git"), homebrew.appending(path: "bin/git")] {+ try FileManager.default.createDirectory(at: git.deletingLastPathComponent(), withIntermediateDirectories: true)+ #expect(FileManager.default.createFile(atPath: git.path(percentEncoded: false), contents: Data(), attributes: [.posixPermissions: 0o755]))+ }+ #expect(GitConfig.find(developerFolder: developer, homebrewPrefix: homebrew, home: folder)?.executable == developer.appending(path: "usr/bin/git"))+ #expect(GitConfig.find(developerFolder: nil, homebrewPrefix: homebrew, home: folder)?.executable == homebrew.appending(path: "bin/git"))+ #expect(GitConfig.find(developerFolder: folder.appending(path: "Missing"), homebrewPrefix: nil, home: folder) == nil)+ }+}