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.

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.swift
index 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: Int64
let 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.swift
new file mode 100644
index 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.swift
index 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.swift
index 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 {