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.

14.4 KB
Raw Blame
import Accessibility
import Foundation
import Observation
import PeelCore

@Observable
final class TweakLibrary {
    private static let changedKey = "tweaksChangedByPeel"
    /// What each key held before Peel changed it, so a reset gives the user their own setting back.
    private static let previousKey = "tweaksValuesBeforePeel"
    private static let writtenKey = "tweaksValuesWrittenByPeel"
    private static let waitingKey = "tweaksWaitingForLogOut"
    private static let sessionKey = "tweaksWaitingSession"

    /// The audit session ID (`man getaudit_addr`), which is new with each login. It tells whether a change
    /// still waiting for a log out was made in this session.
    private static let loginSession: Int = {
        var info = auditinfo_addr_t()
        return getaudit_addr(&info, Int32(MemoryLayout<auditinfo_addr_t>.size)) == 0 ? Int(info.ai_asid) : 0
    }()

    private let store: any TweakStoring
    private let defaults: UserDefaults
    private let home: URL
    private let restart: @Sendable (Tweak.Restart) async -> Void
    private let announcing: (AttributedString) -> Void
    /// What Peel changed, and the values from before. `TweakLedger` decides what turning a switch on or off
    /// does, and is tested there.
    private var ledger: TweakLedger
    private(set) var states: [Tweak.ID: TweakState] = [:]
    private(set) var isSleepDisabled = false
    /// The settings changed in this login session that take effect only after the user logs out. They are
    /// saved with the session ID, so they survive quitting Peel and are dropped after the next login.
    private(set) var waitingForLogOut: Set<Tweak.ID>

    init(
        store: any TweakStoring = TweakStore(),
        defaults: UserDefaults = .standard,
        home: URL = .homeDirectory,
        restart: @escaping @Sendable (Tweak.Restart) async -> Void = TweakRestart.run,
        announcing: @escaping (AttributedString) -> Void = { AccessibilityNotification.Announcement($0).post() }
    ) {
        self.store = store
        self.announcing = announcing
        self.defaults = defaults
        self.home = home
        self.restart = restart
        ledger = TweakLedger(
            changedByPeel: Set(defaults.stringArray(forKey: Self.changedKey) ?? []),
            previousValues: defaults.dictionary(forKey: Self.previousKey) ?? [:],
            writtenValues: defaults.dictionary(forKey: Self.writtenKey) ?? [:]
        )
        let isThisSession = defaults.integer(forKey: Self.sessionKey) == Self.loginSession
        waitingForLogOut = isThisSession ? Set(defaults.stringArray(forKey: Self.waitingKey) ?? []) : []
        ledger.adoptStoredValuesAsWritten(in: store)
        refresh()
    }

    func isWaitingForLogOut(_ group: Tweak.Group) -> Bool {
        tweaks(in: group).contains { waitingForLogOut.contains($0.id) }
    }

    /// The tweaks of the page Peel changed whose keys still hold its value, with nothing a profile sets or another
    /// layer of the preferences holds over them: what their rows put back, and all Turn All Off puts back.
    private(set) var peelsChanges: Set<Tweak.ID> = []

    func isChangedByPeel(_ tweak: Tweak) -> Bool {
        peelsChanges.contains(tweak.id)
    }

    func tweaks(in group: Tweak.Group) -> [Tweak] {
        TweakCatalog.all.filter { $0.group == group }
    }

    func state(of tweak: Tweak) -> TweakState {
        states[tweak.id] ?? .unset
    }

    /// Reads every tweak's state again. System Settings can change any of them while Peel runs, so the page
    /// calls this each time Peel becomes active rather than trusting what it read before.
    func refresh() {
        store.beginReading()
        if ledger.forgetChangesNoLongerHeld(in: store) { save() }
        states = Dictionary(
            TweakCatalog.all.map { ($0.id, store.state(of: $0)) },
            uniquingKeysWith: { first, _ in first }
        )
        peelsChanges = Set(
            Self.onTweaksPage
                .filter { ledger.isPeels($0, state: state(of: $0), stored: store.storedValue(of: $0)) }
                .map(\.id)
        )
        isSleepDisabled = SleepSetting.isSleepDisabled()
    }

    /// The value each switch was just set to, kept until the write and any restart are done. A `Toggle` reads
    /// its binding again in the same update, so without this the switch would spring back until the write lands.
    private(set) var asked: [Tweak.ID: Bool] = [:]

    func isOn(_ tweak: Tweak, state: TweakState) -> Bool {
        asked[tweak.id] ?? state.isOn
    }

    /// A switch's changes to one tweak, made one at a time: flipped quickly, only the latest waiting change runs next.
    private var lines: [Tweak.ID: OneAtATime<Bool>] = [:]
    /// The tweaks changed by a switch whose restart was left to a change waiting after it.
    private var restartOwed: Set<Tweak.ID> = []

