detect_rs 0.1.0

Detect files on your filesystem using arbitrary expression language criteria
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

mod eval;
pub mod expr;
mod parser;
pub mod predicate;
mod util;

use std::path::Path;

use combine::stream::position::{self, SourcePosition};
use expr::{ContentPredicate, Expr, MetadataPredicate, NamePredicate};
use predicate::{Predicate, ProcessPredicate};

use crate::eval::eval;

pub fn parse<'a>(
    s: &'a str,
) -> Result<
    Expr<Predicate<NamePredicate, MetadataPredicate, ContentPredicate, ProcessPredicate>>,
    combine::easy::Errors<char, &'a str, SourcePosition>,
> {
    let (e, _source_position) =
        combine::EasyParser::easy_parse(&mut parser::or(), position::Stream::new(&s[..]))?;

    Ok(e)
}

pub async fn parse_and_run<F: FnMut(&Path)>(
    root: String,
    s: String,
    mut on_match: F,
) -> Result<(), anyhow::Error> {
    use walkdir::WalkDir;

    // NOTE: top level should be and, I think - rain says that binds most tightly
    match parse(&s) {
        Ok(e) => {
            // TODO: debug loggin switch? tracing? idk hell yes
            // println!("expr: {:?}", e);
            let walker = WalkDir::new(root).into_iter();
            for entry in walker {
                let entry = entry?;
                let path = entry.path();

                let is_match = eval(&e, path).await?;

                if is_match {
                    on_match(path);
                }
            }

            Ok(())
        }
        Err(err) => panic!("parse error: {}", err),
    }
}