dpr 1.0.0

Dynamic parser and replacer. You can define rules at run time. It's possible to use peg format
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

mod to_rules;

#[derive(Debug)]
/// IR error information
pub struct Error(pub(crate) String);

#[derive(Debug)]
/// IR error information
pub(crate) struct IR {
    pos: usize,
    commands: Vec<Command>,
}

#[derive(Debug, PartialEq, Clone)]
pub(crate) struct Command(String);

impl IR {
    pub(crate) fn new(txt: &str) -> Self {
        Self {
            pos: 0,
            commands: txt
                .lines()
                .map(|l| Command(l.to_string()))
                .collect::<Vec<_>>(),
        }
    }

    fn get(mut self) -> Result<(IR, Command), Error> {
        if self.pos >= self.commands.len() {
            Err(Error("next over finished program".to_string()))
        } else {
            let cmd = self.commands[self.pos].clone();
            self.pos += 1;
            Ok((self, cmd))
        }
    }

    fn peek(&self) -> Option<Command> {
        self.commands.get(self.pos).map(|c| c.clone())
    }

    fn consume(self, val: &str) -> Result<IR, Error> {
        let (ir, cmd) = self.get()?;
        if cmd.0 == val {
            Ok(ir)
        } else {
            Err(Error(format!("expected {}, received {}", val, cmd.0)))
        }
    }
}