Save: ask before replacing a hard link to the file the dialog named

A save whose added or lowercased extension names another entry in the
folder now asks before replacing it, even when that entry is a hard
link to the file the save dialog asked about. Two spellings of one
name on a file system that ignores letter case still count as the same
entry and do not ask.
This commit is contained in:
dotCooCoo committed 2026-10-18 16:35:59 -07:00
1 parent 77e20dad31
commit 89195d7f16
3 files changed
+55 -7

No files matched your search

+47 -1
View File
@@ -346,6 +346,24 @@ fn same_file(a: &Path, b: &Path) -> bool {
}
}
/// Whether `a` and `b` name one entry in one folder: `same_file` finds they reach the same file
/// in the same folder, and the folder doesn't list both names. Another spelling of a name on a
/// file system that ignores letter case is the same entry; a hard link is another entry, which a
/// save replaces while the first name keeps the old file. False when the folder can't be read.
fn same_entry(a: &Path, b: &Path, same_file: impl Fn(&Path, &Path) -> bool) -> bool {
let folder = |p: &Path| p.parent().filter(|d| !d.as_os_str().is_empty()).unwrap_or(Path::new(".")).to_path_buf();
if !same_file(a, b) || !same_file(&folder(a), &folder(b)) {
return false;
}
let (Some(x), Some(y)) = (a.file_name(), b.file_name()) else { return false };
if x == y {
return true;
}
let Ok(entries) = std::fs::read_dir(folder(a)) else { return false };
let listed: Vec<_> = entries.filter_map(|e| e.ok().map(|e| e.file_name())).collect();
!(listed.iter().any(|n| n == x) && listed.iter().any(|n| n == y))
}
fn export_options(settings: &photocraft_ui_egui::ExportSettings) -> photocraft_io::ExportOptions {
settings.io_options()
}
@@ -559,7 +577,7 @@ pub fn native(automation: Option<photocraft_automation::AuthorizedWorkspace>) ->
let meta = std::fs::metadata(path).ok()?;
Some(photocraft_ui_egui::FileStamp { len: meta.len(), modified: meta.modified().ok() })
})),
same_file: Some(Box::new(|a: &str, b: &str| same_file(Path::new(a), Path::new(b)))),
same_file: Some(Box::new(|a: &str, b: &str| same_entry(Path::new(a), Path::new(b), same_file))),
automation_read,
automation_write,
automation_open_pcraft,
@@ -973,6 +991,34 @@ mod tests {
std::fs::remove_dir_all(&dir).unwrap();
}
/// A hard link is another entry in the folder, though it reaches the same file: a save to it
/// replaces that entry and leaves the other name on the old file. Another spelling of a name,
/// where letter case is ignored, is the same entry.
#[test]
fn a_hard_link_is_another_entry() {
let dir = std::env::temp_dir().join(format!("photocraft-same-entry-{}", std::process::id()));
std::fs::create_dir_all(dir.join("other")).unwrap();
let (cat, bare, upper, other) = (dir.join("CAT.psd"), dir.join("CAT"), dir.join("CAT.PSD"), dir.join("other").join("CAT.psd"));
std::fs::write(&cat, b"cat").unwrap();
std::fs::hard_link(&cat, &bare).unwrap();
std::fs::hard_link(&cat, &other).unwrap();
// Where both names reach one file (one inode on Unix), the folder still lists both.
let one_file = |_: &Path, _: &Path| true;
assert!(!same_entry(&bare, &cat, one_file));
assert!(!same_entry(&bare, &cat, same_file));
assert!(!same_entry(&other, &cat, same_file), "another folder");
assert!(same_entry(&cat, &cat, one_file));
assert!(same_entry(&cat, &cat, same_file));
if upper.exists() {
assert!(same_entry(&upper, &cat, same_file), "one entry where letter case is ignored");
} else {
std::fs::hard_link(&cat, &upper).unwrap();
assert!(!same_entry(&upper, &cat, same_file), "two entries where letter case tells names apart");
}
assert!(!same_entry(&dir.join("missing.psd"), &cat, same_file));
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn block_on_waits_for_a_wake_from_another_thread() {
let (tx, rx) = std::sync::mpsc::channel::<std::task::Waker>();
+3 -2
View File
@@ -185,9 +185,10 @@ impl PhotocraftApp {
/// Whether a save to `path` replaces a file the save dialog didn't ask about: the dialog
/// answered `answered`, and [`saved_path`] changed it. A file at `path` that
/// [`Services::same_file`](crate::Services::same_file) finds is also the file at `answered` (the
/// [`Services::same_file`](crate::Services::same_file) finds is the same entry as `answered` (the
/// same name in another letter case on a file system that ignores case, as Windows and macOS do
/// by default) counts as asked about. Never on the web, which has no file stamps.
/// by default) counts as asked about; a hard link to it does not. Never on the web, which has no
/// file stamps.
fn replaces_unasked(&self, answered: &str, path: &str) -> bool {
let Some(stamp) = self.services.file_stamp.as_ref() else { return false };
answered != path && stamp(path).is_some() && !self.services.same_file.as_ref().is_some_and(|same| same(answered, path))
+5 -4
View File
@@ -367,7 +367,7 @@ pub struct FileStamp {
}
/// The [`FileStamp`] of the file at a path, `None` when it can't be read.
pub type FileStampFn = Box<dyn Fn(&str) -> Option<FileStamp>>;
/// Whether two paths reach the same file on disk; false when either can't be read.
/// Whether two paths name one entry in one folder on disk; false when either can't be read.
pub type SameFileFn = Box<dyn Fn(&str, &str) -> bool>;
/// Encode a document and write it to a path, reporting the stage to the job; returns the export
/// warnings. Runs on a worker thread (see [`Services::save_file`]). It must call
@@ -476,9 +476,10 @@ pub struct Services {
/// Size and modification time of a file (native); `None` on the web, where Save never
/// writes back to a file.
pub file_stamp: Option<FileStampFn>,
/// Whether two paths reach the same file (native): a save dialog's answer and the path the
/// save writes to after Lowercase Extension, on a file system that ignores letter case. A save
/// asks before replacing a file it finds different (`replace_prompt`).
/// Whether two paths name one entry in one folder (native): a save dialog's answer and the
/// path the save writes to after Lowercase Extension, on a file system that ignores letter
/// case. A hard link is another entry. A save asks before replacing an entry it finds
/// different (`replace_prompt`).
pub same_file: Option<SameFileFn>,
/// `write` only asks for the bytes to be kept (a browser download, which the user can
/// cancel and which reports nothing back), so a save through it names the document but