softpath 0.2.2

A human-friendly file and directory path manipulation library for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::fs;
use std::path::{Path, PathBuf};
use crate::error::SoftPathError;
use crate::ops::PathExt;

impl PathExt for &str {
    fn into_path(self) -> Result<PathBuf, SoftPathError> {
        // Check for null bytes which are invalid in paths
        if self.contains('\0') {
            return Err(SoftPathError::InvalidPath(
                "Path contains null bytes".to_string()
            ));
        }
        
        // First validate the input string for basic path traversal patterns
        let input_path = PathBuf::from(self);
        
        let path = if let Some(path) = self.strip_prefix("~/").or_else(|| self.strip_prefix("~\\")) {
            // Validate the path component after tilde expansion before joining
            let path_component = PathBuf::from(path);
            crate::utils::check_path_traversal(&path_component)?;
            
            let home = dirs::home_dir().ok_or_else(|| {
                SoftPathError::InvalidPath("Could not determine home directory.".to_string())
            })?;
            home.join(path)
        } else {
            input_path
        };
        
        // Final validation of the complete path
        crate::utils::check_path_traversal(&path)?;
        crate::utils::check_symlink_cycles(&path)?;
        Ok(path)
    }

    fn exists(&self) -> Result<bool, SoftPathError> {
        // Convert to path and validate, then check existence
        let path = self.into_path()?;
        Ok(path.exists()?)
    }

    fn is_file(&self) -> Result<bool, SoftPathError> {
        // Convert to path and validate, then check if it's a file
        let path = self.into_path()?;
        Ok(path.is_file()?)
    }

    fn is_dir(&self) -> Result<bool, SoftPathError> {
        // Convert to path and validate, then check if it's a directory
        let path = self.into_path()?;
        Ok(path.is_dir()?)
    }

    fn create_file(&self) -> Result<(), SoftPathError> {
        let path = self.into_path()?;
        path.create_file()
    }

    fn create_dir_all(&self) -> Result<(), SoftPathError> {
        fs::create_dir_all(self.into_path()?).map_err(SoftPathError::from)
    }

    fn remove(&self) -> Result<(), SoftPathError> {
        let path = self.into_path()?;
        path.remove()
    }

    fn read_to_string(&self) -> Result<String, SoftPathError> {
        let path = self.into_path()?;
        fs::read_to_string(path).map_err(SoftPathError::from)
    }

    fn write_string(&self, contents: &str) -> Result<(), SoftPathError> {
        let path = self.into_path()?;
        path.write_string(contents)
    }

    fn copy_to<P: AsRef<Path>>(&self, dest: P) -> Result<(), SoftPathError> {
        let from = self.into_path()?;
        let dest_path = dest.as_ref();
        crate::utils::check_path_traversal(dest_path)?;
        crate::utils::check_symlink_cycles(dest_path)?;
        fs::copy(&from, dest)?;
        Ok(())
    }

    fn move_to<P: AsRef<Path>>(&self, dest: P) -> Result<(), SoftPathError> {
        let from = self.into_path()?;
        let dest_path = dest.as_ref();
        crate::utils::check_path_traversal(dest_path)?;
        crate::utils::check_symlink_cycles(dest_path)?;
        fs::rename(&from, dest)?;
        Ok(())
    }

    fn is_empty(&self) -> Result<bool, SoftPathError> {
        let path = self.into_path()?;
        path.is_empty()
    }

    fn is_hidden(&self) -> Result<bool, SoftPathError> {
        let path = self.into_path()?;
        path.is_hidden()
    }

    fn file_name(&self) -> Result<Option<String>, SoftPathError> {
        // Convert to path and validate, then get the file name
        let path = self.into_path()?;
        Ok(path.as_path()
            .file_name()
            .and_then(|s| s.to_str())
            .map(String::from))
    }

    fn extension(&self) -> Result<Option<String>, SoftPathError> {
        // Convert to path and validate, then get the extension
        let path = self.into_path()?;
        Ok(path.as_path()
            .extension()
            .and_then(|s| s.to_str())
            .map(String::from))
    }

    fn parent_name(&self) -> Result<Option<String>, SoftPathError> {
        // Convert to path and validate, then get the parent name
        let path = self.into_path()?;
        Ok(path.parent()
            .and_then(|p| p.file_name())
            .and_then(|s| s.to_str())
            .map(String::from))
    }

    fn absolute(&self) -> Result<PathBuf, SoftPathError> {
        let path = self.into_path()?;
        Ok(fs::canonicalize(path)?)
    }
}