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.

Count Homebrew's "up to date" only within a day of its last check

Țugui Dragoș97e792f40d21
diff --git a/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift b/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift
index fcd5c370..e7174d22 100644
--- a/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift
+++ b/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift
@@ -805,8 +805,11 @@ struct UpdatesCommand: AsyncParsableCommand {
let preferences = UpdatePreferences.asTheAppSeesThem()
let homebrew = await CaskLookup.installed()
let toCheck = apps.filter { !preferences.isIgnored($0) }
+ let checker = UpdateChecker()
let statuses = await ProgressLine.reporting { show in
- await Self.statuses(for: toCheck, preference: preferences.source, casks: homebrew.casks) { answered in
+ await Self.statuses(
+ for: toCheck, checker: checker, preference: preferences.source, casks: homebrew.casks
+ ) { answered in
show(Self.progress(checked: answered, of: toCheck.count))
}
}
@@ -827,6 +830,12 @@ struct UpdatesCommand: AsyncParsableCommand {
if let note = homebrew.note {
Output.note(note)
}
+ let notCheckedRecently = toCheck.filter { statuses[$0.id] == .unsupported }.compactMap { app in
+ checker.caskNotCheckedRecently(for: app, preference: preferences.source, casks: homebrew.casks)
+ }
+ if let note = Self.note(aboutCasksNotCheckedRecently: notCheckedRecently) {
+ Output.note(note)
+ }
if report.ignored > 0 {
Output.note("\(Output.count(report.ignored, "app is", "apps are")) set to be left alone in Peel and \(report.ignored == 1 ? "wasn't" : "weren't") checked.")
}
@@ -839,6 +848,17 @@ struct UpdatesCommand: AsyncParsableCommand {
}
}
+ /// Says why the apps these casks installed got no answer: Homebrew's last check for new versions is too old to
+ /// tell (`UpdateChecker.caskNotCheckedRecently`).
+ static func note(aboutCasksNotCheckedRecently casks: [HomebrewPackage], timeZone: TimeZone = .current) -> String? {
+ guard !casks.isEmpty else { return nil }
+ let apps = "\(Output.count(casks.count, "app", "apps")) it installed \(casks.count == 1 ? "is" : "are")"
+ guard let checked = casks.compactMap(\.lastUpdateCheck).max() else {
+ return "Homebrew doesn't say when it last checked for new versions, so whether \(apps) up to date isn't known."
+ }
+ return "Homebrew last checked for new versions on \(Output.day(checked, timeZone: timeZone)), so whether \(apps) up to date isn't known. Run `brew update`, then check again."
+ }
+
static func progress(checked: Int, of total: Int) -> String {
"Checked \(Output.number(checked)) of \(Output.count(total, "app", "apps"))"
}
@@ -856,12 +876,12 @@ struct UpdatesCommand: AsyncParsableCommand {
private static func statuses(
for apps: [InstalledApp],
+ checker: UpdateChecker,
preference: UpdateSource,
casks: [HomebrewPackage],
answered: (Int) -> Void
) async -> [InstalledApp.ID: UpdateStatus] {
- let checker = UpdateChecker()
- return await withTaskGroup(of: (InstalledApp.ID, UpdateStatus).self) { group in
+ await withTaskGroup(of: (InstalledApp.ID, UpdateStatus).self) { group in
var pending = apps.makeIterator()
var statuses: [InstalledApp.ID: UpdateStatus] = [:]
for _ in 0..<concurrentChecks {
diff --git a/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift b/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift
index f88d622b..b9d3239b 100644
--- a/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift
@@ -56,6 +56,9 @@ public struct HomebrewPackage: Sendable, Hashable, Identifiable {
/// True for an installed cask that left nothing on this Mac: every app gone from where Homebrew put it, or, for a
/// cask with no app, every package it installed, as their receipts say. Set by `checkingWhatItInstalled`.
public private(set) var isMissingWhatItInstalled = false
+ /// When Homebrew last checked for new versions, read before this package was (`Homebrew.lastUpdateCheck()`), or
+ /// nil when Peel couldn't tell. What `isOutdated` says is no more recent than that check.
+ public private(set) var lastUpdateCheck: Date?
public var id: String { "\(kind.rawValue)/\(name)" }
@@ -115,6 +118,12 @@ public struct HomebrewPackage: Sendable, Hashable, Identifiable {
return noted
}
+ public func noting(lastUpdateCheck: Date?) -> HomebrewPackage {
+ var noted = self
+ noted.lastUpdateCheck = lastUpdateCheck
+ return noted
+ }
+
public func kept(inCaskroom caskroom: URL) -> HomebrewPackage {
var kept = self
kept.caskroomFolder = caskroom.appending(path: name, directoryHint: .isDirectory)
@@ -426,6 +435,9 @@ public enum Homebrew {
/// The command brew.sh gives for installing Homebrew. Its script says what it will do and waits before doing it.
public static let installCommand = "/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""
public static let website = URL(string: "https://brew.sh")!
+ /// How long Homebrew lets its last check for new versions stand before it checks again on its own: the default of
+ /// `HOMEBREW_AUTO_UPDATE_SECS` (`man brew`).
+ public static let autoUpdateInterval: TimeInterval = 24 * 60 * 60
public struct CommandFailure: Error, Sendable, Hashable {
public let output: String
@@ -529,14 +541,33 @@ public enum Homebrew {
}
}
+ /// When Homebrew last checked for new versions: when `brew update` last touched `.git/FETCH_HEAD` in Homebrew's
+ /// repository, the file Homebrew itself compares with `HOMEBREW_AUTO_UPDATE_SECS` before it updates on its own.
+ /// Nil when Homebrew doesn't say where its repository is, or the file isn't there.
+ @concurrent
+ public static func lastUpdateCheck() async -> Date? {
+ guard let answer = try? await answer(["--repository"]), let repository = folder(answering: answer) else {
+ return nil
+ }
+ return lastUpdateCheck(inRepository: repository)
+ }
+
+ /// Homebrew reads the file only as a regular file (`find -type f` in `utils/auto-update.sh`), never through a link.
+ static func lastUpdateCheck(inRepository repository: URL) -> Date? {
+ FileIdentity.of(repository.appending(path: ".git/FETCH_HEAD"))?.modificationDate
+ }
+
@concurrent
public static func installedPackages() async throws(CommandFailure) -> [HomebrewPackage] {
+ // Read first, so a check made while the packages are read leaves them dated older than they are, never newer.
+ let checked = await lastUpdateCheck()
let output = try await answer(["info", "--json=v2", "--installed"])
- let caskroom = (try? await answer(["--caskroom"])).flatMap(caskroom(answering:))
+ let caskroom = (try? await answer(["--caskroom"])).flatMap(folder(answering:))
guard let packages = parseInstalled(Data(output.utf8), caskroom: caskroom) else {
throw CommandFailure(output: output)
}
- return await checkedOnThisMac(packages, pkgutil: PackageReceipts.pkgutil)
+ let dated = packages.map { $0.noting(lastUpdateCheck: checked) }
+ return await checkedOnThisMac(dated, pkgutil: PackageReceipts.pkgutil)
}
/// The installed packages with what this Mac says of them: the receipts their casks name, where those packages
@@ -833,7 +864,8 @@ public enum Homebrew {
return Set(line.dropFirst(prefix.count).split(separator: ",").map { $0.trimmingCharacters(in: .whitespaces) })
}
- static func caskroom(answering answer: String) -> URL? {
+ /// The one folder `brew --caskroom` or `brew --repository` answers with.
+ static func folder(answering answer: String) -> URL? {
let lines = answer.split(whereSeparator: \.isNewline)
guard lines.count == 1, let path = lines.first.map(String.init), path.hasPrefix("/") else { return nil }
return URL(filePath: path, directoryHint: .isDirectory)
diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift
index f441c2c4..c47f976d 100644
--- a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift
@@ -30,9 +30,14 @@ public struct UpdateChecker: Sendable {
private let country: String
private let systemVersion: String
private let isAppleSilicon = HostArchitecture.isAppleSilicon
+ /// The time a check is made at, which decides whether what Homebrew says is recent enough to count.
+ private let clock: @Sendable () -> Date
- public init(session: URLSession? = nil, locale: Locale = .current) {
+ public init(
+ session: URLSession? = nil, locale: Locale = .current, clock: @escaping @Sendable () -> Date = { .now }
+ ) {
self.session = session ?? URLSession(configuration: Self.configuration)
+ self.clock = clock
country = Self.storefront(of: locale)
let version = ProcessInfo.processInfo.operatingSystemVersion
systemVersion = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"
@@ -66,24 +71,20 @@ public struct UpdateChecker: Sendable {
casks: [HomebrewPackage] = [],
earlier: UpdateStatus? = nil
) async -> UpdateAnswer {
+ let homebrew = homebrewStatus(for: app, casks: casks)
+ if let status = Self.statusWithoutAsking(for: app, preference: preference, homebrew: homebrew) {
+ return UpdateAnswer(status: status)
+ }
switch preference {
- case .homebrew:
- // A cask Homebrew knows but never installed says nothing about this app's version, so the
- // app's own feed answers instead of a false "up to date".
- if let homebrew = homebrewStatus(for: app, casks: casks) { return UpdateAnswer(status: homebrew) }
+ case .homebrew, .developer:
return await feedAnswer(for: app, earlier: earlier)
case .appStore:
// Even with this preference, Apple is asked only about apps from the App Store. Any other app is
// checked through its own feed, or not at all.
return app.isFromAppStore
? await appStoreAnswer(for: app, earlier: earlier) : await feedAnswer(for: app, earlier: earlier)
- case .developer:
- return await feedAnswer(for: app, earlier: earlier)
case .automatic:
- let homebrew = homebrewStatus(for: app, casks: casks)
- if case .updateAvailable = homebrew { return UpdateAnswer(status: homebrew ?? .unsupported) }
- // An app from a cask may have no feed of its own, and a feed can be down. In both cases what Homebrew
- // knows is used rather than "Can't check for updates".
+ // A feed can be down, and the App Store may not sell the app here: what Homebrew knows is used then.
let feed = await feedAnswer(for: app, earlier: earlier)
if let homebrew, feed.status == .unsupported || feed.status == .failed {
return UpdateAnswer(status: homebrew, developer: feed.developer)
@@ -92,16 +93,65 @@ public struct UpdateChecker: Sendable {
}
}
- /// Homebrew's answer for `app`, found without a network request, or nil when Homebrew did not install this
- /// copy. For a cask it did not install, Homebrew has a definition but no installed version to compare.
+ /// The status `answer(for:preference:casks:earlier:)` gives `app` without asking any server, from Homebrew's
+ /// casks and the app's own files alone, or nil when the app's own feed or the App Store has to be asked.
+ public func statusWithoutAsking(
+ for app: InstalledApp, preference: UpdateSource, casks: [HomebrewPackage]
+ ) -> UpdateStatus? {
+ Self.statusWithoutAsking(for: app, preference: preference, homebrew: homebrewStatus(for: app, casks: casks))
+ }
+
+ private static func statusWithoutAsking(
+ for app: InstalledApp, preference: UpdateSource, homebrew: UpdateStatus?
+ ) -> UpdateStatus? {
+ // An app whose bundle names no version, or no feed, has nothing to ask.
+ let hasNobodyToAsk = app.version == nil || app.updateFeed == nil
+ switch preference {
+ case .homebrew:
+ // A cask Homebrew knows but never installed says nothing about this app's version, and neither does one
+ // Homebrew can't tell about, so the app's own feed answers then instead of a false "up to date".
+ return homebrew ?? (hasNobodyToAsk ? .unsupported : nil)
+ case .automatic:
+ if case .updateAvailable = homebrew { return homebrew }
+ // An app from a cask may have no feed of its own: what Homebrew knows is used rather than "Can't check
+ // for updates".
+ return hasNobodyToAsk ? homebrew ?? .unsupported : nil
+ case .developer:
+ return hasNobodyToAsk ? .unsupported : nil
+ case .appStore:
+ return hasNobodyToAsk && !app.isFromAppStore ? .unsupported : nil
+ }
+ }
+
+ /// Homebrew's answer for `app`, found without a network request, or nil when Homebrew did not install this copy
+ /// or can't tell (`homebrewStatus(of:at:)`). For a cask it did not install, Homebrew has a definition but no
+ /// installed version to compare.
public func homebrewStatus(for app: InstalledApp, casks: [HomebrewPackage]) -> UpdateStatus? {
- CaskEvidence.installedCask(for: app, in: casks).map(Self.homebrewStatus(of:))
+ CaskEvidence.installedCask(for: app, in: casks).flatMap { Self.homebrewStatus(of: $0, at: clock()) }
+ }
+
+ /// The status Homebrew reports at `now` for `cask`, which is already known to be the app's, or nil when it can't
+ /// tell. A cask it doesn't mark outdated is up to date only while Homebrew's last check for new versions is less
+ /// than `Homebrew.autoUpdateInterval` old, the longest Homebrew itself waits before it checks again.
+ static func homebrewStatus(of cask: HomebrewPackage, at now: Date) -> UpdateStatus? {
+ if cask.isOutdated, let latest = cask.latestVersion {
+ return .updateAvailable(version: latest, source: .homebrew, releaseNotes: cask.homepage)
+ }
+ guard let checked = cask.lastUpdateCheck, now.timeIntervalSince(checked) < Homebrew.autoUpdateInterval else {
+ return nil
+ }
+ return .upToDate
}
- /// The status Homebrew reports for `cask`, which is already known to be the app's.
- public static func homebrewStatus(of cask: HomebrewPackage) -> UpdateStatus {
- guard cask.isOutdated, let latest = cask.latestVersion else { return .upToDate }
- return .updateAvailable(version: latest, source: .homebrew, releaseNotes: cask.homepage)
+ /// The cask `app` came from when only Homebrew could say whether it is up to date and Homebrew's last check for
+ /// new versions is too old to tell (`homebrewStatus(of:at:)`), which is why a check has no answer for it.
+ public func caskNotCheckedRecently(
+ for app: InstalledApp, preference: UpdateSource, casks: [HomebrewPackage]
+ ) -> HomebrewPackage? {
+ guard preference == .automatic || preference == .homebrew, app.version == nil || app.updateFeed == nil,
+ let cask = CaskEvidence.installedCask(for: app, in: casks)
+ else { return nil }
+ return Self.homebrewStatus(of: cask, at: clock()) == nil ? cask : nil
}
private func feedAnswer(for app: InstalledApp, earlier: UpdateStatus?) async -> UpdateAnswer {
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift
index 7dbbed9b..f49c2a00 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift
@@ -995,6 +995,16 @@ struct CommandLineTests {
#expect(!some.nothingAnswered)
}
+ @Test func saysWhyAppsHomebrewInstalledGotNoAnswer() {
+ let cask = HomebrewPackage(name: "example", kind: .cask, installedVersion: "1.0")
+ let checked = cask.noting(lastUpdateCheck: Date(timeIntervalSince1970: 1_792_315_250))
+ let utc = TimeZone(identifier: "UTC")!
+
+ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [], timeZone: utc) == nil)
+ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [checked], timeZone: utc) == "Homebrew last checked for new versions on 2026-10-18, so whether 1 app it installed is up to date isn't known. Run `brew update`, then check again.")
+ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [cask, cask], timeZone: utc) == "Homebrew doesn't say when it last checked for new versions, so whether 2 apps it installed are up to date isn't known.")
+ }
+
/// `--all` lists an app Peel can't check as the app does. "No update feed" was wrong for an app that came with
/// macOS, an App Store app with no Mac version to read, and an app whose bundle names no version.
@Test func saysAnAppItCannotCheckCannotBeChecked() {
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift
index 1ca503d8..fd14fae2 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift
@@ -22,11 +22,11 @@ struct HomebrewReceiptTests {
}
@Test func readsTheCaskroomHomebrewNames() {
- #expect(Homebrew.caskroom(answering: "/opt/homebrew/Caskroom\n")?.path(percentEncoded: false)
+ #expect(Homebrew.folder(answering: "/opt/homebrew/Caskroom\n")?.path(percentEncoded: false)
== "/opt/homebrew/Caskroom/")
- #expect(Homebrew.caskroom(answering: "") == nil)
- #expect(Homebrew.caskroom(answering: "Caskroom\n") == nil)
- #expect(Homebrew.caskroom(answering: "/opt/homebrew/Caskroom\n/usr/local/Caskroom\n") == nil)
+ #expect(Homebrew.folder(answering: "") == nil)
+ #expect(Homebrew.folder(answering: "Caskroom\n") == nil)
+ #expect(Homebrew.folder(answering: "/opt/homebrew/Caskroom\n/usr/local/Caskroom\n") == nil)
}
@Test func everyCaskInstalledOnThisMacIsReadAsItIsOnTheDisk() async throws {
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift
index 245f44a4..fae1b2a0 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift
@@ -51,6 +51,47 @@ struct HomebrewTests {
#expect(read.standardError == "Error: It seems the App source is not there.\n")
}
+ @Test func readsWhenHomebrewLastCheckedForNewVersions() throws {
+ let repository = try TemporaryDirectory()
+ let fetchHead = try repository.file(".git/FETCH_HEAD", contents: Data("main of https://github.com/Homebrew/brew\n".utf8))
+ let checked = Date(timeIntervalSince1970: 1_792_315_250)
+ let path = fetchHead.path(percentEncoded: false)
+ try FileManager.default.setAttributes([.modificationDate: checked], ofItemAtPath: path)
+ #expect(Homebrew.lastUpdateCheck(inRepository: repository.url) == checked)
+
+ let linked = try TemporaryDirectory()
+ try linked.directory(".git")
+ try FileManager.default.createSymbolicLink(at: linked.url.appending(path: ".git/FETCH_HEAD"), withDestinationURL: fetchHead)
+ #expect(Homebrew.lastUpdateCheck(inRepository: linked.url) == nil, "Homebrew's `find -type f` passes over a link")
+
+ let folder = try TemporaryDirectory()
+ try folder.directory(".git/FETCH_HEAD")
+ #expect(Homebrew.lastUpdateCheck(inRepository: folder.url) == nil)
+ let empty = try TemporaryDirectory()
+ #expect(Homebrew.lastUpdateCheck(inRepository: empty.url) == nil)
+ }
+
+ @Test func readsTheLastCheckOfTheHomebrewOnThisMac() async throws {
+ guard Homebrew.executableURL != nil else {
+ #expect(await Homebrew.lastUpdateCheck() == nil)
+ return
+ }
+ let answer = try await Homebrew.execute(["--repository"], autoUpdate: false, timeout: 30).answer()
+ let repository = try #require(Homebrew.folder(answering: answer))
+ let fetchHead = repository.appending(path: ".git/FETCH_HEAD").path(percentEncoded: false)
+ let attributes = try? FileManager.default.attributesOfItem(atPath: fetchHead)
+ let isAFile = attributes?[.type] as? FileAttributeType == .typeRegular
+ let expected = isAFile ? attributes?[.modificationDate] as? Date : nil
+ let read = await Homebrew.lastUpdateCheck()
+
+ #expect((read == nil) == (expected == nil))
+ if let read, let expected {
+ #expect(abs(read.timeIntervalSince(expected)) < 0.001)
+ }
+ guard await Homebrew.hasLocalDefinitions() else { return }
+ #expect(try await Homebrew.installedPackages().allSatisfy { $0.lastUpdateCheck == read })
+ }
+
@Test func anUpgradeNeverWaitsForAnAnswer() {
for autoUpdate in [true, false] {
#expect(Homebrew.environment(autoUpdate: autoUpdate)["HOMEBREW_NO_ASK"] == "1")
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift
index 499a35ef..b3423ad1 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift
@@ -130,18 +130,38 @@ private final class CannedProtocol: URLProtocol, @unchecked Sendable {
#expect(await checker.status(for: sparkleApp()) == expected)
}
+ private let homebrewChecked = Date(timeIntervalSince1970: 1_792_315_250)
+
+ private func checking(at now: Date) -> UpdateChecker {
+ let configuration = URLSessionConfiguration.ephemeral
+ configuration.protocolClasses = [CannedProtocol.self]
+ return UpdateChecker(session: URLSession(configuration: configuration), clock: { now })
+ }
+
+ private var feedlessApp: InstalledApp {
+ InstalledApp(url: URL(filePath: "/Applications/Example.app"), bundleIdentifier: "com.example.app", name: "Example", version: "1.0")
+ }
+
+ private var fedApp: InstalledApp {
+ InstalledApp(
+ url: feedlessApp.url, bundleIdentifier: feedlessApp.bundleIdentifier, name: feedlessApp.name,
+ version: "1.0", buildVersion: "100", updateFeed: sparkleApp().updateFeed
+ )
+ }
+
+ private func cask(latest: String = "1.0", checked: Date?) -> HomebrewPackage {
+ HomebrewPackage(
+ name: "example", kind: .cask, installedVersion: "1.0", latestVersion: latest, isOutdated: latest != "1.0",
+ appNames: ["Example.app"]
+ ).noting(lastUpdateCheck: checked)
+ }
+
/// Many apps installed with Homebrew carry no update feed of their own. In the automatic mode, Homebrew's
/// answer is used for them rather than "Can't check for updates".
@Test func automaticFallsBackToWhatHomebrewKnows() async {
- let app = InstalledApp(url: URL(filePath: "/Applications/Example.app"), bundleIdentifier: "com.example.app", name: "Example", version: "1.0")
- let current = HomebrewPackage(
- name: "example",
- kind: .cask,
- installedVersion: "1.0",
- latestVersion: "1.0",
- isOutdated: false,
- appNames: ["Example.app"]
- )
+ let app = feedlessApp
+ let current = cask(checked: homebrewChecked)
+ let checker = checking(at: homebrewChecked + 60 * 60)
reply("nowhere.example.com", "")
#expect(await checker.status(for: app, preference: .automatic, casks: [current]) == .upToDate)
@@ -161,6 +181,84 @@ private final class CannedProtocol: URLProtocol, @unchecked Sendable {
#expect(await checker.status(for: fed, preference: .automatic, casks: [current]) == .upToDate)
}
+ @Test func homebrewCanNotSayAnAppIsUpToDateADayAfterItChecked() async {
+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)
+ let current = [cask(checked: homebrewChecked)]
+ reply("nowhere.example.com", "")
+
+ #expect(await later.status(for: feedlessApp, preference: .automatic, casks: current) == .unsupported)
+ #expect(await later.status(for: feedlessApp, preference: .homebrew, casks: current) == .unsupported)
+ #expect(
+ await later.status(for: feedlessApp, preference: .automatic, casks: [cask(checked: nil)]) == .unsupported,
+ "no check known"
+ )
+ #expect(
+ await later.status(for: feedlessApp, casks: [cask(latest: "2.0", checked: nil)])
+ == .updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)
+ )
+ #expect(CannedProtocol.asked.withLock { $0 }.isEmpty)
+
+ reply("feed.example.com", appcast("<item><enclosure url=\"https://feed.example.com/a.zip\" sparkle:version=\"200\" sparkle:shortVersionString=\"2.0\" /></item>"))
+ #expect(
+ await later.status(for: fedApp, preference: .homebrew, casks: current)
+ == .updateAvailable(version: "2.0", source: .developer, releaseNotes: nil)
+ )
+ #expect(CannedProtocol.asked.withLock { $0 } == ["feed.example.com"])
+
+ reply("feed.example.com", status: 500, "")
+ #expect(await later.status(for: fedApp, preference: .automatic, casks: current) == .failed)
+ }
+
+ @Test func answersWithoutAServerWhatHomebrewAndTheAppAloneDecide() async {
+ let recent = checking(at: homebrewChecked + 60 * 60)
+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)
+ let current = [cask(checked: homebrewChecked)]
+ let outdated = [cask(latest: "2.0", checked: nil)]
+ let update = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)
+ reply("nowhere.example.com", "")
+
+ for preference in UpdateSource.allCases {
+ for casks in [outdated, current, []] {
+ for checker in [recent, later] {
+ let decided = checker.statusWithoutAsking(for: feedlessApp, preference: preference, casks: casks)
+ #expect(decided != nil)
+ #expect(await decided == checker.status(for: feedlessApp, preference: preference, casks: casks))
+ }
+ }
+ }
+ #expect(CannedProtocol.asked.withLock { $0 }.isEmpty)
+
+ #expect(recent.statusWithoutAsking(for: feedlessApp, preference: .automatic, casks: current) == .upToDate)
+ #expect(later.statusWithoutAsking(for: feedlessApp, preference: .automatic, casks: current) == .unsupported)
+ #expect(later.statusWithoutAsking(for: feedlessApp, preference: .developer, casks: outdated) == .unsupported)
+ #expect(later.statusWithoutAsking(for: fedApp, preference: .automatic, casks: outdated) == update)
+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .automatic, casks: current) == nil, "feed first")
+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .homebrew, casks: current) == .upToDate)
+ #expect(later.statusWithoutAsking(for: fedApp, preference: .homebrew, casks: current) == nil, "its feed answers")
+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .developer, casks: outdated) == nil)
+ }
+
+ @Test func namesTheCaskHomebrewHasNotCheckedForADay() {
+ let recent = checking(at: homebrewChecked + 60 * 60)
+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)
+ let current = [cask(checked: homebrewChecked)]
+ let unknown = [cask(checked: nil)]
+ let outdated = [cask(latest: "2.0", checked: homebrewChecked)]
+
+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: current)?.name == "example")
+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .homebrew, casks: current)?.name == "example")
+ #expect(recent.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: unknown)?.name == "example")
+ #expect(recent.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: current) == nil)
+ #expect(
+ later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: outdated) == nil,
+ "an update Homebrew knows of is an answer"
+ )
+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .developer, casks: current) == nil)
+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .appStore, casks: current) == nil)
+ #expect(later.caskNotCheckedRecently(for: fedApp, preference: .automatic, casks: current) == nil, "its feed")
+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: []) == nil)
+ }
+
@Test func aMacAppReadsNoIPhoneRecord() async {
let sold = InstalledApp(
url: URL(filePath: "/Applications/Notes Pro.app"),
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift
index 7e803643..36db28a0 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift
@@ -644,6 +644,28 @@ struct UpdateSourceTests {
#expect(CaskEvidence.cask(for: firefox, in: casks)?.name == "firefox@esr")
}
+ @Test func homebrewSaysAnAppIsUpToDateOnlyWithinADayOfItsLastCheck() {
+ let checked = Date(timeIntervalSince1970: 1_792_315_250)
+ let day = Homebrew.autoUpdateInterval
+ let unknown = HomebrewPackage(name: "example", kind: .cask, installedVersion: "1.0", latestVersion: "1.0")
+ let current = unknown.noting(lastUpdateCheck: checked)
+ let behind = HomebrewPackage(
+ name: "example", kind: .cask, installedVersion: "1.0", latestVersion: "2.0", isOutdated: true
+ )
+ let update = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)
+ let status = { (cask: HomebrewPackage, now: Date) in UpdateChecker.homebrewStatus(of: cask, at: now) }
+
+ #expect(day == 86_400)
+ #expect(status(current, checked + 60) == .upToDate)
+ #expect(status(current, checked + day - 1) == .upToDate)
+ #expect(status(current, checked + day) == nil, "Homebrew's own `find -newermt` wants it newer than a day")
+ #expect(status(current, checked + 4 * day) == nil)
+ #expect(status(unknown.noting(lastUpdateCheck: checked + day), checked) == .upToDate, "as for Homebrew")
+ #expect(status(unknown, checked) == nil, "no check known")
+ #expect(status(behind.noting(lastUpdateCheck: checked), checked + 4 * day) == update)
+ #expect(status(behind, checked) == update)
+ }
+
@Test func anUpdateHomebrewReportedHoldsOnlyWhileTheAppIsHomebrews() {
let homebrew = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew)
#expect(homebrew.holds(whileHomebrews: true))
diff --git a/Peel/Model/AppLibrary.swift b/Peel/Model/AppLibrary.swift
index 47a434ba..78054600 100644
--- a/Peel/Model/AppLibrary.swift
+++ b/Peel/Model/AppLibrary.swift
@@ -532,13 +532,12 @@ final class AppLibrary {
// Read here, where every caller passes. Settings promises that with this off, Peel contacts nothing on
// its own, so even Rescan on an app's page only rescans files.
guard defaults.isOn(SettingsKey.checksForAppUpdates, whenNeverSet: true) else { return }
+ // What Homebrew says lasts only a day after its last check, so its casks decide again in every round.
+ applyHomebrewStatuses()
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.
- // Peel's own copies are left to Sparkle, which checks the one running and is the only way it updates.
let wanted = targets.filter { app in
- guard let identifier = app.bundleIdentifier, !app.isPeelItself, !isIgnored(app),
- !appsInATrash.contains(app.id)
- else { return false }
+ guard let identifier = app.bundleIdentifier, 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 }
@@ -569,7 +568,6 @@ final class AppLibrary {
}
}
while case let (id, answer)? = await group.next() {
- let status = answer.status
// The update source changed since this round began, and the round that change started answers now.
guard updateRounds.answered(id, in: round) else {
group.cancelAll()
@@ -582,6 +580,10 @@ final class AppLibrary {
guard let app = asked[id], apps.contains(where: { $0.id == id && $0.isTheSameBuild(as: app) }) else {
continue
}
+ // Homebrew may have been read again while this answer was on its way: its casks decide where they can.
+ let status = casks == self.casks
+ ? answer.status
+ : checker.statusWithoutAsking(for: app, preference: preference, casks: self.casks) ?? answer.status
let kept = status.following(updateStatuses[id])
// Any write redraws the whole Applications list, so an answer that changes nothing is not written.
if updateStatuses[id] != kept {
@@ -792,20 +794,35 @@ final class AppLibrary {
UpdateMemoryStore.save(memory, to: defaults)
}
- /// Records an update for each app whose cask Homebrew marks outdated. Reading Homebrew costs no network
- /// request, so this doesn't wait for the update schedule, and Applications agrees with the Homebrew page.
- /// It applies only to an app with no answer of its own, or whose own check failed or had no feed to ask:
- /// an answer from the app's own feed wins.
+ /// Shows for each app Homebrew installed what a check would answer now without asking any server, from Homebrew's
+ /// casks and the app's own files. Reading Homebrew costs no network request, so this doesn't wait for the update
+ /// schedule, and Applications agrees with the Homebrew page. A check never asks Homebrew while the app's own feed
+ /// or the App Store is preferred: then only an update Homebrew knows of fills in for an app whose own check has
+ /// nothing, a failure, or no feed to ask.
private func applyHomebrewStatuses() {
- for (id, cask) in homebrewApps {
- let homebrew = UpdateChecker.homebrewStatus(of: cask)
- guard case .updateAvailable = homebrew else { continue }
- let known = updateStatuses[id]
- guard known == nil || known == .failed || known == .unsupported else { continue }
- updateStatuses[id] = homebrew
+ let preference = updateSource
+ for app in apps where homebrewApps[app.id] != nil && isAskedAboutUpdates(app) {
+ let known = updateStatuses[app.id]
+ let decided: UpdateStatus?
+ switch preference {
+ case .automatic, .homebrew:
+ decided = updateChecker.statusWithoutAsking(for: app, preference: preference, casks: casks)
+ case .developer, .appStore:
+ let homebrew = updateChecker.homebrewStatus(for: app, casks: casks)
+ let hasNoAnswer = known == nil || known == .failed || known == .unsupported
+ decided = hasNoAnswer && homebrew?.version != nil ? homebrew : nil
+ }
+ guard let decided, decided != known else { continue }
+ updateStatuses[app.id] = decided
}
}
+ /// Whether update checks ask about `app`. Never about Peel's own copies, which Sparkle keeps current, checking
+ /// the one running, nor about an app the user told Peel never to check or a copy in a Trash.
+ private func isAskedAboutUpdates(_ app: InstalledApp) -> Bool {
+ !app.isPeelItself && !isIgnored(app) && !appsInATrash.contains(app.id)
+ }
+
private func matchHomebrewApps() {
let casks = casks
homebrewApps = Dictionary(uniqueKeysWithValues: apps.compactMap { app in
diff --git a/PeelTests/AppLibraryTests.swift b/PeelTests/AppLibraryTests.swift
index 2d316e54..8734ede7 100644
--- a/PeelTests/AppLibraryTests.swift
+++ b/PeelTests/AppLibraryTests.swift
@@ -22,6 +22,44 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendabl
}
}
+/// Holds every request until the test lets it through, so a round of checks can be caught while it waits.
+private nonisolated final class HeldProtocol: URLProtocol, @unchecked Sendable {
+ static let body = Mutex(Data())
+ static let arrived = Mutex<AsyncStream<Void>.Continuation?>(nil)
+ static let gate = DispatchSemaphore(value: 0)
+
+ override class func canInit(with request: URLRequest) -> Bool { true }
+ override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
+ override func stopLoading() {}
+
+ override func startLoading() {
+ _ = Self.arrived.withLock { $0?.yield() }
+ _ = Self.gate.wait(timeout: .now() + 10)
+ guard let url = request.url,
+ let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: nil)
+ else { return }
+ client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+ client?.urlProtocol(self, didLoad: Self.body.withLock { $0 })
+ client?.urlProtocolDidFinishLoading(self)
+ }
+}
+
+private nonisolated final class TestClock: Sendable {
+ private let moment: Mutex<Date>
+
+ init(_ moment: Date) {
+ self.moment = Mutex(moment)
+ }
+
+ func now() -> Date {
+ moment.withLock { $0 }
+ }
+
+ func set(_ moment: Date) {
+ self.moment.withLock { $0 = moment }
+ }
+}
+
@Suite(.serialized) struct AppLibraryTests {
@Test func aRoundRemembersItsAnswerInTheStoresItWasGiven() async throws {
let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
@@ -84,16 +122,47 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendabl
return bundle
}
- private func library(with defaults: UserDefaults, notesIn folder: URL) -> AppLibrary {
+ private func library(
+ with defaults: UserDefaults,
+ notesIn folder: URL,
+ clock: TestClock? = nil,
+ answeredBy answering: URLProtocol.Type = AppcastProtocol.self
+ ) -> AppLibrary {
let configuration = URLSessionConfiguration.ephemeral
- configuration.protocolClasses = [AppcastProtocol.self]
+ configuration.protocolClasses = [answering]
+ let session = URLSession(configuration: configuration)
return AppLibrary(
defaults: defaults,
- updateChecker: UpdateChecker(session: URLSession(configuration: configuration)),
+ updateChecker: clock.map { clock in UpdateChecker(session: session, clock: { clock.now() }) }
+ ?? UpdateChecker(session: session),
releaseNotesStore: ReleaseNotesStore(url: folder.appending(path: "release-notes.json"))
)
}
+ private let homebrewChecked = Date(timeIntervalSince1970: 1_792_315_250)
+
+ private func caskApp(_ name: String, in folder: URL, feed: String? = nil) 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.\(name.lowercased())", "CFBundleName": name,
+ "CFBundlePackageType": "APPL", "CFBundleShortVersionString": "1.0", "CFBundleVersion": "100",
+ ]
+ info["SUFeedURL"] = feed
+ try PropertyListSerialization.data(fromPropertyList: info, format: .xml, options: 0)
+ .write(to: bundle.appending(path: "Contents/Info.plist"))
+ return bundle
+ }
+
+ private func cask(_ name: String, latest: String = "1.0", checked: Date?) -> HomebrewPackage {
+ HomebrewPackage(
+ name: name.lowercased(), kind: .cask, installedVersion: "1.0", latestVersion: latest,
+ isOutdated: latest != "1.0", appNames: ["\(name).app"]
+ ).noting(lastUpdateCheck: checked)
+ }
+
private func listing(_ version: String) -> Data {
Data(#"{"resultCount":1,"results":[{"kind":"mac-software","version":"\#(version)"}]}"#.utf8)
}
@@ -139,4 +208,107 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendabl
await library.recheck?.value
#expect(library.shownUpdateStatus(of: app)?.version == "1.1")
}
+
+ @Test func showsWhatHomebrewSaysOfAnAppWithNoFeedAsSoonAsHomebrewIsRead() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let bundle = try caskApp("Tool", in: folder)
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ let clock = TestClock(homebrewChecked + 60 * 60)
+ let library = library(with: made.defaults, notesIn: folder, clock: clock)
+
+ #expect(await library.reveal([bundle]))
+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })
+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.shownUpdateStatus(of: app) == .upToDate)
+
+ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")
+
+ clock.set(homebrewChecked + 2 * Homebrew.autoUpdateInterval)
+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.shownUpdateStatus(of: app) == .unsupported)
+ }
+
+ @Test func anUpdateHomebrewLearnsOfReplacesTheUpToDateItGaveBefore() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let bundle = try caskApp("Tool", in: folder)
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ let library = library(with: made.defaults, notesIn: folder, clock: TestClock(homebrewChecked + 60 * 60))
+
+ #expect(await library.reveal([bundle]))
+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })
+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)
+ await library.checkForUpdates([app], force: true)
+ #expect(library.shownUpdateStatus(of: app) == .upToDate)
+
+ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")
+ }
+
+ @Test func aRoundTakesBackHomebrewsUpToDateOnceItsCheckIsADayOld() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let bundle = try caskApp("Tool", in: folder)
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ let clock = TestClock(homebrewChecked + 60 * 60)
+ let library = library(with: made.defaults, notesIn: folder, clock: clock)
+
+ #expect(await library.reveal([bundle]))
+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })
+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)
+ await library.checkForUpdates([app], force: true)
+ #expect(library.shownUpdateStatus(of: app) == .upToDate)
+
+ clock.set(homebrewChecked + 2 * Homebrew.autoUpdateInterval)
+ await library.checkForUpdates([app])
+ #expect(library.shownUpdateStatus(of: app) == .unsupported, "not due, yet Homebrew can no longer tell")
+ }
+
+ @Test func anAppPeelNeverChecksGetsNothingFromHomebrew() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let bundle = try caskApp("Tool", in: folder)
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ let library = library(with: made.defaults, notesIn: folder, clock: TestClock(homebrewChecked + 60 * 60))
+
+ #expect(await library.reveal([bundle]))
+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })
+ library.setIgnored(true, for: app)
+ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.updateStatuses[app.id] == nil)
+ }
+
+ @Test func anAnswerThatCrossedANewReadingOfHomebrewGivesWayToItsCasks() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let bundle = try caskApp("Fed", in: folder, feed: "https://feed.example.com/appcast.xml")
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ HeldProtocol.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="100" sparkle:shortVersionString="1.0" /></item></channel></rss>"#.utf8)
+ }
+ let (arrivals, arrival) = AsyncStream.makeStream(of: Void.self)
+ HeldProtocol.arrived.withLock { $0 = arrival }
+ defer { HeldProtocol.arrived.withLock { $0 = nil } }
+ let clock = TestClock(homebrewChecked + 60 * 60)
+ let library = library(with: made.defaults, notesIn: folder, clock: clock, answeredBy: HeldProtocol.self)
+
+ #expect(await library.reveal([bundle]))
+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.fed" })
+ library.loadHomebrewCasks([cask("Fed", checked: homebrewChecked)], knowsItsOwnApps: true)
+ let round = Task { await library.checkForUpdates([app], force: true) }
+ for await _ in arrivals { break }
+ library.loadHomebrewCasks([cask("Fed", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)
+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")
+
+ HeldProtocol.gate.signal()
+ await round.value
+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0", "the feed was asked with what Homebrew said before")
+ }
}