lunar-lib 0.1.0

Common utilities for lunar applications
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

use crate::formatter::{block::BlockMode, condition::ConditionalToken};

pub(super) enum Lex<'a> {
    Text(&'a str),
    BlockStart,
    BlockEnd,
    Variable,
    Conditional,
    Prefix,
    Suffix,
    Fallback,
    Or,
    And,
    Not,
    Space,
    Escape,
}

impl<'a> Lex<'a> {
    pub fn to_str(&self) -> &'a str {
        match self {
            Lex::Text(str) => str,
            Lex::BlockStart => "{",
            Lex::BlockEnd => "}",
            Lex::Variable => "$",
            Lex::Conditional => "@",
            Lex::Prefix => "<",
            Lex::Suffix => ">",
            Lex::Fallback => "?",
            Lex::Or => "|",
            Lex::And => "&",
            Lex::Not => "!",
            Lex::Space => " ",
            Lex::Escape => "\\",
        }
    }

    pub(super) fn to_block_mode(&self) -> Option<BlockMode> {
        match self {
            Lex::Conditional => Some(BlockMode::Condition),
            Lex::Prefix => Some(BlockMode::Prefix),
            Lex::Suffix => Some(BlockMode::Suffix),
            Lex::Fallback => Some(BlockMode::Fallback),
            _ => None,
        }
    }

    pub(super) fn to_condition_token(&self) -> Option<ConditionalToken<'a>> {
        match self {
            Lex::Or => Some(ConditionalToken::Or),
            Lex::And => Some(ConditionalToken::And),
            Lex::Not => Some(ConditionalToken::Not),
            _ => None,
        }
    }
}

pub(super) fn lex_str<'a>(str: &'a str) -> Vec<Lex<'a>> {
    let mut lex = Vec::new();

    let mut text_start: Option<usize> = None;

    for (i, byte) in str.bytes().enumerate() {
        let new_lex = match byte {
            b'{' => Some(Lex::BlockStart),
            b'}' => Some(Lex::BlockEnd),
            b'$' => Some(Lex::Variable),
            b'@' => Some(Lex::Conditional),
            b'<' => Some(Lex::Prefix),
            b'>' => Some(Lex::Suffix),
            b'?' => Some(Lex::Fallback),
            b'|' => Some(Lex::Or),
            b'&' => Some(Lex::And),
            b'!' => Some(Lex::Not),
            b' ' => Some(Lex::Space),
            b'\\' => Some(Lex::Escape),
            _ => None,
        };

        if let Some(token) = new_lex {
            if let Some(start) = text_start.take() {
                lex.push(Lex::Text(&str[start..i]));
            }
            lex.push(token);
        } else {
            text_start.get_or_insert(i);
        }
    }

    if let Some(start) = text_start.take() {
        lex.push(Lex::Text(&str[start..]));
    }

    lex
}