rust_search 2.1.0

Blazingly fast file search library built in 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
139
140
141
142

use super::SearchBuilder;
use ignore::DirEntry;
use std::{cmp::Ordering, time::SystemTime};

/// custom filter fn to expose the dir entry directly
pub type FilterFn = fn(&DirEntry) -> bool;

#[derive(Clone, Copy)]
pub enum FilterType {
    Created(Ordering, SystemTime),
    Modified(Ordering, SystemTime),
    FileSize(Ordering, u64),
    Custom(FilterFn),
}

impl FilterType {
    pub fn apply(&self, dir: &DirEntry) -> bool {
        if let Ok(m) = dir.metadata() {
            match self {
                FilterType::Created(cmp, time) => {
                    if let Ok(created) = m.created() {
                        return created.cmp(time) == *cmp;
                    }
                }
                FilterType::Modified(cmp, time) => {
                    if let Ok(modified) = m.modified() {
                        return modified.cmp(time) == *cmp;
                    }
                }
                FilterType::FileSize(cmp, size_in_bytes) => {
                    return m.len().cmp(size_in_bytes) == *cmp;
                }
                FilterType::Custom(f) => return f(dir),
            }
        }
        false
    }
}

/// enum to easily convert between byte_sizes
#[derive(Debug, Clone)]
pub enum FileSize {
    /// size in bytes
    Byte(u64),
    /// size in kilobytes
    Kilobyte(f64),
    /// size in megabytes
    Megabyte(f64),
    /// size in gigabytes
    Gigabyte(f64),
    /// size in terabytes
    Terabyte(f64),
}

// helper function for FileSize conversion
fn convert(b: f64, pow: u32) -> u64 {
    (b * 1024_u64.pow(pow) as f64) as u64
}

#[allow(clippy::from_over_into)]
impl Into<u64> for FileSize {
    fn into(self) -> u64 {
        use self::FileSize::*;
        match self {
            Byte(b) => b,
            Kilobyte(b) => convert(b, 1),
            Megabyte(b) => convert(b, 2),
            Gigabyte(b) => convert(b, 3),
            Terabyte(b) => convert(b, 4),
        }
    }
}

/// import this trait to filter files
pub trait FilterExt {
    /// files created before `t`: [SystemTime]
    fn created_before(self, t: SystemTime) -> Self;
    /// files created at `t`: [SystemTime]
    fn created_at(self, t: SystemTime) -> Self;
    /// files created after `t`: [SystemTime]
    fn created_after(self, t: SystemTime) -> Self;
    /// files created before `t`: [SystemTime]
    fn modified_before(self, t: SystemTime) -> Self;
    /// files modified at `t`: [SystemTime]
    fn modified_at(self, t: SystemTime) -> Self;
    /// files modified after `t`: [SystemTime]
    fn modified_after(self, t: SystemTime) -> Self;
    /// files smaller than `size_in_bytes`: [usize]
    fn file_size_smaller(self, size: FileSize) -> Self;
    /// files equal to `size_in_bytes`: [usize]
    fn file_size_equal(self, size: FileSize) -> Self;
    /// files greater than `size_in_bytes`: [usize]
    fn file_size_greater(self, size: FileSize) -> Self;
    /// custom filter that exposes the [DirEntry] directly
    /// ```rust
    /// builder.custom_filter(|dir| dir.metadata().unwrap().is_file())
    /// ```
    fn custom_filter(self, f: FilterFn) -> Self;
}

use FilterType::*;
use Ordering::*;
impl FilterExt for SearchBuilder {
    fn created_before(self, t: SystemTime) -> Self {
        self.filter(Created(Less, t))
    }

    fn created_at(self, t: SystemTime) -> Self {
        self.filter(Created(Equal, t))
    }

    fn created_after(self, t: SystemTime) -> Self {
        self.filter(Created(Greater, t))
    }

    fn modified_before(self, t: SystemTime) -> Self {
        self.filter(Modified(Less, t))
    }

    fn modified_at(self, t: SystemTime) -> Self {
        self.filter(Modified(Equal, t))
    }

    fn modified_after(self, t: SystemTime) -> Self {
        self.filter(Modified(Greater, t))
    }

    fn file_size_smaller(self, size: FileSize) -> Self {
        self.filter(FileSize(Less, size.into()))
    }

    fn file_size_equal(self, size: FileSize) -> Self {
        self.filter(FileSize(Equal, size.into()))
    }

    fn file_size_greater(self, size: FileSize) -> Self {
        self.filter(FileSize(Greater, size.into()))
    }
    fn custom_filter(self, f: FilterFn) -> Self {
        self.filter(Custom(f))
    }
}