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.

Bring nothing of Peel's back once Remove Peel has taken its folder

Țugui Dragoșb282f3495855
diff --git a/Packages/PeelCore/Sources/PeelCore/Apps/AppFolders.swift b/Packages/PeelCore/Sources/PeelCore/Apps/AppFolders.swift
index db9dd6f8..cf26702b 100644
--- a/Packages/PeelCore/Sources/PeelCore/Apps/AppFolders.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Apps/AppFolders.swift
@@ -38,7 +38,7 @@ public struct AppFolders: Sendable {
/// The folders chosen, or nil when the file is there and cannot be read: the apps in them are then not known.
public func load() -> [URL]? {
- FileLock.whileHeld(beside: url) { url.isMissing ? [] : read() }
+ FileLock.whileReading(beside: url) { url.isMissing ? [] : read() }
}
/// Adds `folders`. False when they could not be saved, or when the file is there and cannot be read, since
@@ -114,9 +114,7 @@ public struct AppFolders: Sendable {
else { return false }
edit(&paths)
guard let data = try? JSONEncoder().encode(paths) else { return false }
- let folder = url.deletingLastPathComponent()
- try? FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
- return (try? data.write(to: url, options: .atomic)) != nil
+ return (try? PeelFolder.write(data, to: url)) != nil
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Apps/AppMemory.swift b/Packages/PeelCore/Sources/PeelCore/Apps/AppMemory.swift
index bcdc74d1..291e36ea 100644
--- a/Packages/PeelCore/Sources/PeelCore/Apps/AppMemory.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Apps/AppMemory.swift
@@ -148,7 +148,6 @@ public struct AppMemory: Sendable {
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
encoder.dateEncodingStrategy = .iso8601
guard let data = try? encoder.encode(apps) else { return }
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- try? data.write(to: url, options: .atomic)
+ try? PeelFolder.write(data, to: url)
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Apps/DockTiles.swift b/Packages/PeelCore/Sources/PeelCore/Apps/DockTiles.swift
index 1224536d..8f10fc0b 100644
--- a/Packages/PeelCore/Sources/PeelCore/Apps/DockTiles.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Apps/DockTiles.swift
@@ -173,7 +173,7 @@ public struct DockTiles: Sendable {
/// and restarts the Dock once. A tile goes back beside the tiles it sat between, so apps taken out together come
/// back where they were, together or one at a time in any order, even after the person added other tiles.
public func putBack(_ apps: [URL]) async {
- guard let remembered = FileLock.whileHeld(beside: memory, { read() }) else { return }
+ guard let remembered = FileLock.whileReading(beside: memory, { read() }) else { return }
let removed = Set(apps.map(key)).compactMap { key in remembered[key].map { (key: key, entries: $0) } }
var settled: [String: Set<DockList>] = [:]
var changed = false
@@ -290,10 +290,7 @@ public struct DockTiles: Sendable {
guard var entries = read() ?? (memory.isMissing ? [:] : nil) else { return false }
edit(&entries)
guard let data = try? JSONEncoder().encode(entries) else { return false }
- try? FileManager.default.createDirectory(
- at: memory.deletingLastPathComponent(), withIntermediateDirectories: true
- )
- return (try? data.write(to: memory, options: .atomic)) != nil
+ return (try? PeelFolder.write(data, to: memory)) != nil
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Duplicates/DigestMemory.swift b/Packages/PeelCore/Sources/PeelCore/Duplicates/DigestMemory.swift
index a7136ef8..e70d1e44 100644
--- a/Packages/PeelCore/Sources/PeelCore/Duplicates/DigestMemory.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Duplicates/DigestMemory.swift
@@ -28,7 +28,7 @@ public struct DigestMemory: Sendable {
}
func load(now: Date = .now) -> KnownDigests {
- KnownDigests(entries: FileLock.whileHeld(beside: url) { read() }, day: Self.day(of: now))
+ KnownDigests(entries: FileLock.whileReading(beside: url) { read() }, day: Self.day(of: now))
}
/// Merges what this scan learned into the file's current contents instead of replacing them, since the app
@@ -121,8 +121,7 @@ public struct DigestMemory: Sendable {
bytes += entry.full?.bytes ?? none
}
bytes += ContentDigest(SHA256.hash(data: bytes)).bytes
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- try? Data(bytes).write(to: url, options: .atomic)
+ try? PeelFolder.write(Data(bytes), to: url)
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Homebrew/HomebrewChoice.swift b/Packages/PeelCore/Sources/PeelCore/Homebrew/HomebrewChoice.swift
index 2a72e034..fb504d8d 100644
--- a/Packages/PeelCore/Sources/PeelCore/Homebrew/HomebrewChoice.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Homebrew/HomebrewChoice.swift
@@ -50,8 +50,7 @@ public struct HomebrewChoice: Sendable {
@discardableResult
public func save(_ brew: URL?) -> Bool {
guard let data = try? JSONEncoder().encode(brew?.path(percentEncoded: false)) else { return false }
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- return (try? data.write(to: url, options: .atomic)) != nil
+ return (try? PeelFolder.write(data, to: url)) != nil
}
/// Why `brew` cannot be the one Peel runs, or nil. A link is followed, since the file it leads to is what runs.
diff --git a/Packages/PeelCore/Sources/PeelCore/Orphans/LeftForAnAdministrator.swift b/Packages/PeelCore/Sources/PeelCore/Orphans/LeftForAnAdministrator.swift
index bb31a0ab..b3e9763b 100644
--- a/Packages/PeelCore/Sources/PeelCore/Orphans/LeftForAnAdministrator.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Orphans/LeftForAnAdministrator.swift
@@ -97,8 +97,7 @@ public struct LeftForAnAdministrator: Sendable {
let encoder = JSONEncoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
guard let data = try? encoder.encode(records) else { return }
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- try? data.write(to: url, options: .atomic)
+ try? PeelFolder.write(data, to: url)
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Orphans/OrphanOwners.swift b/Packages/PeelCore/Sources/PeelCore/Orphans/OrphanOwners.swift
index 6444830b..3e8323fe 100644
--- a/Packages/PeelCore/Sources/PeelCore/Orphans/OrphanOwners.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Orphans/OrphanOwners.swift
@@ -49,11 +49,7 @@ public struct OrphanOwners: Sendable {
guard var owners = read() ?? (url.isMissing ? [:] : nil) else { return false }
edit(&owners)
guard let data = try? JSONEncoder().encode(owners) else { return false }
- try? FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- return (try? data.write(to: url, options: .atomic)) != nil
+ return (try? PeelFolder.write(data, to: url)) != nil
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/PreferenceBackup.swift b/Packages/PeelCore/Sources/PeelCore/Removal/PreferenceBackup.swift
index 1e2f4938..a81999b9 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/PreferenceBackup.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/PreferenceBackup.swift
@@ -73,8 +73,8 @@ public enum PreferenceBackup {
// shape `copies` reads back, which rules out a `/` and a space.
guard
Identifier.isValid(bundleIdentifier),
- (try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)) != nil,
- let folder = newFolder(for: bundleIdentifier, in: directory)
+ let folder = PeelFolder.whileOpen(making: directory, { newFolder(for: bundleIdentifier, in: directory) })
+ ?? nil
else { return .failed }
for domain in domains {
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift b/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
index 90689459..5749f891 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
@@ -83,7 +83,7 @@ public actor RefusalLog {
/// The records, with what is still to be said about the file (`note`). Nil records when the file could not be
/// read: what was refused is then not known, which is not the same as nothing refused.
public func load() -> (records: [RefusalRecord]?, problem: RefusalLogProblem?) {
- FileLock.whileHeld(beside: url) {
+ FileLock.whileReading(beside: url) {
let records = current()
return (records, problem)
}
@@ -128,7 +128,7 @@ public actor RefusalLog {
/// Whether nothing is left to forget: no refusal written down, no file that can't be read, and no copy set aside.
public func holdsNothing() -> Bool {
- FileLock.whileHeld(beside: url) { current() == [] && DamagedFile.copies(of: url) == [] }
+ FileLock.whileReading(beside: url) { current() == [] && DamagedFile.copies(of: url) == [] }
}
/// Moves the file and the copies set aside to the Trash, so every refusal is forgotten and can still be taken back
@@ -216,8 +216,7 @@ public actor RefusalLog {
records, within: readLimit, batch: { $0.batch ?? $0.id }, date: \.date, keeping: protected,
encode: { try encoder.encode($0) }
) else { return false }
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- guard (try? fitted.data.write(to: url, options: .atomic)) != nil else { return false }
+ guard (try? PeelFolder.write(fitted.data, to: url)) != nil else { return false }
// Every writer takes the lock, so the file here is the one just written.
kept = FileIdentity.of(url).map { ($0, fitted.records) }
return true
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalJournal.swift b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalJournal.swift
index feff30a2..d3e34daf 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalJournal.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalJournal.swift
@@ -111,8 +111,10 @@ struct RemovalJournal: Sendable {
.compactMap { item in (try? Self.encoder.encode(entry(item))) }
guard !lines.isEmpty else { return }
FileLock.whileHeld(beside: url) {
- let descriptor = open(journal, O_RDWR | O_APPEND | O_CREAT | O_CLOEXEC, 0o600)
- guard descriptor >= 0 else { return }
+ let opened = PeelFolder.whileOpen(making: url.deletingLastPathComponent()) {
+ open(journal, O_RDWR | O_APPEND | O_CREAT | O_CLOEXEC, 0o600)
+ }
+ guard let descriptor = opened, descriptor >= 0 else { return }
defer { close(descriptor) }
var data = Data()
// A line cut short, as when the disk filled up, is ended first, so the next line is not read as part
@@ -183,7 +185,7 @@ struct RemovalJournal: Sendable {
private func write(_ entries: [Entry]) {
let data = entries.compactMap { try? Self.encoder.encode($0) }.reduce(into: Data()) { $0 += $1 + Data("\n".utf8) }
- try? data.write(to: url, options: .atomic)
+ try? PeelFolder.write(data, to: url)
}
private func read() -> [Entry] {
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalLog.swift b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalLog.swift
index 1aa96e2e..4417c487 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalLog.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalLog.swift
@@ -61,7 +61,7 @@ public actor RemovalLog {
/// Reads the log. The read takes the lock too, because reading a damaged file sets it aside and writes back
/// the rows that could be read.
public func load() -> RemovalLogOutcome {
- whileNoOtherProcessWrites { outcome(current()) }
+ FileLock.whileReading(beside: url) { outcome(current()) }
}
/// The places in the Trash where an item Peel moved still is, whichever process moved it: what History records
@@ -271,12 +271,7 @@ public actor RemovalLog {
Self.trimmed(records, keeping: protected), within: readLimit, batch: \.batch, date: \.date,
keeping: protected, encode: { try encoder.encode($0) }
)
- try FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- // `.atomic` writes a temporary file and renames it, so a crash leaves either the old log or the new one.
- try fitted.data.write(to: url, options: .atomic)
+ try PeelFolder.write(fitted.data, to: url)
// Every writer takes the lock, so the file here is the one just written.
kept = FileIdentity.of(url).map { ($0, fitted.records) }
if fitted.records.count < records.count {
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalTotals.swift b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalTotals.swift
index 85088096..d6cc1d75 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/RemovalTotals.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/RemovalTotals.swift
@@ -85,7 +85,7 @@ public struct RemovalTotals: Sendable, Equatable, Codable {
guard var totals = stored(at: url) ?? startedAgain(at: url) else { return false }
change(&totals)
guard let data = try? JSONEncoder().encode(totals) else { return false }
- return (try? data.write(to: url, options: .atomic)) != nil
+ return (try? PeelFolder.write(data, to: url)) != nil
}
/// The totals at `url`: none yet when there is no file, and nil when the file cannot be read as the totals.
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/SelfRemoval.swift b/Packages/PeelCore/Sources/PeelCore/Removal/SelfRemoval.swift
index d59e8df7..5937075a 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/SelfRemoval.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/SelfRemoval.swift
@@ -167,7 +167,7 @@ public enum SelfRemoval {
/// Moves `app` to the Trash, then the rest of `urls` once it has moved, and then `folder`, all but the Terminal
/// settings the person's `.zshrc` and `~/.ssh/config` read, which go on working without Peel. `record` writes
/// History into `folder` first, with `movedFirst`, what the helper moved before it went, so the record goes with
- /// it. Nothing is written after that, or the folder would be created again.
+ /// it. Nothing is written after that (`PeelFolder.take`), or the folder would be created again.
public static func move(
_ urls: [URL],
app: URL,
@@ -185,10 +185,9 @@ public enum SelfRemoval {
)
result.trashed.insert(contentsOf: movedFirst, at: 0)
await record(result)
- guard
- result.trashed.contains(where: { $0.originalURL == app }),
- FileManager.default.fileExists(atPath: folder.path(percentEncoded: false))
- else { return result }
+ guard result.trashed.contains(where: { $0.originalURL == app }) else { return result }
+ PeelFolder.take(folder)
+ guard FileManager.default.fileExists(atPath: folder.path(percentEncoded: false)) else { return result }
let terminal = ShellFile.url(in: folder).deletingLastPathComponent()
let moved = terminal.isMissing
? await service.trash([folder]) : await movingTogether(folder, leaving: terminal, using: service)
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/Exclusions.swift b/Packages/PeelCore/Sources/PeelCore/Support/Exclusions.swift
index 9a0cf875..fd5c332a 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/Exclusions.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/Exclusions.swift
@@ -405,15 +405,6 @@ public struct ExclusionStore: Sendable {
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
guard let data = try? encoder.encode(exclusions) else { return false }
if read().isUnreadable, DamagedFile.setAside(url) == nil { return false }
- do {
- try FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- try data.write(to: url, options: .atomic)
- return true
- } catch {
- return false
- }
+ return (try? PeelFolder.write(data, to: url)) != nil
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/FileLock.swift b/Packages/PeelCore/Sources/PeelCore/Support/FileLock.swift
index cfcfc974..6f243381 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/FileLock.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/FileLock.swift
@@ -19,6 +19,12 @@ enum FileLock {
}
}
+ /// The same, for a read: with no folder there is nothing to read or to wait for, and a read makes nothing.
+ static func whileReading<T>(beside url: URL, _ read: () -> T) -> T {
+ guard url.deletingLastPathComponent().isThere else { return read() }
+ return whileHeld(beside: url, read)
+ }
+
/// The same, for a change that has to wait for other work, such as a move to the Trash.
static func whileHeld<T>(beside url: URL, waitingFor change: () async -> T) async -> T {
guard let descriptor = openLock(beside: url) else { return await change() }
@@ -31,9 +37,10 @@ enum FileLock {
}
private static func openLock(beside url: URL) -> Int32? {
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- let descriptor = open(url.path(percentEncoded: false) + ".lock", O_CREAT | O_RDWR | O_CLOEXEC, 0o600)
- return descriptor >= 0 ? descriptor : nil
+ let descriptor = PeelFolder.whileOpen(making: url.deletingLastPathComponent()) {
+ open(url.path(percentEncoded: false) + ".lock", O_CREAT | O_RDWR | O_CLOEXEC, 0o600)
+ }
+ return descriptor.flatMap { $0 >= 0 ? $0 : nil }
}
private static func lock(_ descriptor: Int32) -> Bool {
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/PeelFolder.swift b/Packages/PeelCore/Sources/PeelCore/Support/PeelFolder.swift
index f13bd8fc..ea35311e 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/PeelFolder.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/PeelFolder.swift
@@ -1,4 +1,6 @@
public import Foundation
+import PeelPrivileged
+import Synchronization
/// Where Peel keeps what it writes: History and its record of refusals, the exclusions, the apps and teams it
/// has seen, Saved Settings, and the file digests Duplicates remembers.
@@ -10,4 +12,33 @@ public enum PeelFolder {
static func url(inHome home: URL) -> URL {
home.appending(path: "Library/Application Support/Peel", directoryHint: .isDirectory)
}
+
+ /// The folders Remove Peel has taken. Holding this lock across each write lets a write under way finish first.
+ private static let taken = Mutex<[String]>([])
+
+ /// Says that Remove Peel takes `folder` now. Nothing is written in it after this, since a scan that ends later
+ /// would otherwise bring the folder back.
+ static func take(_ folder: URL) {
+ taken.withLock { $0.append(PathPattern.comparablePath(of: folder)) }
+ }
+
+ /// Makes `folder` and runs `write`, which puts something in it. Nil, doing neither, once `folder` has been taken.
+ static func whileOpen<Answer: Sendable>(making folder: URL, _ write: () throws -> Answer) rethrows -> Answer? {
+ try taken.withLock { taken in
+ guard !taken.contains(where: {
+ PathComponents.isPath(PathPattern.comparablePath(of: folder), atOrInside: $0)
+ }) else { return nil }
+ try? FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+ return try write()
+ }
+ }
+
+ /// Writes one of Peel's files whole: it goes to a temporary file that is then renamed, so a crash leaves either
+ /// the old file or the new one.
+ static func write(_ data: Data, to file: URL) throws {
+ let wrote: Void? = try whileOpen(making: file.deletingLastPathComponent()) {
+ try data.write(to: file, options: .atomic)
+ }
+ guard wrote != nil else { throw CocoaError(.fileWriteNoPermission) }
+ }
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/ScanRun.swift b/Packages/PeelCore/Sources/PeelCore/Support/ScanRun.swift
index 49a14112..e2e83952 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/ScanRun.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/ScanRun.swift
@@ -22,8 +22,11 @@ public final class ScanRun {
public private(set) var itemsRead = 0
@ObservationIgnored private var newest = 0
@ObservationIgnored private var stopNewest: (@Sendable () -> Void)?
+ @ObservationIgnored private let others: RunningScans
- public init() {}
+ public init(among others: RunningScans = .shared) {
+ self.others = others
+ }
/// Runs `work` as the page's scan and returns its answer, or nil when it was stopped, replaced by another
/// scan, or canceled with its caller.
@@ -37,6 +40,7 @@ public final class ScanRun {
wasStopped = false
isAbandoned = false
isRunning = true
+ others.began(self)
itemsRead = 0
let reading = Task { [weak self] in
while !Task.isCancelled {
@@ -58,6 +62,7 @@ public final class ScanRun {
guard asked == newest else { return nil }
stopNewest = nil
isRunning = false
+ others.ended(self)
isAbandoned = false
return task.isCancelled ? nil : answer
}
@@ -85,7 +90,29 @@ public final class ScanRun {
stopNewest = nil
newest += 1
isRunning = false
+ others.ended(self)
isAbandoned = false
wasStopped = true
}
}
+
+/// The scans running on every page, so that Remove Peel can stop them all.
+@MainActor
+public final class RunningScans {
+ public static let shared = RunningScans()
+ private var scans: [ObjectIdentifier: ScanRun] = [:]
+
+ public init() {}
+
+ fileprivate func began(_ scan: ScanRun) {
+ scans[ObjectIdentifier(scan)] = scan
+ }
+
+ fileprivate func ended(_ scan: ScanRun) {
+ scans[ObjectIdentifier(scan)] = nil
+ }
+
+ func stopEvery() {
+ Array(scans.values).forEach { $0.stop() }
+ }
+}
diff --git a/Packages/PeelCore/Sources/PeelCore/Support/StandingWork.swift b/Packages/PeelCore/Sources/PeelCore/Support/StandingWork.swift
index 0fbd02e9..636e765b 100644
--- a/Packages/PeelCore/Sources/PeelCore/Support/StandingWork.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Support/StandingWork.swift
@@ -8,21 +8,30 @@ public import Observation
public final class StandingWork {
@ObservationIgnored private var work: [@MainActor () async -> Void] = []
@ObservationIgnored private var running: [Task<Void, Never>] = []
+ @ObservationIgnored private var stoppedWithIt: [@MainActor () -> Void] = []
+ @ObservationIgnored private let scans: RunningScans
- public init() {}
+ public init(scans: RunningScans = .shared) {
+ self.scans = scans
+ }
/// Starts each piece of work. Only the first call starts anything: a window built again calls it again.
- public func start(_ work: [@MainActor () async -> Void]) {
+ /// `stoppingWithIt` is work a person started that a pause stops as View > Stop does, and doesn't start again.
+ public func start(_ work: [@MainActor () async -> Void], stoppingWithIt: [@MainActor () -> Void] = []) {
guard self.work.isEmpty else { return }
self.work = work
+ self.stoppedWithIt = stoppingWithIt
resume()
}
- /// Stops every piece. Each ends at its next wait, since a piece waits on something that ends when its task is
- /// canceled: a stream of changes, a notification, or a sleep.
+ /// Stops every piece, every page's scan, and what `start` was given to stop with them. Each piece ends at its
+ /// next wait, since a piece waits on something that ends when its task is canceled: a stream of changes, a
+ /// notification, or a sleep.
public func pause() {
running.forEach { $0.cancel() }
running = []
+ scans.stopEvery()
+ stoppedWithIt.forEach { $0() }
}
/// Starts every piece again after a pause.
diff --git a/Packages/PeelCore/Sources/PeelCore/Terminal/SSHFile.swift b/Packages/PeelCore/Sources/PeelCore/Terminal/SSHFile.swift
index 3a312470..9d7c684a 100644
--- a/Packages/PeelCore/Sources/PeelCore/Terminal/SSHFile.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Terminal/SSHFile.swift
@@ -36,7 +36,7 @@ public enum SSHFile {
guard let data = BoundedRead.data(at: url, maximum: maximumBytes),
let updated = update(of: String(decoding: data, as: UTF8.self))
else { return }
- try? Data(updated.utf8).write(to: url, options: .atomic)
+ try? PeelFolder.write(Data(updated.utf8), to: url)
}
public static func settings(in contents: String) -> Set<SSHSetting> {
@@ -55,16 +55,7 @@ public enum SSHFile {
}
public static func write(_ settings: Set<SSHSetting>, to url: URL) -> Bool {
- do {
- try FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- try Data(contents(of: settings).utf8).write(to: url, options: .atomic)
- return true
- } catch {
- return false
- }
+ (try? PeelFolder.write(Data(contents(of: settings).utf8), to: url)) != nil
}
/// The lines that make ssh read the file. `Match all` first, so they apply to every server even after a `Host`
diff --git a/Packages/PeelCore/Sources/PeelCore/Terminal/ShellFile.swift b/Packages/PeelCore/Sources/PeelCore/Terminal/ShellFile.swift
index 8c36f335..0f0fdc5f 100644
--- a/Packages/PeelCore/Sources/PeelCore/Terminal/ShellFile.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Terminal/ShellFile.swift
@@ -51,16 +51,7 @@ public enum ShellFile {
}
public static func write(_ choices: Choices, to url: URL) -> Bool {
- do {
- try FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- try Data(contents(of: choices).utf8).write(to: url, options: .atomic)
- return true
- } catch {
- return false
- }
+ (try? PeelFolder.write(Data(contents(of: choices).utf8), to: url)) != nil
}
public static func line(sourcing url: URL, home: URL) -> String {
diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/ReleaseNotesMemory.swift b/Packages/PeelCore/Sources/PeelCore/Updates/ReleaseNotesMemory.swift
index 36da3b38..a07e97b5 100644
--- a/Packages/PeelCore/Sources/PeelCore/Updates/ReleaseNotesMemory.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Updates/ReleaseNotesMemory.swift
@@ -95,7 +95,6 @@ public struct ReleaseNotesStore: Sendable {
@concurrent
public func save(_ memory: ReleaseNotesMemory) async {
guard let data = try? JSONEncoder().encode(memory) else { return }
- try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
- try? data.write(to: url, options: .atomic)
+ try? PeelFolder.write(data, to: url)
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/TeamRegistry.swift b/Packages/PeelCore/Sources/PeelCore/Updates/TeamRegistry.swift
index f8a252aa..9c2815cb 100644
--- a/Packages/PeelCore/Sources/PeelCore/Updates/TeamRegistry.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Updates/TeamRegistry.swift
@@ -126,11 +126,7 @@ public struct TeamRegistry: Sendable {
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
do {
let data = try encoder.encode(entries)
- try FileManager.default.createDirectory(
- at: url.deletingLastPathComponent(),
- withIntermediateDirectories: true
- )
- try data.write(to: url, options: .atomic)
+ try PeelFolder.write(data, to: url)
return true
} catch {
return false
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/PeelFolderTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/PeelFolderTests.swift
index 8c24baa2..b14ebeef 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/PeelFolderTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/PeelFolderTests.swift
@@ -16,4 +16,84 @@ struct PeelFolderTests {
#expect(PathPattern.comparablePath(of: url.deletingLastPathComponent()) == folder, "\(url.path(percentEncoded: false))")
}
}
+
+ @Test func nothingIsWrittenInAFolderRemovePeelTook() async throws {
+ let directory = try TemporaryDirectory()
+ let folder = directory.url.appending(path: "Peel", directoryHint: .isDirectory)
+ let file = { (name: String) in folder.appending(path: name) }
+ PeelFolder.take(folder)
+
+ FileLock.whileHeld(beside: file("a.json")) {}
+ #expect(!AppFolders(url: file("app-folders.json")).add([directory.url]))
+ #expect(!HomebrewChoice(url: file("homebrew.json")).save(nil))
+ #expect(!ShellFile.write(ShellFile.Choices(), to: file("Terminal/zshrc")))
+ #expect(!SSHFile.write([], to: file("Terminal/ssh_config")))
+ await ReleaseNotesStore(url: file("release-notes.json")).save(ReleaseNotesMemory())
+ let known = KnownDigests(entries: [:], day: 0)
+ let identity = try #require(FileIdentity.of(try directory.file("a file")))
+ known.keep(sample: try #require(ContentDigest(bytes: [UInt8](repeating: 1, count: 32))), of: identity)
+ DigestMemory(url: file("digests.bin")).save(known)
+ _ = await RefusalLog(url: file("refusals.json")).add(
+ [TrashFailure(url: directory.url, reason: .failed("no"))], source: "A test", tool: "test"
+ )
+ if case .saved = await ExclusionStore(url: file("exclusions.json")).change({ $0 = Exclusions() }) {
+ Issue.record("the list was saved in a folder that went")
+ }
+
+ #expect(folder.isMissing)
+ }
+
+ @Test func aFileWrittenInAFolderThatStaysAfterItWasTakenDoesNotLandThere() throws {
+ let directory = try TemporaryDirectory()
+ let folder = try directory.directory("Peel")
+ PeelFolder.take(folder)
+
+ #expect(!HomebrewChoice(url: folder.appending(path: "homebrew.json")).save(nil))
+ FileLock.whileHeld(beside: folder.appending(path: "a.json")) {}
+
+ #expect(try FileManager.default.contentsOfDirectory(atPath: folder.path(percentEncoded: false)).isEmpty)
+ }
+
+ @Test func aFolderBesideOneTakenStaysOpen() throws {
+ let directory = try TemporaryDirectory()
+ PeelFolder.take(directory.url.appending(path: "Peel", directoryHint: .isDirectory))
+
+ #expect(HomebrewChoice(url: directory.url.appending(path: "Peel 2/homebrew.json")).save(nil))
+ }
+
+ @Test func onlyThisFolderWritesAFileOfPeelsWhole() throws {
+ let sources = URL(filePath: #filePath).deletingLastPathComponent().deletingLastPathComponent()
+ .deletingLastPathComponent().appending(path: "Sources/PeelCore")
+ let files = try #require(FileManager.default.enumerator(at: sources, includingPropertiesForKeys: nil))
+ let writers = try files.compactMap { $0 as? URL }.filter { $0.pathExtension == "swift" }.filter {
+ try String(contentsOf: $0, encoding: .utf8).contains("options: .atomic")
+ }
+ #expect(writers.map(\.lastPathComponent) == ["PeelFolder.swift"])
+ }
+
+ @Test func aReadLeavesAHomeAsItFoundIt() async throws {
+ let directory = try TemporaryDirectory()
+ let folder = directory.url.appending(path: "Peel", directoryHint: .isDirectory)
+ let file = { (name: String) in folder.appending(path: name) }
+
+ _ = AppFolders(url: file("app-folders.json")).load()
+ _ = DigestMemory(url: file("digests.bin")).load()
+ _ = await RemovalLog(url: file("removals.json")).load()
+ _ = await RemovalLog(url: file("removals.json")).placesInTheTrash()
+ _ = await RefusalLog(url: file("refusals.json")).load()
+ _ = await RefusalLog(url: file("refusals.json")).holdsNothing()
+ await DockTiles(store: EmptyDock(), memory: file("dock-tiles.json")).putBack([directory.url])
+ _ = await ExclusionStore(url: file("exclusions.json")).load()
+ _ = await AppMemory(url: file("apps.json")).load()
+ _ = OrphanOwners(url: file("orphan-owners.json")).load()
+ _ = await LeftForAnAdministrator(url: file("left.json")).load()
+
+ #expect(folder.isMissing)
+ }
+}
+
+private struct EmptyDock: DockTileStore {
+ func tiles(in list: DockList) -> [Any]? { [] }
+ func setTiles(_ tiles: [Any], in list: DockList) -> Bool { true }
+ func restartTheDock() async {}
}
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/SelfRemovalTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/SelfRemovalTests.swift
index 2070fc56..14c68527 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/SelfRemovalTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/SelfRemovalTests.swift
@@ -364,6 +364,28 @@ struct SelfRemovalTests {
#expect(try String(contentsOf: moved.trashedURL.appending(path: "removals.json"), encoding: .utf8) == "2")
}
+ @Test func aScanThatEndsAfterPeelLeftDoesNotBringItsFolderBack() async throws {
+ let directory = try TemporaryDirectory()
+ let app = try directory.directory("home/Applications/Peel.app")
+ let folder = try directory.directory("home/Library/Application Support/Peel")
+
+ _ = await SelfRemoval.move([app], app: app, folder: folder, using: try service(in: directory)) { _ in }
+ #expect(folder.isMissing)
+
+ _ = await AppMemory(url: folder.appending(path: "apps.json")).remember([])
+ #expect(folder.isMissing, "a write made the folder again")
+ }
+
+ @Test func peelThatStaysKeepsWritingInItsFolder() async throws {
+ let directory = try TemporaryDirectory()
+ let app = directory.url.appending(path: "home/Applications/Peel.app", directoryHint: .isDirectory)
+ let folder = try directory.directory("home/Library/Application Support/Peel")
+
+ _ = await SelfRemoval.move([app], app: app, folder: folder, using: try service(in: directory)) { _ in }
+
+ #expect(HomebrewChoice(url: folder.appending(path: "homebrew.json")).save(nil))
+ }
+
@Test func movesTheAppPeelRunsFrom() async throws {
let directory = try TemporaryDirectory()
let program = try #require(RunningProgram.path(of: getpid()))
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/StandingWorkTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/StandingWorkTests.swift
index 0831d0dd..1c83903d 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/StandingWorkTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/StandingWorkTests.swift
@@ -9,7 +9,7 @@ struct StandingWorkTests {
var started = 0
var ended = 0
let (changes, _) = AsyncStream<Void>.makeStream()
- let work = StandingWork()
+ let work = StandingWork(scans: RunningScans())
work.start([{
started += 1
for await _ in changes {}
@@ -30,6 +30,51 @@ struct StandingWorkTests {
work.pause()
}
+ @Test func aPauseStopsEveryPagesScanAndWhatItWasGivenToStop() async {
+ let scans = RunningScans()
+ let work = StandingWork(scans: scans)
+ let run = ScanRun(among: scans)
+ let finished = ScanRun(among: scans)
+ var stopped = 0
+ _ = await finished.run { true }
+ let (never, _) = AsyncStream<Void>.makeStream()
+ work.start([{}], stoppingWithIt: [{ stopped += 1 }])
+ let scan = Task {
+ await run.run {
+ for await _ in never {}
+ return true
+ }
+ }
+ await settle { run.isRunning }
+
+ work.pause()
+
+ #expect(!run.isRunning)
+ #expect(run.wasStopped)
+ #expect(!finished.wasStopped)
+ #expect(stopped == 1)
+ #expect(await scan.value == nil)
+ }
+
+ @Test func aScanOfAnotherListKeepsRunningThroughAPause() async {
+ let work = StandingWork(scans: RunningScans())
+ let run = ScanRun(among: RunningScans())
+ let (never, _) = AsyncStream<Void>.makeStream()
+ let scan = Task {
+ await run.run {
+ for await _ in never {}
+ return true
+ }
+ }
+ await settle { run.isRunning }
+
+ work.pause()
+
+ #expect(run.isRunning)
+ run.stop()
+ _ = await scan.value
+ }
+
private func settle(until done: () -> Bool) async {
for _ in 0..<1_000 where !done() {
await Task.yield()
diff --git a/Peel/Model/AppLibrary.swift b/Peel/Model/AppLibrary.swift
index 1229293f..0de77b74 100644
--- a/Peel/Model/AppLibrary.swift
+++ b/Peel/Model/AppLibrary.swift
@@ -368,6 +368,12 @@ final class AppLibrary {
}
}
+ func stopCheckingEveryApp() {
+ recheck?.cancel()
+ rechecks += 1
+ isCheckingEveryApp = false
+ }
+
private func keepUnreadable(of scan: AppScan) {
if unreadable != scan.unreadable { unreadable = scan.unreadable }
if listOfFoldersUnreadable != scan.listOfFoldersUnreadable {
diff --git a/Peel/PeelApp.swift b/Peel/PeelApp.swift
index 697d57d9..886b5450 100644
--- a/Peel/PeelApp.swift
+++ b/Peel/PeelApp.swift
@@ -332,10 +332,13 @@ struct PeelApp: App {
guard HomeSnapshot.directory == nil, TerminalExport.directory == nil else { return }
#endif
Navigator.shared.openWindow = openWindow
- background.start([
- followFolders, followAppsForTheTrash, askWhenDue, followFindings, followActivations, watchFreeSpace,
- followHelper, followHomebrew, followUpdates,
- ])
+ background.start(
+ [
+ followFolders, followAppsForTheTrash, askWhenDue, followFindings, followActivations, watchFreeSpace,
+ followHelper, followHomebrew, followUpdates,
+ ],
+ stoppingWithIt: [duplicates.stop, library.stopCheckingEveryApp]
+ )
textEditing.start()
sheetInFront.start()
// Work for Peel coming forward is in `followActivations`.
diff --git a/PeelTests/AppLibraryTests.swift b/PeelTests/AppLibraryTests.swift
index e75b568a..fad24e87 100644
--- a/PeelTests/AppLibraryTests.swift
+++ b/PeelTests/AppLibraryTests.swift
@@ -301,6 +301,24 @@ private nonisolated final class TestClock: Sendable {
#expect(library.shownUpdateStatus(of: app)?.version == "1.1")
}
+ @Test func stoppingTheRoundOfEveryAppEndsIt() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let made = try MadeUpDefaults()
+ defer { made.forget() }
+ let library = library(with: made.defaults, notesIn: folder)
+
+ library.checkEveryAppAgain()
+ #expect(library.isCheckingEveryApp)
+ let round = library.recheck
+ library.stopCheckingEveryApp()
+
+ #expect(!library.isCheckingEveryApp)
+ #expect(round?.isCancelled == true)
+ await round?.value
+ #expect(!library.isCheckingEveryApp)
+ }
+
@Test func knowsHomebrewsAppsOnlyOnceAReadingKnowsThemAll() async throws {
let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
defer { try? FileManager.default.removeItem(at: folder) }