fsnav 0.4.0

A fast terminal file navigator with advanced features: search, preview, bookmarks, and split-pane view
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

use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct FileEntry {
    pub name: String,
    pub path: PathBuf,
    pub is_dir: bool,
    pub is_accessible: bool,
    pub is_symlink: bool,
    pub permissions: Option<u32>,
    pub owner: Option<String>,
    pub group: Option<String>,
    #[allow(dead_code)]
    pub uid: Option<u32>,
    #[allow(dead_code)]
    pub gid: Option<u32>,
}

impl FileEntry {
    pub fn display_name(&self) -> String {
        let icon = if self.is_symlink {
            "🔗"
        } else if self.is_dir {
            "📁"
        } else {
            "📄"
        };

        let name = if self.is_dir && !self.is_symlink {
            format!("{}/", self.name)
        } else {
            self.name.clone()
        };

        format!("{} {}", icon, name)
    }

    pub fn permissions_string(&self) -> String {
        match self.permissions {
            Some(mode) => {
                let user = (mode >> 6) & 0b111;
                let group = (mode >> 3) & 0b111;
                let other = mode & 0b111;

                let to_rwx = |p: u32| {
                    format!(
                        "{}{}{}",
                        if p & 4 != 0 { "r" } else { "-" },
                        if p & 2 != 0 { "w" } else { "-" },
                        if p & 1 != 0 { "x" } else { "-" }
                    )
                };

                format!("{}{}{}", to_rwx(user), to_rwx(group), to_rwx(other))
            }
            None => "---------".to_string(),
        }
    }

    pub fn ownership_string(&self) -> String {
        format!(
            "{} {}",
            self.owner.as_ref().unwrap_or(&"-".to_string()),
            self.group.as_ref().unwrap_or(&"-".to_string())
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_file_entry_display() {
        let dir_entry = FileEntry {
            name: "test_dir".to_string(),
            path: PathBuf::from("/test/test_dir"),
            is_dir: true,
            is_accessible: true,
            is_symlink: false,
            permissions: Some(0o755),
            owner: Some("user".to_string()),
            group: Some("group".to_string()),
            uid: Some(1000),
            gid: Some(1000),
        };
        assert_eq!(dir_entry.display_name(), "📁 test_dir/");

        let file_entry = FileEntry {
            name: "test.txt".to_string(),
            path: PathBuf::from("/test/test.txt"),
            is_dir: false,
            is_accessible: true,
            is_symlink: false,
            permissions: Some(0o644),
            owner: Some("user".to_string()),
            group: Some("group".to_string()),
            uid: Some(1000),
            gid: Some(1000),
        };
        assert_eq!(file_entry.display_name(), "📄 test.txt");
    }

    #[test]
    fn test_permissions_string() {
        let entry = FileEntry {
            name: "test".to_string(),
            path: PathBuf::from("/test"),
            is_dir: false,
            is_accessible: true,
            is_symlink: false,
            permissions: Some(0o755),
            owner: None,
            group: None,
            uid: None,
            gid: None,
        };
        assert_eq!(entry.permissions_string(), "rwxr-xr-x");
    }
}