regast-syntax 0.1.0

Lossless syntax tree for the regast regular expression engine
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

use std::convert::Infallible;

use super::rep_name;
use crate::{AstKind, Cursor, Flow, Pattern, Visitor, visit};

impl Pattern {
    #[must_use]
    pub fn to_sexpr(&self) -> String {
        match visit(self, SExpr::default()) {
            Ok(output) => output,
            Err(error) => match error {},
        }
    }
}

#[derive(Default)]
struct SExpr {
    stack: Vec<SExprFrame>,
    root: Option<String>,
}

struct SExprFrame {
    head: String,
    children: Vec<String>,
}

impl Visitor for SExpr {
    type Output = String;
    type Err = Infallible;

    fn enter(&mut self, node: Cursor<'_>) -> Result<Flow, Self::Err> {
        self.stack.push(SExprFrame {
            head: node_head(node),
            children: Vec::new(),
        });
        Ok(Flow::Continue)
    }

    fn leave(&mut self, _node: Cursor<'_>) -> Result<(), Self::Err> {
        let frame = self.stack.pop().expect("enter precedes leave");
        let completed = if frame.children.is_empty() {
            format!("({})", frame.head)
        } else {
            format!("({} {})", frame.head, frame.children.join(" "))
        };
        if let Some(parent) = self.stack.last_mut() {
            parent.children.push(completed);
        } else {
            self.root = Some(completed);
        }
        Ok(())
    }

    fn finish(self) -> Result<Self::Output, Self::Err> {
        Ok(self.root.expect("pattern always has a root"))
    }
}

fn node_head(node: Cursor<'_>) -> String {
    match node.kind() {
        AstKind::Empty => "empty".into(),
        AstKind::Anchor { kind } => format!("anchor {kind:?}"),
        AstKind::Literal { c, .. } => format!("literal {c:?}"),
        AstKind::Dot => "dot".into(),
        AstKind::Class { .. } => format!("class {:?}", node.text()),
        AstKind::Group { .. } => "group".into(),
        AstKind::Alt { .. } => "alt".into(),
        AstKind::Concat { .. } => "concat".into(),
        AstKind::Repeat { kind, greedy, .. } => format!(
            "repeat {} {}",
            rep_name(*kind),
            if *greedy { "greedy" } else { "lazy" }
        ),
    }
}