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
import Foundation
import Observation
import PeelCore
@Observable
final class GitLibrary {
struct State: Equatable {
var isInstalled: Bool
var settings: [String: String?]?
var known: Set<String>?
var signingKey: String?
var setInIncludedFiles: Set<String> = []
}
static let ledgerKey = "terminalGit"
private let home: URL
private let defaults: UserDefaults
private var ledger: GitLedger
private var git: GitConfig?
private(set) var state: State?
private var asked: [GitSetting: Bool] = [:]
private(set) var wasRefused = false
/// What Git said when it refused, when it said something.
private(set) var whyRefused: GitConfig.Refusal?
private var waiting: [GitSetting: Int] = [:]
private var changes: Task<Void, Never>?
private let finding: () async -> GitConfig?
init(home: URL = .homeDirectory, defaults: UserDefaults = .standard, finding: (() async -> GitConfig?)? = nil) {
self.home = home
self.defaults = defaults
self.finding = finding ?? { await GitConfig.find(home: home) }
ledger = GitLedger(stored: defaults.dictionary(forKey: Self.ledgerKey) ?? [:])
}
var hasSomethingOn: Bool {
GitSetting.allCases.contains(where: isOn)
}
func refresh() async {
await afterTheOthers {
await self.read()
}.value
}
private func read() async {
// Xcode can move or its tools go while Peel runs.
let git = if let git, FileManager.default.isExecutableFile(atPath: git.executable.path(percentEncoded: false)) {
git
} else {
await finding()
}
let settings = await git?.settings()
var known = state?.known
if known == nil {
known = await git?.knownKeys()
}
self.git = git
state = State(
isInstalled: git != nil,
settings: settings,
known: known,
signingKey: GitSetting.signingKey(in: settings ?? [:], home: home),
setInIncludedFiles: await git?.keysSetByIncludedFiles() ?? []
)
}
func isOn(_ setting: GitSetting) -> Bool {
asked[setting] ?? state?.settings.map(setting.isOn(in:)) ?? false
}
func isOffered(_ setting: GitSetting) -> Bool {
guard let state, state.settings != nil, state.known.map(setting.isKnown(by:)) == true else { return false }
guard !isSetInIncludedFiles(setting) else { return false }
return setting != .signCommits || state.signingKey != nil || isOn(setting)
}
/// Whether a file the person's global settings include sets the setting, so Peel leaves it to them. One already on
/// can still be turned off.
func isSetInIncludedFiles(_ setting: GitSetting) -> Bool {
guard let state, !isOn(setting) else { return false }
return setting.isSetInIncludedFiles(state.setInIncludedFiles)
}
func set(_ setting: GitSetting, to isOn: Bool) {
ask([setting], isOn: isOn)
afterTheOthers {
await self.change([setting], to: isOn)
}
}
func turnAllOff() {
let settings = GitSetting.allCases.filter(isOn)
ask(settings, isOn: false)
afterTheOthers {
await self.change(settings, to: false)
}
}
func forgetRefusal() {
wasRefused = false
whyRefused = nil
}
private func save(_ ledger: GitLedger) {
defaults.set(ledger.stored, forKey: Self.ledgerKey)
}
private func ask(_ settings: [GitSetting], isOn: Bool) {
for setting in settings {
asked[setting] = isOn
waiting[setting, default: 0] += 1
}
}
@discardableResult
private func afterTheOthers(_ work: @escaping @MainActor () async -> Void) -> Task<Void, Never> {
let others = changes
let task = Task {
await others?.value
await work()
}
changes = task
return task
}
/// Changes the settings through Git, saving the ledger before each key Git writes, and a quit asked meanwhile
/// waits for the change to end.
private func change(_ settings: [GitSetting], to isOn: Bool) async {
if let git {
await QuitGuard.shared.run {
var ledger = ledger
var refused = false
var why: GitConfig.Refusal?
for setting in settings {
let outcome = isOn
? await ledger.turnOn(setting, signingKey: state?.signingKey, in: git) { save($0) }
: await ledger.turnOff(setting, in: git) { save($0) }
if case .refused(let refusal) = outcome {
refused = true
why = why ?? refusal
}
}
self.ledger = ledger
wasRefused = refused
whyRefused = why
}
await read()
}
for setting in settings {
waiting[setting, default: 1] -= 1
if waiting[setting] == 0 {
waiting[setting] = nil
asked[setting] = nil
}
}
}
}