fs-mel 0.9.2

Mélodium core filesystem interaction library
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

use async_std::path::PathBuf;
use melodium_core::*;
use melodium_macro::{check, mel_function, mel_treatment};

/// Gives compition of paths.
///
/// For each streamed `path`, the outputs are filled with values:
/// - `extension` contains the part of the name after last `.`, else is none;
/// - `file_name` contains the full name of the file (`bin` for `/usr/bin/`, `bar.txt` for `foo/bar.txt`, `etc` for `etc/./`, empty for `/`);
/// - `file_stem` contains the part of the name before last `.`, or full name if starting with `.` with none in, or not containing any `.` at all;
/// - `parent` contains the path up to the parent of the designated component, else is empty (`/usr` for `/usr/bin`, empty for `/`).
#[mel_treatment(
    input path Stream<string>
    output extension Stream<Option<string>>
    output file_name Stream<Option<string>>
    output file_stem Stream<Option<string>>
    output parent Stream<Option<string>>
)]
pub async fn composition() {
    while let Ok(paths) = path
        .recv_many()
        .await
        .map(|values| TryInto::<Vec<string>>::try_into(values).unwrap())
    {
        let mut extensions = VecDeque::with_capacity(paths.len());
        let mut file_names = VecDeque::with_capacity(paths.len());
        let mut file_stems = VecDeque::with_capacity(paths.len());
        let mut parents = VecDeque::with_capacity(paths.len());
        for path in paths {
            let path = PathBuf::from(path);
            extensions.push_back(Value::Option(
                path.extension()
                    .map(|s| Box::new(Value::from(s.to_string_lossy().to_string()))),
            ));
            file_names.push_back(Value::Option(
                path.file_name()
                    .map(|s| Box::new(Value::from(s.to_string_lossy().to_string()))),
            ));
            file_stems.push_back(Value::Option(
                path.file_stem()
                    .map(|s| Box::new(Value::from(s.to_string_lossy().to_string()))),
            ));
            parents.push_back(Value::Option(
                path.parent()
                    .map(|s| Box::new(Value::from(s.to_string_lossy().to_string()))),
            ));
        }
        if let (Err(_), Err(_), Err(_), Err(_)) = futures::join!(
            extension.send_many(TransmissionValue::Other(extensions)),
            file_name.send_many(TransmissionValue::Other(file_names)),
            file_stem.send_many(TransmissionValue::Other(file_stems)),
            parent.send_many(TransmissionValue::Other(parents))
        ) {
            break;
        }
    }
}

/// Tells if path exists.
///
/// For every streamed `path`, `exists` tells if it exists and is accessible on filesystem.
/// This treatment will traverse symbolic links to query information about the destination file. In case of broken symbolic links this will give `false`.
/// If access to the directory containing the file is forbidden, this will give `false`.
#[mel_treatment(
    input path Stream<string>
    output exists Stream<bool>
)]
pub async fn exists() {
    #[cfg(feature = "real")]
    while let Ok(paths) = path
        .recv_many()
        .await
        .map(|values| TryInto::<Vec<string>>::try_into(values).unwrap())
    {
        let mut results = Vec::with_capacity(paths.len());
        for path in paths {
            results.push(PathBuf::from(path).exists().await);
        }
        check!(exists.send_many(results.into()).await);
    }
}

/// Gives metadata of path.
///
/// For every streamed `path`, tells if it is a directory, a file, and the length of the designated element.
///
#[mel_treatment(
    input path Stream<string>
    output is_dir Stream<bool>
    output is_file Stream<bool>
    output length Stream<u64>
)]
pub async fn meta() {
    #[cfg(feature = "real")]
    while let Ok(paths) = path
        .recv_many()
        .await
        .map(|values| TryInto::<Vec<string>>::try_into(values).unwrap())
    {
        let mut are_dirs = Vec::with_capacity(paths.len());
        let mut are_files = Vec::with_capacity(paths.len());
        let mut lengths = Vec::with_capacity(paths.len());
        for path in paths {
            if let Ok(metadata) = async_std::fs::metadata(path).await {
                are_dirs.push(metadata.is_dir());
                are_files.push(metadata.is_file());
                lengths.push(metadata.len());
            } else {
                are_dirs.push(false);
                are_files.push(false);
                lengths.push(0);
            }
        }
        if let (Err(_), Err(_), Err(_)) = futures::join!(
            is_dir.send_many(are_dirs.into()),
            is_file.send_many(are_files.into()),
            length.send_many(lengths.into())
        ) {
            break;
        }
    }
}

/// Gives file path extension.
///
/// Return the part of the name after last `.`, or none if there is no extension.
///
/// The extension is:
///
/// - none, if there is no file name
/// - none, if there is no embedded `.`
/// - none, if the file name begins with `.` and has no other `.`s within
/// - otherwise, the portion of the file name after the final `.`
#[mel_function]
pub fn extension(path: string) -> Option<string> {
    PathBuf::from(path)
        .extension()
        .map(|s| s.to_string_lossy().to_string())
}

/// Gives file name.
///
/// Return the full name of the file (`bin` for `/usr/bin/`, `bar.txt` for `foo/bar.txt`, `etc` for `etc/./`, empty for `/`).
///
/// If the path is a normal file, this is the file name. If it's the path of a directory, this is the directory name.
///
/// Returns none if the path terminates in `..`.
#[mel_function]
pub fn file_name(path: string) -> Option<string> {
    PathBuf::from(path)
        .file_name()
        .map(|s| s.to_string_lossy().to_string())
}

/// Gives file stem.
///
/// Return the part of the name before last `.`, or full name if starting with `.` with none in, or not containing any `.` at all.
///
/// The stem is:
///
/// - none, if there is no file name
/// - the entire file name if there is no embedded `.`
/// - the entire file name if the file name begins with `.` and has no other `.`s within
/// - otherwise, the portion of the file name before the final `.`
#[mel_function]
pub fn file_stem(path: string) -> Option<string> {
    PathBuf::from(path)
        .file_stem()
        .map(|s| s.to_string_lossy().to_string())
}

/// Gives parent path.
///
/// Return the path up to the parent of the designated component (`/usr` for `/usr/bin`, none for `/`).
///
/// Returns none if the path terminates in a root or prefix.
#[mel_function]
pub fn parent(path: string) -> Option<string> {
    PathBuf::from(path)
        .parent()
        .map(|s| s.to_string_lossy().to_string())
}