diff --git a/src/prefs.rs b/src/prefs.rs index 4dc51c4b..77d5fd36 100644 --- a/src/prefs.rs +++ b/src/prefs.rs @@ -261,17 +261,9 @@ impl PreferenceManager { // Note: if current_dir() also fails, unwrap_or_default yields an empty PathBuf, // and the result may remain relative. #[cfg(not(feature = "include-zip"))] - let rules_dir = match rules_dir.canonicalize() { - Err(_e) => { - if rules_dir.is_absolute() { - rules_dir - } else { - std::env::current_dir() - .unwrap_or_default() - .join(&rules_dir) - } - }, - Ok(rules_dir) => rules_dir, + let rules_dir = match canonicalize_shim(&rules_dir) { + Err(e) => bail!("set_rules_dir: could not canonicalize path {}: {}", rules_dir.display(), e.to_string()), + Ok(rules_dir) => rules_dir, }; self.set_rules_dir(&rules_dir)?; diff --git a/src/shim_filesystem.rs b/src/shim_filesystem.rs index 14c5b26f..a0211baa 100644 --- a/src/shim_filesystem.rs +++ b/src/shim_filesystem.rs @@ -281,15 +281,81 @@ cfg_if! { crate::interface::set_rules_dir("Rules").unwrap(); // force reinitialization after the change } } else { + use std::collections::{HashMap, HashSet}; + use std::sync::RwLock; + + static IN_MEMORY_FILES: RwLock>> = RwLock::new(None); + static IN_MEMORY_DIRS: RwLock>> = RwLock::new(None); + + pub fn add_in_memory_file(path: &str, content: &str) { + { + let mut files = IN_MEMORY_FILES.write().unwrap(); + files.get_or_insert_with(HashMap::new).insert(path.to_string(), content.to_string()); + } + + let path_obj = Path::new(path); + { + let mut dirs = IN_MEMORY_DIRS.write().unwrap(); + let dirs = dirs.get_or_insert_with(HashSet::new); + for parent in path_obj.ancestors().skip(1) { + let parent_str = parent.to_str().unwrap_or_default(); + if !parent_str.is_empty() { + dirs.insert(parent_str.to_string()); + } + } + } + } + + pub fn canonicalize_shim(path: &Path) -> std::io::Result { + use std::ffi::OsStr; + let dot = OsStr::new("."); + let dot_dot = OsStr::new(".."); + let mut result = PathBuf::new(); + for part in path.iter() { + if dot == part { + continue; + } else if dot_dot == part { + result.pop(); + } else { + result.push(part); + } + } + return Ok(result); + } + + fn get_in_memory_key(path: &Path) -> String { + canonicalize_shim(path).unwrap_or_else(|_| path.to_path_buf()).to_str().unwrap_or_default().to_string() + } + pub fn is_file_shim(path: &Path) -> bool { + if IN_MEMORY_FILES.read().unwrap().as_ref().map_or(false, |f| f.contains_key(&get_in_memory_key(path))) { + return true; + } return path.is_file(); } pub fn is_dir_shim(path: &Path) -> bool { + if IN_MEMORY_DIRS.read().unwrap().as_ref().map_or(false, |d| d.contains(&get_in_memory_key(path))) { + return true; + } return path.is_dir(); } pub fn find_files_in_dir_that_ends_with_shim(dir: &Path, ending: &str) -> Vec { + let dir_name = get_in_memory_key(dir); + let mut answer = Vec::new(); + if let Some(files) = IN_MEMORY_FILES.read().unwrap().as_ref() { + for file_name in files.keys() { + if file_name.starts_with(&dir_name) && file_name.ends_with(ending) { + let name = Path::new(file_name).file_name().unwrap_or_default().to_str().unwrap_or_default(); + answer.push(name.to_string()); + } + } + } + if !answer.is_empty() { + return answer; + } + match dir.read_dir() { Err(_) => return vec![], // empty Ok(read_dir) => { @@ -340,27 +406,6 @@ cfg_if! { } } - /// Resolves the path to an absolute, canonical form using the OS. - /// If `canonicalize()` fails (e.g., ACCESS_DENIED in containers), falls back to: - /// - returning the path as-is if it is already absolute, - /// - prepending the current working directory if it is relative. - /// Note: the fallback does not resolve symlinks or normalize `..`/`.` segments. - pub fn canonicalize_shim(path: &Path) -> std::io::Result { - match path.canonicalize() { - Ok(p) => Ok(p), - Err(_) => { - if path.is_absolute() { - Ok(path.to_path_buf()) - } else { - // Prepend cwd to make the relative path absolute. - // unwrap_or_default yields an empty PathBuf if cwd is unavailable, - // in which case the returned path will still be relative. - Ok(std::env::current_dir().unwrap_or_default().join(path)) - } - } - } - } - // Tests extract language/braille zips in parallel. During extraction, individual YAML // files can briefly exist in a partially-written state (created/truncated before the // full contents are flushed). Guard both extraction and YAML reads with the same lock @@ -379,6 +424,10 @@ cfg_if! { } pub fn read_to_string_shim(path: &Path) -> Result { + if let Some(content) = IN_MEMORY_FILES.read().unwrap().as_ref().and_then(|f| f.get(&get_in_memory_key(path)).cloned()) { + return Ok(content); + } + let path = match path.canonicalize() { Ok(path) => path, Err(_) => path.to_path_buf(), @@ -490,4 +539,18 @@ mod tests { assert_eq!("test-value", read_to_string_shim(&existing_file).unwrap()); assert!(read_to_string_shim(&test_dir.path().join("does-not-exist.yaml")).is_err()); } + + #[test] + fn in_memory_filesystem_shim() { + add_in_memory_file("virtual/rules/Languages/en/test_Rules.yaml", "key: value"); + let file_path = Path::new("virtual/rules/Languages/en/test_Rules.yaml"); + let dir_path = Path::new("virtual/rules/Languages/en"); + + assert!(is_file_shim(file_path)); + assert!(is_dir_shim(dir_path)); + assert_eq!(read_to_string_shim(file_path).unwrap(), "key: value"); + + let found = find_files_in_dir_that_ends_with_shim(dir_path, "_Rules.yaml"); + assert_eq!(found, vec!["test_Rules.yaml".to_string()]); + } }