LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
#2617: Find Missing matches Windows paths' file names on macOS and Linux
Clyde C Brownf6a4770cf213
diff --git a/crates/engine/src/cmd/missing.rs b/crates/engine/src/cmd/missing.rsindex 1bff30d2b..c6c692c35 100644--- a/crates/engine/src/cmd/missing.rs+++ b/crates/engine/src/cmd/missing.rs@@ -197,13 +197,24 @@ impl FindPlan {}}+/// How Find Missing compares file names: the part after the last `/` or `\`, in lower case. A+/// library made on Windows keeps Windows paths, whose `\` isn't a separator to `Path` on macOS or+/// Linux. Files on disk are named by the same rule, so a macOS or Linux file name that holds a+/// `\` (`a\b.jpg`) still meets its photo, and a `b.jpg` beside it makes that match ambiguous+/// rather than a guess. With no `a\b.jpg` there, such a photo may be found as `b.jpg`, if the+/// size on record agrees.+fn name_key(path: &str) -> String {+ path.rsplit(['/', '\\']).next().unwrap_or_default().to_lowercase()+}+/// The file-system half of Find Missing Photos: which `candidates` are gone, and which file in/// `folder` (recursively) is each one's. Touches only the disk — never the session — so the app/// runs it on a worker thread (walking a big folder on a network share and hashing look-alikes/// takes a while) and relinks the result with `library.findMissing {found, missing, ambiguous}`.////// Matching, per photo:-/// 1. a file with the same name (any letter case), the same size and the same content hash;+/// 1. a file with the same name ([`name_key`]: any letter case), the same size and the same+/// content hash;/// 2. renamed: a file of the same size with the same content hash (only same-size files are/// read, so this stays cheap);/// 3. without a hash to confirm (or the file was edited in place): the one file with the same@@ -228,8 +239,9 @@ pub fn plan_find_missing(candidates: &[FindCandidate], folder: &str) -> std::reslet mut by_name: HashMap<String, Vec<String>> = HashMap::new();let files: Vec<String> = crate::import::expand(&[folder.to_string()], None).into_iter().filter(|f| !in_use.contains(f.as_str())).collect();for f in &files {- if let Some(n) = Path::new(f).file_name() {- by_name.entry(n.to_string_lossy().to_lowercase()).or_default().push(f.clone());+ let name = name_key(f);+ if !name.is_empty() {+ by_name.entry(name).or_default().push(f.clone());}}let mut by_size: Option<HashMap<u64, Vec<String>>> = None;@@ -239,7 +251,7 @@ pub fn plan_find_missing(candidates: &[FindCandidate], folder: &str) -> std::reslet mut used: HashSet<String> = HashSet::new();let mut plan = FindPlan::default();for c in &lost {- let name = Path::new(&c.path).file_name().map(|n| n.to_string_lossy().to_lowercase()).unwrap_or_default();+ let name = name_key(&c.path);let size = c.size;let hash = c.hash.as_deref();let named: Vec<&String> = by_namediff --git a/crates/engine/src/tests_import.rs b/crates/engine/src/tests_import.rsindex 191595ebe..a688426ec 100644--- a/crates/engine/src/tests_import.rs+++ b/crates/engine/src/tests_import.rs@@ -263,6 +263,70 @@ fn find_missing_plan_is_rechecked_when_applied() {let _ = std::fs::remove_dir_all(&dir);}+/// A library made on Windows names its originals with Windows paths; opened on macOS or Linux+/// they are missing until Find Missing finds them by name, there as everywhere: the name follows+/// the last `/` or `\`, any letter case, the size checked when one is on record, look-alikes+/// reported rather than guessed, and undo puts back the path exactly as spelled.+#[test]+fn find_missing_finds_the_files_of_a_library_made_on_windows() {+ use lightcraft_catalog::{Op, Photo, PhotoId, Source};+ let dir = temp_dir("missing-windows");+ for (rel, bytes) in [("found/a.jpg", &b"x"[..]), ("found/deep/b.jpg", b"xyz"), ("found/one/twin.jpg", b"x"), ("found/two/twin.jpg", b"x")] {+ std::fs::create_dir_all(dir.join(rel).parent().unwrap()).unwrap();+ std::fs::write(dir.join(rel), bytes).unwrap();+ }+ let mut s = Session::new();+ // as a Windows library may list them: no content hash, and a size only for b+ let mut add = |path: &str, size: u64| {+ let id = s.catalog.alloc_photo_id();+ let mut p = Photo::new(id, Source::File { path: path.into() }, "x.jpg", "JPEG", 60, 40, "2026-01-01T10:00:00");+ p.file_size = size;+ s.catalog.apply(Op::AddPhoto { photo: Box::new(p) }).unwrap();+ id+ };+ let (a, b, twin) = (add(r"C:\Users\me\Photos\a.jpg", 0), add(r"D:\Shoot\2019\B.JPG", 3), add(r"C:\Users\me\Photos\twin.jpg", 0));+ let path_of = |s: &Session, id: PhotoId| match &s.catalog.photo(id).unwrap().source {+ Source::File { path } => path.clone(),+ _ => String::new(),+ };+ let r = s.execute("library.findMissing", &json!({"folder": dir.join("found").to_string_lossy()})).unwrap();+ assert_eq!(path_of(&s, a), dir.join("found").join("a.jpg").to_string_lossy(), "found by its name: {r}");+ assert_eq!(path_of(&s, b), dir.join("found").join("deep").join("b.jpg").to_string_lossy(), "found by its name, any case, and size: {r}");+ assert_eq!(path_of(&s, twin), r"C:\Users\me\Photos\twin.jpg", "two files of its name: not guessed: {r}");+ assert_eq!(r["ambiguous"][0]["candidates"].as_array().map(Vec::len), Some(2), "both look-alikes reported: {r}");+ assert_eq!(r["missing"], 1, "{r}");+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(+ (path_of(&s, a), path_of(&s, b)),+ (r"C:\Users\me\Photos\a.jpg".to_string(), r"D:\Shoot\2019\B.JPG".to_string()),+ "one undo step puts back the Windows paths as they were spelled"+ );+ let _ = std::fs::remove_dir_all(&dir);+}++/// On macOS and Linux `\` may be part of a file name. Find Missing names the files it finds by+/// the same rule as the missing photos, so `a\b.jpg` isn't relinked to a `b.jpg` beside it+/// unasked: the two are reported as look-alikes.+#[cfg(unix)]+#[test]+fn find_missing_does_not_take_a_look_alike_for_a_file_name_with_a_backslash() {+ use lightcraft_catalog::{Op, Photo, Source};+ let dir = temp_dir("missing-backslash");+ std::fs::create_dir_all(dir.join("found")).unwrap();+ for name in [r"a\b.jpg", "b.jpg"] {+ std::fs::write(dir.join("found").join(name), b"x").unwrap();+ }+ let mut s = Session::new();+ let gone = dir.join("gone").join(r"a\b.jpg").to_string_lossy().to_string();+ let id = s.catalog.alloc_photo_id();+ let p = Photo::new(id, Source::File { path: gone.clone() }, "x.jpg", "JPEG", 60, 40, "2026-01-01T10:00:00");+ s.catalog.apply(Op::AddPhoto { photo: Box::new(p) }).unwrap();+ let r = s.execute("library.findMissing", &json!({"folder": dir.join("found").to_string_lossy()})).unwrap();+ assert!(matches!(&s.catalog.photo(id).unwrap().source, Source::File { path } if *path == gone), "not relinked to b.jpg: {r}");+ assert_eq!(r["ambiguous"][0]["candidates"].as_array().map(Vec::len), Some(2), "both reported: {r}");+ let _ = std::fs::remove_dir_all(&dir);+}+#[test]fn missing_files_are_found_and_relinked() {let dir = std::env::temp_dir().join(format!("lc-missing-{}", std::process::id()));diff --git a/docs/whats-new.md b/docs/whats-new.mdindex cffff83e2..d5341efdd 100644--- a/docs/whats-new.md+++ b/docs/whats-new.md@@ -1,5 +1,15 @@# What's new in LightCraft+## 2026-10-22++### Find Missing Photos finds the files of a library made on Windows+- A library made on Windows records its originals with Windows paths. Opened on macOS or Linux, its photos are+ missing until relinked, and Find Missing Photos found them only by their content, so it missed every photo it had+ no fingerprint for (such as photos brought in from a Lightroom catalog) or that had been edited since, even in a+ folder holding every file under the same name. It now matches them by name as it does any other photo: the name+ after the last `/` or `\`, in any letter case, checked against the size when the library has one. Several files+ of that name are still reported rather than guessed, and undo puts back the paths as they were.+## 2026-10-21### Sharper resampling in HDR and panorama merges