fix(processor): ensure correct error on Linux

Author: Romelium

src/processor/create.rs

@@ -3,6 +3,7 @@
 use crate::core_types::{Action, CreateStatus};
 use crate::errors::ProcessError;
 use std::fs;
+use std::io; // Import io for ErrorKind
 use std::path::Path;
 
 /// Creates or overwrites a file with the provided content.
@@ -63,21 +64,51 @@ pub(crate) fn process_create(
 /// Also checks if the parent path itself is unexpectedly a file.
 fn ensure_parent_directory(target_path: &Path, resolved_base: &Path) -> Result<(), ProcessError> {
     if let Some(parent_dir) = target_path.parent() {
-        if parent_dir == resolved_base || parent_dir.exists() {
-            // If parent exists, ensure it's a directory
-            if !parent_dir.is_dir() {
-                return Err(ProcessError::ParentIsNotDirectory {
-                    path: target_path.to_path_buf(),
-                    parent_path: parent_dir.to_path_buf(),
-                });
+        // Avoid checking the base directory itself if it's the parent
+        if parent_dir == resolved_base || parent_dir.as_os_str().is_empty() {
+            return Ok(()); // Base directory is guaranteed to exist and be a dir, or path is in root
+        }
+
+        match fs::metadata(parent_dir) {
+            Ok(metadata) => {
+                // Parent exists, check if it's a directory
+                if !metadata.is_dir() {
+                    return Err(ProcessError::ParentIsNotDirectory {
+                        path: target_path.to_path_buf(),
+                        parent_path: parent_dir.to_path_buf(),
+                    });
+                }
+                // Parent exists and is a directory, all good.
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::NotFound => {
+                // Parent does not exist, try to create it
+                let relative_parent_dir =
+                    parent_dir.strip_prefix(resolved_base).unwrap_or(parent_dir);
+                println!("  Creating directory: {}", relative_parent_dir.display());
+
+                if let Err(create_err) = fs::create_dir_all(parent_dir) {
+                    // Check if the error is specifically "Not a directory"
+                    // This often indicates an intermediate path component was a file.
+                    if create_err.kind() == io::ErrorKind::NotADirectory {
+                        // Map this specific IO error to our more descriptive error
+                        return Err(ProcessError::ParentIsNotDirectory {
+                            path: target_path.to_path_buf(),
+                            // Report the parent directory we *failed* to create
+                            parent_path: parent_dir.to_path_buf(),
+                        });
+                    } else {
+                        // Other I/O error during creation
+                        return Err(ProcessError::Io { source: create_err });
+                    }
+                }
+                // Creation successful
+            }
+            Err(e) => {
+                // Other error getting metadata (permissions?)
+                return Err(ProcessError::Io { source: e });
             }
-        } else {
-            // Parent does not exist, create it
-            let relative_parent_dir = parent_dir.strip_prefix(resolved_base).unwrap_or(parent_dir);
-            println!("  Creating directory: {}", relative_parent_dir.display());
-            fs::create_dir_all(parent_dir).map_err(|e| ProcessError::Io { source: e })?;
         }
     }
-    // If no parent (e.g., root directory), assume it's okay.
+    // If no parent (e.g., file directly in base), assume it's okay.
     Ok(())
 }

src/processor/safety.rs

@@ -1,40 +1,49 @@
 //! Path safety validation logic.
 
 use crate::errors::ProcessError;
+use std::fs; // Use fs::metadata
 use std::io::ErrorKind;
 use std::path::Path;
 
 /// Checks if the target path is safely within the base directory.
-/// Canonicalizes both paths for reliable comparison.
+/// Canonicalizes paths for reliable comparison.
 pub(crate) fn ensure_path_safe(base_dir: &Path, target_path: &Path) -> Result<(), ProcessError> {
     // Canonicalize base directory (must succeed as it's resolved in process_actions)
     let canonical_base = base_dir
         .canonicalize()
         .map_err(|e| ProcessError::Io { source: e })?;
 
-    // Attempt to canonicalize the target path.
-    match target_path.canonicalize() {
-        Ok(canonical_target) => {
-            // If target exists and canonicalizes, check if it starts with the base
-            if canonical_target.starts_with(&canonical_base) {
-                Ok(()) // Path is safe
-            } else {
-                Err(ProcessError::PathNotSafe {
-                    resolved_path: canonical_target,
-                    base_path: canonical_base,
-                })
+    // Check if the target path *exists* first using metadata.
+    match fs::metadata(target_path) {
+        Ok(_) => {
+            // Target exists. Canonicalize it for the safety check.
+            match target_path.canonicalize() {
+                Ok(canonical_target) => {
+                    if canonical_target.starts_with(&canonical_base) {
+                        Ok(()) // Path exists and is safe
+                    } else {
+                        Err(ProcessError::PathNotSafe {
+                            resolved_path: canonical_target,
+                            base_path: canonical_base,
+                        })
+                    }
+                }
+                Err(e) => {
+                    // Error canonicalizing an *existing* path (permissions?)
+                    Err(ProcessError::PathResolution {
+                        path: target_path.to_path_buf(),
+                        details: format!("Failed to canonicalize existing target path: {}", e),
+                    })
+                }
             }
         }
         Err(ref e) if e.kind() == ErrorKind::NotFound => {
             // Target doesn't exist: Check safety based on its intended parent.
             check_nonexistent_target_safety(target_path, &canonical_base)
         }
         Err(e) => {
-            // Other error during canonicalization (e.g., permission denied)
-            Err(ProcessError::PathResolution {
-                path: target_path.to_path_buf(),
-                details: format!("Failed to canonicalize target path: {}", e),
-            })
+            // Other error getting metadata (permissions?)
+            Err(ProcessError::Io { source: e }) // Map other metadata errors to IO
         }
     }
 }