aldoc 0.2.0

CLI and library for parsing and compiling Aldoc Markdown documents
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

use nom::{
    branch::alt,
    bytes::complete::{tag, take, take_while1},
    combinator::{verify, map},
    sequence::{delimited, terminated},
    IResult
};
use numerals::roman::Numeral;

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct ListToken {
    pub wrapper: TokenWrapper,
    // If the enumerator is `None` then it is unnumbered
    pub enumerator: Option<TokenEnumerator>,
}
impl ListToken {
    fn unnumbered(wrapper: &str) -> ListToken {
        ListToken {
            wrapper: TokenWrapper(String::from(wrapper)),
            enumerator: None,
        }
    }
    pub fn bullet() -> ListToken {
        ListToken::unnumbered("*")
    }
    pub fn plus() -> ListToken {
        ListToken::unnumbered("+")
    }
    pub fn hyphen() -> ListToken {
        ListToken::unnumbered("-")
    }
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum TokenEnumerator {
    Numerical,
    Roman(bool),        // uppercase or lowercase
    Alphabetical(bool), // uppercase or lowercase
}
impl TokenEnumerator {
    pub fn latex(&self) -> String {
        use TokenEnumerator::*;

        let s = match self {
            Numerical           => "\\arabic",
            Alphabetical(true)  => "\\Alph",
            Alphabetical(false) => "\\alph",
            Roman(true)     	=> "\\Roman",
            Roman(false)    	=> "\\roman",
        };
        format!("{}*", s)
    }
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct TokenWrapper(String);

impl TokenWrapper {
    pub fn label(&self, enumerator: &str) -> String {
        self.0.replace("{}", enumerator)
    }
    pub fn unnumbered(&self) -> String {
        self.0.clone()
    }
}

#[derive(Debug, Clone)]
pub struct List {
    pub vec: Vec<ListItem>,
    pub token: ListToken
}

#[derive(Debug, Clone)]
pub struct ListItem {
    pub text: String, 
    pub list: Option<List>
}

fn parse_unnumbered_token(input: &str) -> IResult<&str, ListToken> {
    let bullet = 
        map(
            tag("*"),
            |_| ListToken::bullet()
        );
    let plus = 
        map(
            tag("+"),
            |_| ListToken::plus()
        );
    let hyphen = 
        map(
            tag("-"),
            |_| ListToken::hyphen()
        );
    alt((
        bullet, 
        plus, 
        hyphen
    ))(input)
}
fn parse_enumerator(input: &str) -> IResult<&str, TokenEnumerator> {
    let numerical =
        map(
            take_while1(|c: char| c.is_digit(10)),
            |_| TokenEnumerator::Numerical
        );
    let alphabetic = 
        map(
            verify(
                take(1u8),
                |c: &str| {
                    let c = c.chars().nth(0).unwrap();
                    c.is_alphabetic()
                }
            ),
            |a: &str| {
                let ch = a.chars().nth(0).unwrap();
                TokenEnumerator::Alphabetical(ch.is_uppercase())
            }
        );
    let roman =
        map(
            take_while1(|r| Numeral::from_char(r).is_some()),
            |n: &str| {
                let ch = n.chars().nth(0).unwrap();
                TokenEnumerator::Roman(ch.is_uppercase())
            }
        );
    alt((
        numerical,
        roman,
        alphabetic,
    ))(input)
}

fn parse_enumerated_token(input: &str) -> IResult<&str, ListToken> {
    // TODO move all of these to their own functions
    let symbol_terminated = |symbol: &'static str|
        map(
            terminated(
                parse_enumerator,
                tag(symbol)
            ),
            move |e| (format!("{{}}{}", symbol), e)
        );
    let symbol_delimited = |start: &'static str, end: &'static str|
        map(
            delimited(
                tag(start),
                parse_enumerator,
                tag(end),
            ),
            move |e| (format!("{}{{}}{}", start, end), e)
        );
    let dot_terminated = symbol_terminated(".");
    let hyphen_terminated = symbol_terminated("-");
    let parenthesis_terminated = symbol_terminated(")");

    let parenthesis_delimited = symbol_delimited("(", ")");
    
    map(
        alt((
            dot_terminated,
            hyphen_terminated,
            parenthesis_terminated,
            parenthesis_delimited,
        )),
        |(wrapper, enumerator)| 
            ListToken { 
                wrapper: TokenWrapper(wrapper), 
                enumerator: Some(enumerator) 
            }
    )(input)
}
// this parses the full token.
pub fn parse_item_token(input: &str) -> IResult<&str, ListToken> {
    alt((
        parse_unnumbered_token,
        parse_enumerated_token,
    ))(input)
}