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.

5.2 KB
Raw Blame
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
            }
        }
    }
}