remotefs 0.3.1

a client library to work with all file transfer protocols
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

//! ## File
//!
//! file system types related to file entries and directories

// -- ext
use std::path::{Path, PathBuf};

// -- mod
mod file_type;
mod metadata;
mod permissions;

// -- export
pub use file_type::FileType;
pub use metadata::Metadata;
pub use permissions::{UnixPex, UnixPexClass};

/// A file represents an entity in the file system

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct File {
    /// File absolute path
    pub path: PathBuf,
    /// File metadata
    pub metadata: Metadata,
}

impl File {
    /// Get absolute path
    pub fn path(&self) -> &Path {
        self.path.as_path()
    }

    /// Get file name
    pub fn name(&self) -> String {
        self.path()
            .file_name()
            .map(|x| x.to_string_lossy().to_string())
            .unwrap_or_else(|| "/".to_string())
    }

    /// Get metadata
    pub fn metadata(&self) -> &Metadata {
        &self.metadata
    }

    /// Get file type, if defined
    pub fn extension(&self) -> Option<String> {
        self.path()
            .extension()
            .map(|x| x.to_string_lossy().to_string())
    }

    /// Returns whether the file is a directory
    pub fn is_dir(&self) -> bool {
        self.metadata().is_dir()
    }

    /// Returns whether the file is a regular file
    pub fn is_file(&self) -> bool {
        self.metadata().is_file()
    }

    /// Returns whether the file is a symbolic link
    pub fn is_symlink(&self) -> bool {
        self.metadata().is_symlink()
    }

    /// Returns whether file is hidden
    pub fn is_hidden(&self) -> bool {
        self.name().starts_with('.')
    }
}

#[cfg(test)]
mod tests {

    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn should_create_file() {
        let entry = File {
            path: PathBuf::from("/bar.txt"),
            metadata: Metadata::default(),
        };
        assert_eq!(entry.path(), Path::new("/bar.txt"));
        assert_eq!(entry.name(), String::from("bar.txt"));
        assert_eq!(entry.extension().as_deref(), Some("txt"));
        assert_eq!(entry.metadata(), &Metadata::default());
        assert_eq!(entry.is_dir(), false);
        assert_eq!(entry.is_file(), true);
        assert_eq!(entry.is_hidden(), false);
    }

    #[test]
    fn should_return_is_hidden_for_hidden_files() {
        let entry = File {
            path: PathBuf::from("/.bar.txt"),
            metadata: Metadata::default(),
        };
        assert_eq!(entry.is_hidden(), true);
    }
}