Skip to content

armgit / peel

Public Imported from GitHub
0

Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.

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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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)
+ }
+}