sieve-parser 0.1.2

Parsing the Sieve language and exporting an abstract representation
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

// use pest::error::ErrorVariant;
use pest::iterators::Pairs;
use pest::Parser;
use pest_derive::Parser;
use std::fmt;

const SIEVE_MARKER: u8 = 0xff;

#[derive(Parser)]
#[grammar = "grammar.pest"]
pub struct SieveParser;

impl SieveParser {
    pub fn serialize(pairs: &Pairs<'_, Rule>) -> Result<Vec<u8>, Box<bincode::ErrorKind>> {
        let mut buf = Vec::with_capacity(bincode::serialized_size(pairs)? as usize + 2);

        buf.push(SIEVE_MARKER);
        bincode::serialize_into(&mut buf, pairs).unwrap();
        Ok(buf)
    }
}

// use pest::error::*;

#[derive(Debug)]
pub struct ParserError {
    code: usize,
    // message: String,
    // location: (usize, usize),
}

impl fmt::Display for ParserError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let err_msg = match self.code {
            404 => "Sorry, Can not find the Page!",
            _ => "Sorry, something is wrong! Please Try Again!",
        };

        write!(f, "{}", err_msg)
    }
}

pub fn parse<'r>(src: &'r str) -> Result<Pairs<'r, Rule>, ParserError> {
    match SieveParser::parse(Rule::sieve, &src[..]) {
        Ok(pairs) => Ok(pairs),
        Err(e) => {
            eprintln!("Error: {}", e);

            // let location = match e.location {
            //     InputLocation::Pos(a) => (a, a),
            //     InputLocation::Span((a, b)) => (a, b),
            // };

            // let message = match &e.variant {
            //     ErrorVariant::ParsingError {
            //         positives,
            //         negatives: _s,
            //     } => {
            //         // println!("Error: {:?}", e);
            //         // println!("Error: {:?}", positives);
            //         // println!("Error: {:?}", negatives);
            //         "Parsing error".to_string()
            //     }
            //     ErrorVariant::CustomError { message } => message.to_string(),
            // };

            Err(ParserError {
                code: 404,
                // location,
                // message,
            })
        }
    }
}