ez_fs 0.1.0

A filesystem simplification over the standard library
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

//#![warn(clippy::suspicious)]
//#![warn(clippy::style)]
//#![warn(clippy::complexity)]
//#![warn(clippy::perf)]
//#![warn(clippy::pedantic)]
//#![warn(clippy::nursery)]
#![warn(clippy::cargo)]

//!# ez_fs
//!
//!`ez_fs` is a Rust library that provides convenient abstractions for working with files and directories. It aims to simplify common file and directory operations by providing easy-to-use interfaces and utilities.
//!
//!## Features
//!
//!- Wrapper for `std::fs` types, providing a simplified and more ergonomic API.
//!- Lazy-loading directory representation with the ability to cache and walk through subdirectories.
//!- Flattening directories into vectors of files for easy traversal and manipulation.
//!
//!## Getting Started
//!
//!### Reading/Writing to Files
//!```rust
//!//open file in write-only mode
//!let mut file = EzFile::create("foo.txt").unwrap();
//!file.write_all(b"bar").unwrap();
//!
//!//change to read-only
//!file.to_read().unwrap();
//!
//!let mut buf = String::new();
//!file.read_to_string(&mut buf).unwrap();
//!assert_eq!(buf, "bar");
//!```
//!
//!### Collecting Directories
//!```rust
//!//open an existing directory
//!let dir = EzDir::new(".", true).unwrap();
//!
//!//recursively can subdirectories and collect all files
//!let files = dir.flatten_all();
//!for file in files {
//!    println!("{file}")
//!}
//!```


mod file;
mod dir;
pub use crate::{dir::*, file::*};

#[cfg(test)]
mod tests {
    use std::io::{Read, Write};

    use super::*; 

    #[test]
    fn rw_test() {
        //open file in write-only mode
        let mut file = EzFile::create("foo.txt").unwrap();
        file.write_all(b"bar").unwrap();

        //change file to read-only mode
        file.to_read().unwrap();

        let mut buf = String::new();
        file.read_to_string(&mut buf).unwrap();
        assert_eq!(buf, "bar");
    }

    #[test]
    fn dir_test() {
        let dir = EzDir::new(".", true).unwrap();
        println!("{dir:?}");
    }

    #[test]
    fn iter_test() {
        let mut dir = EzDir::new(".", true).unwrap();
        for entry in dir.iter() {
            println!("{entry:?}") 
        }
        for entry in dir.iter_mut() {
            println!("{entry:?}") 
        }
        for entry in dir.into_iter() {
            println!("{entry:?}") 
        }
    }

    #[test]
    fn walk_dirs() {
        let mut dir = EzDir::new(".", true).unwrap();
        //recursively walks all subdirectories
        dir.walk(0);
        println!("{dir}");
    }

    #[test]
    fn display_test() {
        let dir = EzDir::new(".", true).unwrap();
        for elem in dir {
            println!("{elem}")
        }
    }

    #[test]
    fn flatten() {
        let dir = EzDir::new(".", true).unwrap();
        let files = dir.flatten();
        for file in files {
            println!("{file}")
        }
    }
}