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.

A path a cask writes in another case is the folder the scan found

Țugui Dragoș44886c883822
diff --git a/Packages/PeelCore/Sources/PeelCore/Homebrew/CaskEvidence.swift b/Packages/PeelCore/Sources/PeelCore/Homebrew/CaskEvidence.swift
index e99f6a1b..da91e717 100644
--- a/Packages/PeelCore/Sources/PeelCore/Homebrew/CaskEvidence.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Homebrew/CaskEvidence.swift
@@ -15,12 +15,12 @@ public struct CaskEvidence: Sendable, Hashable {
public static func evidence(for app: InstalledApp, casks: [HomebrewPackage], home: URL = .homeDirectory) -> CaskEvidence? {
guard let cask = cask(for: app, in: casks) else { return nil }
- var seen: Set<String> = []
+ var seen: Set<ItemKey> = []
let named = cask.leftoverPatterns.flatMap { expand($0, home: home) }
let emptied = cask.emptyFolderPatterns.flatMap { expand($0, home: home) }.filter(holdsNothing)
let items = (named + emptied).compactMap { url -> Item? in
- // A folder listed twice, such as with and without a trailing slash, becomes one item.
- guard seen.insert(PathPattern.comparablePath(of: url)).inserted else { return nil }
+ // A folder listed twice, with and without a slash at the end or in another case, becomes one item.
+ guard seen.insert(ItemKey(url)).inserted else { return nil }
return Item(url: url, isInLibrary: isInLibrary(url, home: home))
}
guard !items.isEmpty else { return nil }
diff --git a/Packages/PeelCore/Sources/PeelCore/Leftovers/Leftover.swift b/Packages/PeelCore/Sources/PeelCore/Leftovers/Leftover.swift
index db7f4409..3c12bf8f 100644
--- a/Packages/PeelCore/Sources/PeelCore/Leftovers/Leftover.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Leftovers/Leftover.swift
@@ -204,9 +204,10 @@ public struct LeftoverScan: Sendable {
/// Adds findings the scanner didn't see, keeping what it already knows about a path.
public func adding(_ extra: [Leftover]) -> LeftoverScan {
- // By path, not by URL: a folder written with a slash at the end is the same folder.
- let known = Set(leftovers.map { PathPattern.comparablePath(of: $0.url) })
- let merged = leftovers + extra.filter { !known.contains(PathPattern.comparablePath(of: $0.url)) }
+ // By what each item is on the disk, not by its spelling: a cask can write a folder in another case, or with
+ // a slash at the end, and it is still the folder the scan found.
+ let known = Set(leftovers.map { ItemKey($0.url) })
+ let merged = leftovers + extra.filter { !known.contains(ItemKey($0.url)) }
return LeftoverScan(
leftovers: merged.sorted(by: Leftover.comesBefore),
unreadableLocations: unreadableLocations,
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/FileIdentity.swift b/Packages/PeelCore/Sources/PeelCore/Support/FileIdentity.swift
index dad32e3c..97a9249a 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/FileIdentity.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/FileIdentity.swift
@@ -55,3 +55,14 @@ public struct FileIdentity: Sendable, Hashable {
time.tv_sec &* 1_000_000_000 &+ time.tv_nsec
}
}
+
+/// What an item is on the disk: its device and inode while it is there, and its path otherwise. Two spellings of
+/// one path, another case on a disk that folds it or a slash at the end, name one item.
+enum ItemKey: Hashable {
+ case object(FileIdentity.Link)
+ case path(String)
+
+ init(_ url: URL) {
+ self = FileIdentity.Link.of(url).map(ItemKey.object) ?? .path(PathPattern.comparablePath(of: url))
+ }
+}
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/CaskEvidenceTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/CaskEvidenceTests.swift
index 71e64608..eb1edb6a 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/CaskEvidenceTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/CaskEvidenceTests.swift
@@ -201,6 +201,20 @@ struct CaskEvidenceTests {
#expect(found["Word Templates"]?.kind == .elsewhere, "a folder in Documents was called something it is not")
}
+ /// A cask can write one path two ways, and a Mac's disk folds case, so both name one folder: it is one item.
+ @Test func aPathACaskWritesTwoWaysIsOneItem() throws {
+ let directory = try TemporaryDirectory()
+ try directory.directory("Library/Group Containers/org.example.Viewer")
+ let cask = HomebrewPackage(name: "viewer", kind: .cask, appNames: ["Viewer.app"], leftoverPatterns: [
+ "~/Library/Group Containers/org.example.Viewer", "~/Library/Group Containers/org.example.viewer",
+ ])
+ let app = InstalledApp(url: URL(filePath: "/Applications/Viewer.app"), bundleIdentifier: "org.example.Viewer", name: "Viewer")
+
+ let evidence = try #require(CaskEvidence.evidence(for: app, casks: [cask], home: directory.url))
+
+ #expect(evidence.items.count == 1)
+ }
+
/// What a cask names is a folder like any other: a repository inside takes the checkmark away here as well.
@Test func aCaskPathGoesThroughTheSameHoldBacks() async throws {
let directory = try TemporaryDirectory()
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/LeftoverScannerTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/LeftoverScannerTests.swift
index d8912c75..e832a82f 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/LeftoverScannerTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/LeftoverScannerTests.swift
@@ -683,6 +683,27 @@ struct LeftoverScannerTests {
#expect(folder.match.heldBack == .holdsKeys)
}
+ /// A cask can name a folder in another case than the disk spells it. It is the folder the scan already found,
+ /// held back as a name at the top of a Library is, so it is listed once, as the scan found it.
+ @Test func aCaskPathInAnotherCaseIsTheFolderTheScanFound() async throws {
+ let directory = try TemporaryDirectory()
+ try directory.file("home/Library/Tunewell/settings.db", bytes: 100)
+ let tunewell = InstalledApp(url: URL(filePath: "/Applications/Tunewell.app"), bundleIdentifier: "net.example.tunewell", name: "Tunewell")
+ let cask = HomebrewPackage(name: "tunewell", kind: .cask, appNames: ["Tunewell.app"], leftoverPatterns: ["~/Library/TUNEWELL"])
+ let environment = environment(in: directory)
+ let scan = await LeftoverScanner(environment: environment).scan(tunewell, installedApps: [tunewell])
+ let evidence = try #require(CaskEvidence.evidence(for: tunewell, casks: [cask], home: environment.homeDirectory))
+ let fromTheCask = await Uninstallation.caskLeftovers(
+ evidence, app: tunewell, exclusions: .none, matcher: LeftoverMatcher(app: tunewell, installedApps: [tunewell]),
+ environment: environment
+ )
+
+ let merged = scan.adding(fromTheCask)
+
+ #expect(merged.leftovers.map(\.url.lastPathComponent) == ["Tunewell"])
+ #expect(merged.leftovers.first?.match.heldBack == .namedLikeTheApp)
+ }
+
/// Plug-ins that declare the app's identifier are found in the user's Library and the system's, including inside
/// a vendor's own folder.
@Test func findsThePlugInsAnAppInstalled() async throws {