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.

Keep an update answer for each build of an app

Țugui Dragoș0f99293c54fb
diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateMemory.swift b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateMemory.swift
index 529a6c89..a21e767a 100644
--- a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateMemory.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateMemory.swift
@@ -50,28 +50,87 @@ public struct UpdateMemory: Codable, Equatable, Sendable {
/// How long past its due date an entry is kept for an app that is not installed, such as one on a disk that
/// is not connected. Without a limit, the saved list would keep an entry for every app ever seen.
static let longestAbsence: TimeInterval = 90 * 24 * 60 * 60
+}
+
+/// What Peel knows about every app's updates, by bundle identifier, with an entry for each build a copy is at: an app
+/// and a beta of it share an identifier, and each keeps its own answer and schedule.
+public struct UpdateMemories: Equatable, Sendable {
+ private var entries: [String: [UpdateMemory]]
+
+ public init() {
+ entries = [:]
+ }
+
+ /// One entry per identifier, as Peel saved it before it kept one for each build.
+ init(_ earlier: [String: UpdateMemory]) {
+ entries = earlier.mapValues { [$0] }
+ }
+
+ /// Reads what was saved, in either form, or nil when it can't be read.
+ public init?(data: Data) {
+ let decoder = JSONDecoder()
+ if let builds = try? decoder.decode([String: [UpdateMemory]].self, from: data) {
+ entries = builds
+ } else if let earlier = try? decoder.decode([String: UpdateMemory].self, from: data) {
+ entries = earlier.mapValues { [$0] }
+ } else {
+ return nil
+ }
+ }
+
+ public var data: Data? {
+ try? JSONEncoder().encode(entries)
+ }
+
+ public var isEmpty: Bool {
+ entries.isEmpty
+ }
+
+ /// The entry about the build `app` is at.
+ public func entry(for app: InstalledApp) -> UpdateMemory? {
+ app.bundleIdentifier.flatMap { entries[$0] }?.first { $0.describes(app) }
+ }
+
+ /// Keeps `entry` for the build `app` is at, in place of the one about that build.
+ public mutating func keep(_ entry: UpdateMemory, for app: InstalledApp) {
+ guard let identifier = app.bundleIdentifier else { return }
+ entries[identifier, default: []].removeAll { $0.describes(app) }
+ entries[identifier, default: []].append(entry)
+ }
+
+ public mutating func forget(_ app: InstalledApp) {
+ guard let identifier = app.bundleIdentifier else { return }
+ entries[identifier]?.removeAll { $0.describes(app) }
+ if entries[identifier]?.isEmpty == true { entries[identifier] = nil }
+ }
+
+ /// The developer the App Store named for any build of the app, the latest kept first.
+ public func developer(of identifier: String) -> String? {
+ entries[identifier]?.reversed().lazy.compactMap(\.developer).first
+ }
- /// Returns the entries that still apply to `apps`. An entry is dropped when no installed copy is the build it
- /// describes, which also makes that app due at once, when an earlier checker couldn't check the app or gave the
- /// answer about a copy this checker asks nobody about, or when the app is not installed and the entry is more
- /// than `longestAbsence` past due. With two copies at two builds, the entry describes one of them and stays.
- public static func recalled(
- from memory: [String: UpdateMemory],
- for apps: [InstalledApp],
- now: Date = .now
- ) -> [String: UpdateMemory] {
+ /// The entries that still apply to `apps`. An entry is dropped when no installed copy is the build it describes,
+ /// which also makes that copy due at once, when an earlier checker couldn't check the app or gave the answer about
+ /// a copy this checker asks nobody about, or when the app is not installed and the entry is more than
+ /// `UpdateMemory.longestAbsence` past due.
+ public func recalled(for apps: [InstalledApp], now: Date = .now) -> UpdateMemories {
let installed = InstalledApp.byIdentifier(apps)
- return memory.filter { identifier, entry in
- let isEarlier = entry.revision ?? 1 < UpdateChecker.revision
- if entry.status == .unsupported, isEarlier { return false }
- guard let copies = installed[identifier] else {
- return entry.schedule.due.addingTimeInterval(longestAbsence) > now
+ var recalled = UpdateMemories()
+ for (identifier, builds) in entries {
+ let kept = builds.filter { entry in
+ let isEarlier = entry.revision ?? 1 < UpdateChecker.revision
+ if entry.status == .unsupported, isEarlier { return false }
+ guard let copies = installed[identifier] else {
+ return entry.schedule.due.addingTimeInterval(UpdateMemory.longestAbsence) > now
+ }
+ let described = copies.filter(entry.describes)
+ // An earlier checker may have asked a source this one no longer reads, and answering such a copy
+ // again costs no request.
+ if isEarlier, described.contains(where: UpdateChecker.asksNobody(about:)) { return false }
+ return !described.isEmpty
}
- let described = copies.filter(entry.describes)
- // An earlier checker may have asked a source this one no longer reads, and answering such a copy again
- // costs no request.
- if isEarlier, described.contains(where: UpdateChecker.asksNobody(about:)) { return false }
- return !described.isEmpty
+ if !kept.isEmpty { recalled.entries[identifier] = kept }
}
+ return recalled
}
}
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateMemoryTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateMemoryTests.swift
index 1a25437d..594a83cb 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateMemoryTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateMemoryTests.swift
@@ -35,9 +35,9 @@ struct UpdateMemoryTests {
)
let memory = ["com.example.foo": learned]
- #expect(UpdateMemory.recalled(from: memory, for: [app("1.0")]) == memory)
- #expect(UpdateMemory.recalled(from: memory, for: [app("2.0")]).isEmpty)
- #expect(UpdateMemory.recalled(from: memory, for: [app("1.0", build: "2")]).isEmpty)
+ #expect(UpdateMemories(memory).recalled(for: [app("1.0")]) == UpdateMemories(memory))
+ #expect(UpdateMemories(memory).recalled(for: [app("2.0")]).isEmpty)
+ #expect(UpdateMemories(memory).recalled(for: [app("1.0", build: "2")]).isEmpty)
}
/// Two copies of one app can sit at two builds, and an entry describes one of them. It is kept while either
@@ -51,8 +51,8 @@ struct UpdateMemoryTests {
bundleIdentifier: "com.example.foo", name: "Foo", version: "2.0", buildVersion: "1"
)
- #expect(UpdateMemory.recalled(from: memory, for: [app("1.0"), second]) == memory)
- #expect(UpdateMemory.recalled(from: memory, for: [second]).isEmpty)
+ #expect(UpdateMemories(memory).recalled(for: [app("1.0"), second]) == UpdateMemories(memory))
+ #expect(UpdateMemories(memory).recalled(for: [second]).isEmpty)
}
/// An app that is not installed right now keeps its entry, since it may be on a disk that is not connected.
@@ -62,14 +62,9 @@ struct UpdateMemoryTests {
let learned = UpdateMemory(status: .upToDate, schedule: schedule, checked: .now, describing: app("1.0"))
let memory = ["com.example.foo": learned]
- #expect(UpdateMemory.recalled(from: memory, for: [], now: schedule.due).count == 1)
- #expect(
- UpdateMemory.recalled(
- from: memory,
- for: [],
- now: schedule.due.addingTimeInterval(UpdateMemory.longestAbsence + 1)
- ).isEmpty
- )
+ let later = schedule.due.addingTimeInterval(UpdateMemory.longestAbsence + 1)
+ #expect(UpdateMemories(memory).recalled(for: [], now: schedule.due) == UpdateMemories(memory))
+ #expect(UpdateMemories(memory).recalled(for: [], now: later).isEmpty)
}
@Test func asksAgainAboutAnAppAnEarlierCheckerCouldNotCheck() throws {
@@ -77,27 +72,27 @@ struct UpdateMemoryTests {
let earlier = try JSONDecoder().decode([String: UpdateMemory].self, from: saved)
let now = Date(timeIntervalSinceReferenceDate: 814364011)
- #expect(UpdateMemory.recalled(from: earlier, for: [app("1.0")], now: now).isEmpty)
+ #expect(UpdateMemories(earlier).recalled(for: [app("1.0")], now: now).isEmpty)
let current = ["com.example.foo": UpdateMemory(status: .unsupported, schedule: schedule, checked: now, describing: app("1.0"))]
- #expect(UpdateMemory.recalled(from: current, for: [app("1.0")], now: now) == current)
+ #expect(UpdateMemories(current).recalled(for: [app("1.0")], now: now) == UpdateMemories(current))
let upToDate = try JSONDecoder().decode(
[String: UpdateMemory].self,
from: Data(String(decoding: saved, as: UTF8.self).replacingOccurrences(of: "unsupported", with: "upToDate").utf8)
)
- #expect(UpdateMemory.recalled(from: upToDate, for: [app("1.0", feed: feed)], now: now) == upToDate)
+ #expect(UpdateMemories(upToDate).recalled(for: [app("1.0", feed: feed)], now: now) == UpdateMemories(upToDate))
}
@Test func forgetsWhatAnEarlierCheckerSaidOfAnAppNobodyIsAskedAbout() throws {
for status in [UpdateStatus.updateAvailable(version: "2.0"), .upToDate, .failed] {
let entry = UpdateMemory(status: status, schedule: schedule, checked: .now, describing: app("1.0"))
let earlier = ["com.example.foo": try savedByAnEarlierChecker(entry)]
- #expect(UpdateMemory.recalled(from: earlier, for: [app("1.0")]).isEmpty, "\(status)")
- #expect(UpdateMemory.recalled(from: earlier, for: [app("1.0", feed: feed)]) == earlier, "\(status)")
+ #expect(UpdateMemories(earlier).recalled(for: [app("1.0")]).isEmpty, "\(status)")
+ #expect(UpdateMemories(earlier).recalled(for: [app("1.0", feed: feed)]) == UpdateMemories(earlier), "\(status)")
let current = ["com.example.foo": entry]
- #expect(UpdateMemory.recalled(from: current, for: [app("1.0")]) == current, "\(status)")
+ #expect(UpdateMemories(current).recalled(for: [app("1.0")]) == UpdateMemories(current), "\(status)")
}
}
@@ -119,6 +114,41 @@ struct UpdateMemoryTests {
#expect(old["com.example.foo"]?.describes(app("1.0")) == false)
}
+ @Test func keepsAnAnswerAndAScheduleForEachBuildOfAnApp() throws {
+ let beta = InstalledApp(
+ url: URL(filePath: "/Applications/Foo-beta.app", directoryHint: .isDirectory),
+ bundleIdentifier: "com.example.foo", name: "Foo", version: "2.0", buildVersion: "9"
+ )
+ let found = UpdateMemory(
+ status: .updateAvailable(version: "1.2", source: .appStore), schedule: schedule, checked: .now,
+ describing: app("1.0"), developer: "Example"
+ )
+ let unchecked = UpdateMemory(
+ status: .unsupported, schedule: UpdateSchedule.next(after: .unsupported), checked: .now, describing: beta
+ )
+ var memory = UpdateMemories()
+ memory.keep(found, for: app("1.0"))
+ memory.keep(unchecked, for: beta)
+
+ let saved = try #require(memory.data.flatMap(UpdateMemories.init(data:)))
+ #expect(saved == memory)
+ #expect(saved.entry(for: app("1.0")) == found)
+ #expect(saved.entry(for: beta) == unchecked)
+ #expect(saved.developer(of: "com.example.foo") == "Example")
+ #expect(saved.recalled(for: [app("1.0"), beta]) == memory)
+
+ memory.forget(beta)
+ #expect(memory.entry(for: beta) == nil && memory.entry(for: app("1.0")) == found)
+ }
+
+ @Test func readsTheOneEntryForEachAppAnEarlierPeelSaved() throws {
+ let entry = UpdateMemory(status: .upToDate, schedule: schedule, checked: nil, describing: app("1.0"))
+ let saved = try JSONEncoder().encode(["com.example.foo": entry])
+
+ #expect(UpdateMemories(data: saved)?.entry(for: app("1.0")) == entry)
+ #expect(UpdateMemories(data: Data("not a memory".utf8)) == nil)
+ }
+
@Test func keepsAcrossLaunchesThatTheAppStoreListedNoSuchApp() throws {
let entry = UpdateMemory(
status: .updateAvailable(version: "1.2", source: .appStore), schedule: schedule, checked: nil,
diff --git a/Peel/Model/AppLibrary.swift b/Peel/Model/AppLibrary.swift
index d6947811..6c5a5d61 100644
--- a/Peel/Model/AppLibrary.swift
+++ b/Peel/Model/AppLibrary.swift
@@ -40,13 +40,12 @@ struct VisibleApps {
}
private enum UpdateMemoryStore {
- static func load(from defaults: UserDefaults) -> [String: UpdateMemory] {
- guard let data = defaults.data(forKey: SettingsKey.updateMemory) else { return [:] }
- return (try? JSONDecoder().decode([String: UpdateMemory].self, from: data)) ?? [:]
+ static func load(from defaults: UserDefaults) -> UpdateMemories {
+ defaults.data(forKey: SettingsKey.updateMemory).flatMap(UpdateMemories.init(data:)) ?? UpdateMemories()
}
- static func save(_ memory: [String: UpdateMemory], to defaults: UserDefaults) {
- guard let data = try? JSONEncoder().encode(memory) else { return }
+ static func save(_ memory: UpdateMemories, to defaults: UserDefaults) {
+ guard let data = memory.data else { return }
defaults.set(data, forKey: SettingsKey.updateMemory)
}
}
@@ -146,7 +145,7 @@ final class AppLibrary {
/// True when any of the list's filters is on, the same three `visible(matching:)` applies.
var isFiltering: Bool { !sources.isEmpty || selectedDeveloper != nil || showsOnlyUnused }
- private var memory: [String: UpdateMemory]
+ private var memory: UpdateMemories
/// What is new in each waiting update, read at launch, so a page shows it with no connection too.
private(set) var releaseNotes = ReleaseNotesMemory()
private let releaseNotesStore: ReleaseNotesStore
@@ -334,7 +333,7 @@ final class AppLibrary {
picked.formIntersection(present)
// Forgets what was learned about a build that was replaced, including when to check it again.
- let recalled = UpdateMemory.recalled(from: memory, for: listed)
+ let recalled = memory.recalled(for: listed)
if recalled != memory {
memory = recalled
UpdateMemoryStore.save(memory, to: defaults)
@@ -353,8 +352,7 @@ final class AppLibrary {
/// Restores the update answers saved by earlier runs, for apps still at the build they describe.
private func recall() {
for app in apps {
- guard let identifier = app.bundleIdentifier, let remembered = memory[identifier], remembered.describes(app)
- else { continue }
+ guard let remembered = remembered(app) else { continue }
updateStatuses[app.id] = remembered.status
if let checked = remembered.checked {
lastUpdateChecks[app.id] = checked
@@ -412,7 +410,7 @@ final class AppLibrary {
}
func developer(of app: InstalledApp) -> String? {
- appDevelopers.developer(of: app, remembered: app.bundleIdentifier.flatMap { memory[$0]?.developer })
+ appDevelopers.developer(of: app, remembered: app.bundleIdentifier.flatMap(memory.developer(of:)))
}
var developers: [String] {
@@ -539,13 +537,13 @@ final class AppLibrary {
let now = Date.now
// An app is checked on a schedule kept by its identifier, so an app with none is left to Homebrew's answer.
let wanted = targets.filter { app in
- guard let identifier = app.bundleIdentifier, isAskedAboutUpdates(app) else { return false }
+ guard app.bundleIdentifier != nil, isAskedAboutUpdates(app) else { return false }
guard !force else { return true }
// Already being checked by another round: a second answer could double the wait for the next check.
guard !appsCheckingForUpdates.contains(app.id) else { return false }
// An update whose notes are still to be asked for is checked now rather than on its next turn.
let notesWait = releaseNotes.asks(about: updateStatuses[app.id], of: app, with: updatePreferences)
- return memory[identifier]?.schedule.isDue(at: now) ?? true || notesWait
+ return remembered(app)?.schedule.isDue(at: now) ?? true || notesWait
}
// The list's own entry, not the caller's: a page that was open through an upgrade still holds the old build.
.map { app in apps.first { $0.id == app.id } ?? app }
@@ -610,18 +608,19 @@ final class AppLibrary {
lastUpdateChecks[id] = .now
}
guard let identifier = app.bundleIdentifier else { continue }
- memory[identifier] = UpdateMemory(
+ let before = remembered(app)
+ memory.keep(UpdateMemory(
status: kept,
// A feed that failed is asked again on its own count, even where Homebrew answered in its place.
schedule: UpdateSchedule.next(
- after: answer.standsInFor ?? answer.status, following: memory[identifier]?.schedule
+ after: answer.standsInFor ?? answer.status, following: before?.schedule
),
- checked: answer.status == .failed ? memory[identifier]?.checked : .now,
+ checked: answer.status == .failed ? before?.checked : .now,
describing: app,
- developer: answer.developer ?? memory[identifier]?.developer,
+ developer: answer.developer ?? memory.developer(of: identifier),
standsInFor: standsInFor,
isNotListed: answer.isNotListed
- )
+ ), for: app)
// Only an answer that found this update can say what is new in it; a failed one keeps what was known.
if case .updateAvailable(let version, _, _) = kept, answer.status == kept {
if let notes = answer.notes {
@@ -725,7 +724,7 @@ final class AppLibrary {
updateRounds.sourceChanged()
updateStatuses = [:]
lastUpdateChecks = [:]
- memory = [:]
+ memory = UpdateMemories()
UpdateMemoryStore.save(memory, to: defaults)
await checkForUpdates(apps, force: true)
}
@@ -812,7 +811,7 @@ final class AppLibrary {
updateStatuses = updateStatuses.filter { !outlived.contains($0.key) }
lastUpdateChecks = lastUpdateChecks.filter { !outlived.contains($0.key) }
for app in apps where outlived.contains(app.id) {
- if let identifier = app.bundleIdentifier { memory[identifier] = nil }
+ memory.forget(app)
}
UpdateMemoryStore.save(memory, to: defaults)
}
@@ -835,7 +834,7 @@ final class AppLibrary {
/// The answer saved for `app`, while it is about the build installed.
private func remembered(_ app: InstalledApp) -> UpdateMemory? {
- app.bundleIdentifier.flatMap { memory[$0] }.flatMap { $0.describes(app) ? $0 : nil }
+ memory.entry(for: app)
}
/// Whether update checks ask about `app`. Never about Peel's own copies, which Sparkle keeps current, checking
diff --git a/PeelTests/AppLibraryTests.swift b/PeelTests/AppLibraryTests.swift
index 859f8863..f622b4fb 100644
--- a/PeelTests/AppLibraryTests.swift
+++ b/PeelTests/AppLibraryTests.swift
@@ -377,8 +377,8 @@ private nonisolated final class TestClock: Sendable {
await library.checkForUpdates([app], force: true)
#expect(library.shownUpdateStatus(of: app) == .upToDate)
let saved = try #require(made.defaults.data(forKey: SettingsKey.updateMemory))
- let memory = try JSONDecoder().decode([String: UpdateMemory].self, from: saved)
- #expect(memory["org.example.fed"]?.schedule.isRetrying == true, "the feed failed")
+ let memory = try #require(UpdateMemories(data: saved))
+ #expect(memory.entry(for: app)?.schedule.isRetrying == true, "the feed failed")
clock.set(homebrewChecked + 2 * Homebrew.autoUpdateInterval)
library.loadHomebrewCasks([cask("Fed", checked: homebrewChecked)], knowsItsOwnApps: true)
@@ -473,8 +473,8 @@ private nonisolated final class TestClock: Sendable {
library.loadHomebrewCasks([cask("Fed", checked: homebrewChecked)], knowsItsOwnApps: true)
#expect(library.shownUpdateStatus(of: app) == nil)
let saved = try #require(made.defaults.data(forKey: SettingsKey.updateMemory))
- let memory = try JSONDecoder().decode([String: UpdateMemory].self, from: saved)
- #expect(memory["org.example.fed"] == nil, "its feed answers at the next round")
+ let memory = try #require(UpdateMemories(data: saved))
+ #expect(memory.entry(for: app) == nil, "its feed answers at the next round")
}
@Test func aRoundAsksEveryAppEvenWhenAppsLeaveTheListBeforeTheirAnswers() async throws {
@@ -514,10 +514,8 @@ private nonisolated final class TestClock: Sendable {
#expect(await library.reveal([bundle]))
let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.fed" })
await library.checkForUpdates([app], force: true)
- let remembered = { () -> [String: UpdateMemory]? in
- made.defaults.data(forKey: SettingsKey.updateMemory).flatMap {
- try? JSONDecoder().decode([String: UpdateMemory].self, from: $0)
- }
+ let remembered = { () -> UpdateMemories? in
+ made.defaults.data(forKey: SettingsKey.updateMemory).flatMap(UpdateMemories.init(data:))
}
let known = remembered()
#expect(library.shownUpdateStatus(of: app) == .upToDate)
@@ -598,6 +596,49 @@ private nonisolated final class TestClock: Sendable {
#expect(library.releaseNotes.asks("org.example.fed", version: "1.1"))
}
+ @Test func twoCopiesOfAnAppAtTwoBuildsKeepAnAnswerEach() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ defer { try? FileManager.default.removeItem(at: folder) }
+ func copy(_ name: String, version: String, build: String, feed: String?) throws -> URL {
+ let bundle = folder.appending(path: "\(name).app", directoryHint: .isDirectory)
+ try FileManager.default.createDirectory(
+ at: bundle.appending(path: "Contents"), withIntermediateDirectories: true
+ )
+ var info: [String: Any] = [
+ "CFBundleIdentifier": "org.example.twin", "CFBundleName": name, "CFBundlePackageType": "APPL",
+ "CFBundleShortVersionString": version, "CFBundleVersion": build,
+ ]
+ info["SUFeedURL"] = feed
+ try PropertyListSerialization.data(fromPropertyList: info, format: .xml, options: 0)
+ .write(to: bundle.appending(path: "Contents/Info.plist"))
+ return bundle
+ }
+ let released = try copy("Twin", version: "1.0", build: "100", feed: "https://feed.example.com/appcast.xml")
+ let beta = try copy("Twin Beta", version: "2.0", build: "200", feed: nil)
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ AppcastProtocol.body.withLock {
+ $0 = Data("""
+ <rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"><channel><item>\
+ <enclosure url="https://feed.example.com/u.zip" sparkle:version="101" sparkle:shortVersionString="1.1" />\
+ </item></channel></rss>
+ """.utf8)
+ }
+ let library = library(with: made.defaults, notesIn: folder)
+ #expect(await library.reveal([released, beta]))
+ let copies = library.apps.filter { $0.bundleIdentifier == "org.example.twin" }
+ #expect(copies.count == 2)
+
+ await library.checkForUpdates(copies, force: true)
+
+ let data = made.defaults.data(forKey: SettingsKey.updateMemory)
+ let saved = try #require(data.flatMap(UpdateMemories.init(data:)))
+ let releasedCopy = try #require(copies.first { $0.version == "1.0" })
+ let betaCopy = try #require(copies.first { $0.version == "2.0" })
+ #expect(saved.entry(for: releasedCopy)?.status.version == "1.1")
+ #expect(saved.entry(for: betaCopy)?.status == .unsupported)
+ }
+
@Test func theListMovesAnUpdateFoundDuringARoundOnceTheRoundEnds() async throws {
let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
let quick = try caskApp("Quick", in: folder, feed: "https://quick.example.com/appcast.xml")