projclean 0.3.1

Project non-essential files cleaner
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

use anyhow::{anyhow, Error, Result};
use regex::Regex;
use std::str::FromStr;

#[derive(Debug, Default)]
pub struct Config {
    pub rules: Vec<Rule>,
}

impl Config {
    pub fn is_rule_no_check(&self, id: &str) -> bool {
        if let Some(rule) = self.rules.iter().find(|rule| rule.id.as_str() == id) {
            rule.check.is_none()
        } else {
            false
        }
    }

    pub fn add_rule(&mut self, value: &str) -> Result<()> {
        let rule: Rule = value.parse()?;
        self.rules.push(rule);
        Ok(())
    }
}

#[derive(Debug)]
pub struct Rule {
    id: String,
    purge: Regex,
    check: Option<Regex>,
}

impl Rule {
    pub fn get_id(&self) -> &str {
        &self.id
    }

    pub fn test_purge(&self, name: &str) -> bool {
        self.purge.is_match(name)
    }

    pub fn test_check(&self, name: &str) -> bool {
        match self.check.as_ref() {
            Some(check) => check.is_match(name),
            None => false,
        }
    }
}

impl FromStr for Rule {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split('@').collect();
        let (purge, check) = match parts.len() {
            1 => (parts[0].trim(), ""),
            2 => (parts[0].trim(), parts[1].trim()),
            _ => ("", ""),
        };
        let err = || anyhow!("Invalid rule '{}'", s);
        if purge.is_empty() {
            return Err(err());
        }
        Ok(Rule {
            id: s.to_string(),
            purge: to_regex(purge).map_err(|_| err())?,
            check: if check.is_empty() {
                None
            } else {
                let check = to_regex(check).map_err(|_| err())?;
                Some(check)
            },
        })
    }
}

fn to_regex(value: &str) -> Result<Regex> {
    let re = if value
        .chars()
        .all(|v| v.is_alphanumeric() || v == '.' || v == '-' || v == '_')
    {
        format!("^{}$", value.replace('.', "\\."))
    } else {
        value.to_string()
    };
    Regex::new(&re).map_err(|_| anyhow!("Invalid regex value '{}'", value))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_rule() {
        let rule: Rule = "target".parse().unwrap();
        assert!(rule.test_purge("target"));
        assert!(!rule.test_purge("-target"));
        assert!(!rule.test_purge("target-"));
        assert!(!rule.test_purge("Target"));

        let rule: Rule = "^(Debug|Release)$@\\.sln$".parse().unwrap();
        assert!(rule.test_purge("Debug"));
        assert!(!rule.test_purge("Debug-"));
        assert!(!rule.test_purge("-Debug"));
        assert!(rule.test_check("App.sln"));
    }
}