blarse 0.1.0

A lightweight parsing framework for blex
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

pub use blex::*;
use blex::empty_token;
pub use super::parse_token;
use std::fmt;
use std::ops::Range;

#[derive(Clone)]
/// Represents a tree of tokens. A tree, viewed in total, will likely have the
/// same tokens in the same order as a vector of tokens on which it is based.
/// A tree can either have a single token or a list of child parse tokens. This
/// allows trees to be built from single parse tokens.
pub enum ParseNode<'a> {
    Leaf(Range<usize>),
    Branch(Vec<ParseToken<'a>>)
}

#[derive(Clone)]
pub struct ParseToken<'a> {
    pub node: ParseNode<'a>,
    pub body: &'a str,
    pub tags: Vec<&'a str>
}

impl fmt::Display for ParseToken<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.write_indented(0, f)?;
        Ok(())
    }
}

pub fn print_parse_tokens(tokens: Vec<ParseToken>) {
    for tok in tokens {
        println!("{}", tok);
    }
}

impl <'a> ParseToken<'a> {
    fn write_indented(&self, tabs: usize, f: &mut fmt::Formatter) -> fmt::Result {
        for _ in 0..tabs {
            write!(f, "\t")?;
        }
        match &self.node {
            ParseNode::Leaf(r) => {
                writeln!(f, "{0} {1}", &self.body[r.clone()], format_tags(self.tags.clone()))?;
            },
            ParseNode::Branch(children) => {
                writeln!(f, "{}:", format_tags(self.tags.clone()))?;
                for pt in children {
                    pt.write_indented(tabs + 1, f)?;
                }
            }
        }
        Ok(())
    }

    pub fn new_leaf(tok: Token<'a>) -> ParseToken<'a> {
        ParseToken { 
            node: ParseNode::Leaf(tok.indices.clone()), 
            body: tok.body, 
            tags: tok.tags.clone() 
        }
    }

    pub fn new_branch(children: Vec<ParseToken<'a>>, body: &'a str, tags:Vec<&'a str>) -> ParseToken<'a> {
        ParseToken {
            node: ParseNode::Branch(children),
            body,
            tags
        }
    }

    pub fn new_branch_from_first(children: Vec<ParseToken<'a>>, tags:Vec<&'a str>) -> ParseToken<'a> {
        let body = children[0].body;
        ParseToken {
            node: ParseNode::Branch(children),
            body,
            tags
        }
    }

    pub fn content(&'a self) -> &'a str {
        if let Some(cr) = self.content_range() {
            &self.body[cr]
        } else {
            ""
        }
    }

    pub fn content_range(&'a self) -> Option<Range<usize>> {
        match &self.node {
            ParseNode::Leaf(inds) => {
                Some(inds.clone())
            },
            ParseNode::Branch(children) => {
                let known_ranges: Vec<Range<usize>> = children.iter()
                    .flat_map(|item| item.content_range()).collect();
                if let Some(last) = known_ranges.last() {
                    Some(known_ranges[0].start..last.end)
                } else {
                    None
                }
            }
        }
    }

    pub fn has_tag(&self, tag: &str) -> bool {
        self.tags.contains(&tag)
    }
}

pub fn empty_parse_token() -> ParseToken<'static> {
    ParseToken::new_leaf(empty_token())
}

pub fn tokens_to_parse_tokens(tokens: Vec<Token>) -> Vec<ParseToken> {
    let mut to_ret: Vec<ParseToken> = tokens.iter().map(|t| ParseToken::new_leaf(t.clone())).collect();
    to_ret.push(empty_parse_token());
    to_ret
}