postar 0.1.0

A local email filtering service
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

use std::ops::Range;

use crate::{
    // dsl::name_resolver::{self, NameResolver},
    dsl::resolver::{ResolutionError, Resolve, Resolver},
    process::Rule,
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Node<T> {
    pub value: T,
    pub span: Range<usize>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ParserConfig {
    pub folder_definitions: Vec<Node<ParserFolder>>,
    pub rule_definitions: Vec<Node<ParserRule>>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ParserDefinition {
    Rule(Node<ParserRule>),
    Folder(Node<ParserFolder>),
}

/// Maps to [crate::process::Rule]
#[derive(Debug, Clone, PartialEq)]
pub struct ParserRule {
    pub name: String,
    pub matcher: Node<ParserMatcher>,
    pub action: Node<ParserAction>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum ParserRuleValue {
    Matcher(Node<ParserMatcher>),
    Action(Node<ParserAction>),
}

/// Maps to [crate::process::Matcher]
#[derive(Debug, Clone, PartialEq)]
pub enum ParserMatcher {
    And(Node<ParserMatchList>),
    Or(Node<ParserMatchList>),
    Not(Box<Node<ParserMatcher>>),

    Subject(Node<ParserStringMatcher>),
    From(Node<ParserStringMatcher>),
    To(Node<ParserStringMatcher>),
    Body(Node<ParserStringMatcher>),
}

/// Maps to [crate::process::StringMatcher]
#[derive(Debug, Clone, PartialEq)]
pub enum ParserStringMatcher {
    Contains(String),
    StartsWith(String),
    Equals(String),
    Regex(String),
}

#[derive(Debug, Clone, PartialEq)]
pub struct ParserMatchList {
    pub list: Vec<Node<ParserMatcher>>,
}

/// Maps to [crate::process::Action]
#[derive(Debug, Clone, PartialEq)]
pub enum ParserAction {
    Delete,
    MoveTo(Node<ParserIdentifier>),
}

#[derive(Debug, Clone, PartialEq)]
pub struct ParserIdentifier {
    pub identifier: String,
}

/// Maps to [crate::inbox::Folder]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParserFolder {
    pub identifier: String,
    pub name: String,
}

impl ParserConfig {
    pub fn to_rules(self) -> Result<Vec<Rule>, ResolutionError> {
        let ctx = Resolver::build(&self)?;

        let rules = self
            .rule_definitions
            .into_iter()
            .map(|x| x.resolve(&ctx))
            .collect::<Result<Vec<_>, _>>()?;

        Ok(rules)
    }
}