    /// Returns the task that makes the change, which a test can await; the page lets it run.
    @discardableResult
    func set(_ tweak: Tweak, on isOn: Bool) -> Task<Void, Never> {
        asked[tweak.id] = isOn
        foldersLeftToMacOS.remove(tweak.id)
        let line = lines[tweak.id] ?? OneAtATime()
        lines[tweak.id] = line
        return Task {
            await line.ask(isOn) { [self] isOn, anotherWaits in
                let outcome = isOn ? ledger.turnOn(tweak, in: store) : ledger.turnOff(tweak, in: store)
                await finish(tweak, after: outcome, isLast: !anotherWaits())
            }
        }
    }

    func turnOn(_ tweak: Tweak, text: String? = nil) async {
        foldersLeftToMacOS.remove(tweak.id)
        await finish(tweak, after: ledger.turnOn(tweak, text: text, in: store))
    }

    func rename(_ tweak: Tweak, to name: String) async {
        name.isEmpty ? await reset(tweak) : await turnOn(tweak, text: name)
    }

    /// Turns `tweak` off. A setting Peel changed gets back the value it had before. A setting changed by hand
    /// is removed, so macOS falls back to its default.
    func reset(_ tweak: Tweak) async {
        let hasGone = await folderFromBeforeHasGoneAway(tweak)
        // A folder's row offers this only for Peel's change, which a second press or Turn All Off may have put back
        // during that wait. Turned off again, the key would lose what they put back.
        guard tweak.kind != .folder || ledger.changedByPeel.contains(tweak.id) else { return }
        leaveToMacOS(tweak, ifItsFolderHasGone: hasGone)
        await finish(tweak, after: ledger.turnOff(tweak, in: store))
    }

    /// The folder tweaks whose Put Back handed the setting to macOS, since the folder from before Peel's change
    /// could no longer take screenshots. Each row says so until the tweak changes again, and all go with the page.
    private(set) var foldersLeftToMacOS: Set<Tweak.ID> = []

    /// `screencapture` saves nothing in a folder that isn't there, is in the Trash, or can't be written to, so a
    /// folder from before that has become one is not put back: the key goes instead, and macOS saves on the Desktop.
    private func folderFromBeforeHasGoneAway(_ tweak: Tweak) async -> Bool {
        guard tweak.kind == .folder, let before = ledger.previousValues[tweak.id] as? String else { return false }
        return await ScreenshotFolder.hasGoneAway(before, home: home)
    }

    private func leaveToMacOS(_ tweak: Tweak, ifItsFolderHasGone hasGone: Bool) {
        guard hasGone else {
            foldersLeftToMacOS.remove(tweak.id)
            return
        }
        ledger.forgetPreviousValue(of: tweak)
        foldersLeftToMacOS.insert(tweak.id)
    }

    private func save() {
        defaults.set(Array(ledger.changedByPeel), forKey: Self.changedKey)
        defaults.set(ledger.previousValues, forKey: Self.previousKey)
        defaults.set(ledger.writtenValues, forKey: Self.writtenKey)
        defaults.set(Array(waitingForLogOut), forKey: Self.waitingKey)
        defaults.set(Self.loginSession, forKey: Self.sessionKey)
    }

    func chooseScreenshotFolder(for tweak: Tweak) async {
        // Asked again once the panel has closed, since the folder can change after the panel's own check.
        guard let url = await ScreenshotFolderPanel.choose(), await ScreenshotFolder.takesScreenshots(url, home: home)
        else { return }
        await turnOn(tweak, text: ScreenshotFolder.setting(for: url))
    }

    /// The settings Peel could not write, so each row can say so instead of letting the switch spring back
    /// with no reason. A tweak leaves the set with its next write that lands, and all of them when the page goes.
    private(set) var refused: Set<Tweak.ID> = []

    func forgetNotices() {
        refused = []
        foldersLeftToMacOS = []
    }
    private(set) var isTurningAllOff = false

    private static let onTweaksPage = TweakCatalog.all.filter { Tweak.Group.onTweaksPage.contains($0.group) }

