Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.
Swift cache-cleanercleanerclideveloper-toolsdisk-cleanupdisk-spaceduplicate-finderhomebrewliquid-glassmac-cleanermacosmacos-appmacos-golden-gatemacos-tahoemacos-tweaksswiftswiftuiterminal-themesuninstalluninstaller
Copies with other Finder tags or another resource fork are not duplicates
Țugui Dragoș3af088a405df
diff --git a/Packages/PeelCore/Sources/PeelCore/Duplicates/DuplicateFinder.swift b/Packages/PeelCore/Sources/PeelCore/Duplicates/DuplicateFinder.swiftindex 37d635b6..e0bb0707 100644--- a/Packages/PeelCore/Sources/PeelCore/Duplicates/DuplicateFinder.swift+++ b/Packages/PeelCore/Sources/PeelCore/Duplicates/DuplicateFinder.swift@@ -124,6 +124,7 @@ public struct DuplicateFinder: Sendable {private struct ContentKey: Hashable {let size: Int64let digest: ContentDigest+ let extras: [UInt8]}private final class UnreadableLocations {@@ -234,9 +235,12 @@ public struct DuplicateFinder: Sendable {}private static func grouped(_ hashed: [HashedCandidate]) -> [[HashedCandidate]] {- Dictionary(grouping: hashed) { ContentKey(size: $0.item.identity.size, digest: $0.digest) }- .values- .filter { $0.count > 1 }+ let keyed = hashed.compactMap { candidate in+ FileExtras.of(candidate.item.url).map { extras in+ (candidate, ContentKey(size: candidate.item.identity.size, digest: candidate.digest, extras: extras))+ }+ }+ return Dictionary(grouping: keyed, by: \.1).values.filter { $0.count > 1 }.map { $0.map(\.0) }}private func makeGroup(_ members: [HashedCandidate]) -> DuplicateGroup {diff --git a/Packages/PeelCore/Sources/PeelCore/Duplicates/FileExtras.swift b/Packages/PeelCore/Sources/PeelCore/Duplicates/FileExtras.swiftnew file mode 100644index 00000000..dbbb32fb--- /dev/null+++ b/Packages/PeelCore/Sources/PeelCore/Duplicates/FileExtras.swift@@ -0,0 +1,25 @@+import CryptoKit+import Darwin+import Foundation++/// What a copy carries besides its bytes, which moving it to the Trash takes away from where it was: its Finder tags+/// and its resource fork. Copies that differ in either are not duplicates.+enum FileExtras {+ /// The tags, in order, and a digest of the resource fork, as bytes to compare. Nil when the fork is there and+ /// cannot be read, since two copies are then not known to be alike.+ static func of(_ url: URL) -> [UInt8]? {+ var bytes: [UInt8] = []+ for tag in ((try? url.resourceValues(forKeys: [.tagNamesKey]).tagNames) ?? []).sorted() {+ bytes += Array(tag.utf8) + [0]+ }+ let path = url.path(percentEncoded: false)+ let size = getxattr(path, resourceFork, nil, 0, 0, XATTR_NOFOLLOW)+ guard size > 0 else { return bytes }+ var fork = [UInt8](repeating: 0, count: size)+ guard getxattr(path, resourceFork, &fork, size, 0, XATTR_NOFOLLOW) == size else { return nil }+ return bytes + [1] + Array(SHA256.hash(data: fork))+ }++ /// `XATTR_RESOURCEFORK_NAME` in `<sys/xattr.h>`.+ private static let resourceFork = "com.apple.ResourceFork"+}diff --git a/Packages/PeelCore/Sources/PeelCore/Duplicates/FolderDuplicates.swift b/Packages/PeelCore/Sources/PeelCore/Duplicates/FolderDuplicates.swiftindex 198a7ad5..cdfbbf0e 100644--- a/Packages/PeelCore/Sources/PeelCore/Duplicates/FolderDuplicates.swift+++ b/Packages/PeelCore/Sources/PeelCore/Duplicates/FolderDuplicates.swift@@ -254,9 +254,13 @@ struct FolderDuplicates: Sendable {private func content(of folder: Folder, using contents: [FileIdentity: ContentDigest]) -> SHA256.Digest? {var hasher = SHA256()+ guard let extras = FileExtras.of(folder.url) else { return nil }+ hasher.update(data: Self.number(extras.count) + extras)for (name, identity) in folder.files.sorted(by: { $0.name < $1.name }) {- guard let digest = contents[identity] else { return nil }- hasher.update(data: Self.field("f", name, digest.bytes))+ guard let digest = contents[identity], let extras = FileExtras.of(folder.url.appending(path: name)) else {+ return nil+ }+ hasher.update(data: Self.field("f", name, digest.bytes + Self.number(extras.count) + extras))}for (name, child) in folder.children.sorted(by: { $0.name < $1.name }) {guard let digest = content(of: child, using: contents) else { return nil }diff --git a/Packages/PeelCore/Tests/PeelCoreTests/DuplicateFinderTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/DuplicateFinderTests.swiftindex 37a729c4..2be02c35 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/DuplicateFinderTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/DuplicateFinderTests.swift@@ -92,6 +92,36 @@ struct DuplicateFinderTests {#expect(result.suggestedSelection.map(\.lastPathComponent).sorted() == ["note.txt", "photo copy.jpg"])}+ /// Moving a copy takes its Finder tags and its resource fork with it, so copies that differ in either are not+ /// duplicates, on their own or inside folders.+ @Test func copiesWithOtherTagsOrAnotherResourceForkAreNotDuplicates() async throws {+ let directory = try TemporaryDirectory()+ let contract = randomData(count: 4_000)+ try directory.file("home/Documents/Contract.pdf", contents: contract)+ var tagged = try directory.file("home/Desktop/Contract.pdf", contents: contract)+ try directory.file("home/Downloads/Contract.pdf", contents: contract)+ let sound = randomData(count: 4_000)+ let forked = try directory.file("home/Music/sound.aiff", contents: sound)+ try directory.file("home/Documents/sound.aiff", contents: sound)+ let notes = randomData(count: 4_000)+ try directory.file("home/Projects/a/notes.txt", contents: notes)+ var taggedInside = try directory.file("home/Projects/b/notes.txt", contents: notes)+ var red = URLResourceValues()+ red.tagNames = ["Red"]+ try tagged.setResourceValues(red)+ try taggedInside.setResourceValues(red)+ let fork = Data(randomData(count: 64))+ let written = fork.withUnsafeBytes {+ setxattr(forked.path(percentEncoded: false), "com.apple.ResourceFork", $0.baseAddress, fork.count, 0, 0)+ }+ #expect(written == 0)++ let result = try await scan(directory)++ #expect(Set(names(result)) == [["Documents/Contract.pdf", "Downloads/Contract.pdf"]])+ #expect(result.folderGroups.isEmpty)+ }+/// Duplicates scans again only when asked, so what is excluded after a scan is taken out of it: the copy/// leaves its group, a group left with one copy goes, and a group that lost its kept copy keeps the next one.@Test func whatIsExcludedAfterTheScanLeavesIt() async throws {