fix(processor): ensure correct error on Linux

Author: Romelium

src/processor/action_handler.rs

@@ -93,6 +93,8 @@ pub(crate) fn process_single_action(
 
     // --- Handle Errors from Action Handlers ---
     if let Err(e) = result {
+        // *** DEBUG LOG ***
+        eprintln!("[DEBUG] Action handler returned error variant: {:?}", e);
         eprintln!("Error processing action for '{}': {}", relative_path_str, e);
         summary_updater::update_summary_error(summary, e);
     }

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.
@@ -19,6 +20,7 @@ pub(crate) fn process_create(
         .ok_or_else(|| ProcessError::Internal("Missing content for create action".to_string()))?;
 
     // Ensure parent directory exists and is a directory
+    // This might return ParentIsNotDirectory if parent exists as file or if creation fails
     ensure_parent_directory(resolved_full_path, resolved_base)?;
 
     let mut status = CreateStatus::Created; // Default optimistic status
@@ -54,7 +56,23 @@ pub(crate) fn process_create(
 
     // Write the file content (as bytes to preserve line endings)
     fs::write(resolved_full_path, content.as_bytes())
-        .map_err(|e| ProcessError::Io { source: e })?;
+        .map_err(|e| {
+            // Check if the write failed because the parent path component is a file
+            if e.kind() == io::ErrorKind::NotADirectory {
+                // Map this specific IO error to our more descriptive error
+                let parent_path = resolved_full_path.parent().unwrap_or(resolved_full_path).to_path_buf();
+                // *** DEBUG LOG ***
+                eprintln!("[DEBUG] fs::write failed with NotADirectory, mapping to ParentIsNotDirectory for path: {}", resolved_full_path.display());
+                ProcessError::ParentIsNotDirectory {
+                    path: resolved_full_path.to_path_buf(),
+                    parent_path, // Report the parent path
+                }
+            } else {
+                 // *** DEBUG LOG ***
+                eprintln!("[DEBUG] fs::write failed with other IO error: {:?}, mapping to Io for path: {}", e.kind(), resolved_full_path.display());
+                ProcessError::Io { source: e }
+            }
+        })?;
 
     Ok(status)
 }
@@ -63,21 +81,59 @@ 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() {
+                    // *** DEBUG LOG ***
+                    eprintln!("[DEBUG] Parent metadata exists but is not dir, returning ParentIsNotDirectory for parent: {}", parent_dir.display());
+                    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 during creation attempt.
+                    if create_err.kind() == io::ErrorKind::NotADirectory {
+                        // *** DEBUG LOG ***
+                        eprintln!("[DEBUG] create_dir_all failed with NotADirectory, returning ParentIsNotDirectory for parent: {}", parent_dir.display());
+                        // 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 {
+                        // *** DEBUG LOG ***
+                        eprintln!("[DEBUG] create_dir_all failed with other IO error: {:?}, returning Io for parent: {}", create_err.kind(), parent_dir.display());
+                        // Other I/O error during creation
+                        return Err(ProcessError::Io { source: create_err });
+                    }
+                }
+                // Creation successful
+            }
+            Err(e) => {
+                // *** DEBUG LOG ***
+                eprintln!("[DEBUG] fs::metadata failed with other IO error: {:?}, returning Io for parent: {}", e.kind(), parent_dir.display());
+                // 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,41 +1,73 @@
 //! Path safety validation logic.
 
 use crate::errors::ProcessError;
-use std::io::ErrorKind;
+use std::fs; // Use fs::metadata
+use std::io::ErrorKind; // Import io and 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 })?;
+    let canonical_base = match base_dir.canonicalize() {
+        Ok(path) => path,
+        // Handle potential NotADirectory error if base_dir itself is somehow a file (should be caught earlier, but belt-and-suspenders)
+        Err(e) if e.kind() == ErrorKind::NotADirectory => {
+            return Err(ProcessError::ParentIsNotDirectory {
+                // Technically the base itself isn't a dir
+                path: base_dir.to_path_buf(),
+                parent_path: base_dir.parent().unwrap_or(base_dir).to_path_buf(),
+            });
+        }
+        Err(e) => return Err(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,
+                        })
+                    }
+                }
+                // *** CATCH NotADirectory during canonicalization of EXISTING target ***
+                Err(e) if e.kind() == ErrorKind::NotADirectory => {
+                    Err(ProcessError::ParentIsNotDirectory {
+                        path: target_path.to_path_buf(),
+                        parent_path: target_path.parent().unwrap_or(target_path).to_path_buf(),
+                    })
+                }
+                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 {
+        // *** CATCH NotADirectory during metadata check (parent is file) ***
+        Err(ref e) if e.kind() == ErrorKind::NotADirectory => {
+            Err(ProcessError::ParentIsNotDirectory {
                 path: target_path.to_path_buf(),
-                details: format!("Failed to canonicalize target path: {}", e),
+                parent_path: target_path.parent().unwrap_or(target_path).to_path_buf(),
             })
         }
+        Err(e) => {
+            // Other error getting metadata (permissions?)
+            Err(ProcessError::Io { source: e }) // Map other metadata errors to IO
+        }
     }
 }
 
@@ -60,6 +92,13 @@ fn check_nonexistent_target_safety(
                     })
                 }
             }
+            // *** CATCH NotADirectory during PARENT canonicalization ***
+            Err(ref parent_err) if parent_err.kind() == ErrorKind::NotADirectory => {
+                Err(ProcessError::ParentIsNotDirectory {
+                    path: target_path.to_path_buf(), // The target we were trying to create
+                    parent_path: parent.to_path_buf(), // The parent that is not a directory
+                })
+            }
             Err(ref parent_err) if parent_err.kind() == ErrorKind::NotFound => {
                 // Parent directory itself doesn't exist. This implies it needs to be
                 // created. Assume `create_dir_all` will handle safety within the base.