    /// Puts back every change of Peel's, as its own row would, and restarts each affected process once. What the
    /// person set themselves stays as it is.
    func turnAllOff() async {
        isTurningAllOff = true
        defer { isTurningAllOff = false }
        // Read again: System Settings may have changed any of these after the page was drawn.
        refresh()
        let shown = Self.onTweaksPage.filter { peelsChanges.contains($0.id) }
        var foldersGone: Set<Tweak.ID> = []
        for tweak in shown where tweak.kind == .folder {
            if await folderFromBeforeHasGoneAway(tweak) { foldersGone.insert(tweak.id) }
        }
        // A row may have put its own change back during those waits, and turned off again its key would lose that.
        let tried = shown.filter { ledger.changedByPeel.contains($0.id) }
        for tweak in tried {
            leaveToMacOS(tweak, ifItsFolderHasGone: foldersGone.contains(tweak.id))
        }
        let batch = ledger.turnOff(tried, in: store)
        refused.subtract(tried.map(\.id))
        refused.formUnion(batch.refused.map(\.id))
        for tweak in batch.changed where tweak.restart == .logOut {
            waitingForLogOut.formSymmetricDifference([tweak.id])
        }
        save()
        for needed in batch.restarts {
            await restart(needed)
        }
        refresh()
        announcing(
            Self.spoken(puttingBack: batch.changed.count, refused: batch.refused.count, restarts: batch.restarts)
        )
    }

    /// What VoiceOver hears once Turn All Off has ended, since the bar's words change without a sound.
    private static func spoken(puttingBack: Int, refused: Int, restarts: [Tweak.Restart]) -> AttributedString {
        var words = AttributedString(localized: "Put back ^[\(puttingBack) setting](inflect: true).")
        if refused > 0 {
            words += AttributedString(" ")
            words += AttributedString(localized: "macOS refused ^[\(refused) setting](inflect: true).")
        }
        for sentence in restarts.compactMap(\.sentence) {
            words += AttributedString(" ")
            words += AttributedString(localized: sentence)
        }
        return words
    }

    /// Saves the result of a change and restarts what the tweak needs. Nothing restarts when the setting was
    /// already as asked.
    private func finish(_ tweak: Tweak, after outcome: TweakLedger.Outcome, isLast: Bool = true) async {
        defer { if isLast { asked[tweak.id] = nil } }
        if outcome == .refused { refused.insert(tweak.id) } else { refused.remove(tweak.id) }
        guard outcome != .refused else {
            announcing(AttributedString(localized: "macOS refused the change to \(String(localized: tweak.words.title))."))
            if isLast, restartOwed.remove(tweak.id) != nil { await restart(tweak.restart) }
            refresh()
            return
        }
        // Each change flips the tweak in or out of the waiting set: changed and then changed back, it is as it
        // was at login, and nothing waits.
        if outcome == .changed, tweak.restart == .logOut {
            waitingForLogOut.formSymmetricDifference([tweak.id])
        }
        save()
        if !isLast {
            if outcome == .changed { restartOwed.insert(tweak.id) }
        } else {
            let wasOwed = restartOwed.remove(tweak.id) != nil
            if outcome == .changed || wasOwed { await restart(tweak.restart) }
        }
        refresh()
    }
}

extension Tweak.Group {
    static let onTweaksPage = allCases.filter { $0 != .terminal }

    var title: LocalizedStringResource {
        switch self {
        case .dock: "Dock"
        case .screenshots: "Screenshots"
        case .finder: "Finder"
        case .typing: "Typing"
        case .windows: "Windows"
        case .privacy: "Privacy"
        case .terminal: "Terminal"
        }
    }

    var systemImage: String {
        switch self {
        case .dock: "dock.rectangle"
        case .screenshots: "camera.viewfinder"
        case .finder: "folder"
        case .typing: "keyboard"
        case .windows: "macwindow"
        case .privacy: "hand.raised"
        case .terminal: "terminal"
        }
    }
}

extension TweakState.Elsewhere {
    var words: LocalizedStringResource {
        switch self {
        case .thisMac: "Set for this Mac"
        case .everyAccount: "Set for every account"
        case .everyApp: "Set for every app"
        }
    }
}

extension Tweak.Restart {
    var note: LocalizedStringResource? {
        switch self {
        case .none: nil
        case .dock: "The Dock restarts"
        case .finder: "Finder restarts"
        case .controlCenter: "macOS’s menu bar items restart"
        case .windowManager: "The window manager restarts"
        case .relaunchApps: "Open apps keep the old setting until you reopen them"
        case .logOut: "Takes effect after you log out"
        case .terminalQuits: "Takes effect the next time Terminal quits"
        }
    }

    /// The same note as a full sentence, for the text behind the circled i. Each language ends it with its own
    /// punctuation.
    var sentence: LocalizedStringResource? {
        switch self {
        case .none: nil
        case .dock: "The Dock restarts."
        case .finder: "Finder restarts, which stops anything it is copying."
        case .controlCenter: "macOS’s menu bar items restart, since Control Center draws them."
        case .windowManager: "The window manager restarts."
        case .relaunchApps: "Open apps keep the old setting until you reopen them, and an app with a setting of its own for this keeps that."
        case .logOut: "Takes effect after you log out."
        case .terminalQuits: "Takes effect the next time Terminal quits."
        }
    }
}