md 0.0.1

A pure-Rust Markdown parser implementation, CommonMark-compatible
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

use parser::{MarkdownParser, ParseResult, Success, End, NoParse};
use tokens::*;

use self::ListItemInfo::*;

use util::CharOps;

enum ListItemInfo {
    Ordered {
        start: uint
    }, 
    Unordered {
        marker: u8
    },
    Unknown
}

pub trait ListsParser {
    fn parse_list(&self) -> ParseResult<Block>;
}

impl<'a> ListsParser for MarkdownParser<'a> {
    fn parse_list(&self) -> ParseResult<Block> {
        let mut result = Vec::new();
        let mut current_item = Unknown;
        loop {
            let m = self.cur.mark();
            match self.parse_list_item(current_item) {
                Success((d, i)) => {
                    result.push(d);
                    current_item = i;
                    m.cancel();
                }
                NoParse | End => break
            }
        }

        match current_item {
            Unknown => NoParse,
            Ordered { start } => Success(OrderedList {
                start_index: start,
                items: result
            }),
            Unordered { .. } => Success(UnorderedList {
                items: result
            })
        }
    }
}

trait Ops {
    fn parse_list_item(&self, current_item: ListItemInfo) 
        -> ParseResult<(Document, ListItemInfo)>;
    fn parse_list_item_content(&self) -> ParseResult<Document>;
}

impl<'a> Ops for MarkdownParser<'a> {
    fn parse_list_item(&self, current_item: ListItemInfo) 
            -> ParseResult<(Document, ListItemInfo)> {
        parse_or_ret!(self.try_skip_initial_spaces());

        //match current_item {
            //Ordered { .. } => {}
            //Unordered { marker } => {}
            //Unknown => {
                //match self.parse(|c: u8| c.is_numeric()) {
                    //Success(n) => {
                        //let start: uint = from_str(n).unwrap();
                        //self.parse_list_item_content()
                            //.map(|d| (d, Ordered { start: start }))
                    //}
                //}
            //}
        //}
        unimplemented!()
    }

    fn parse_list_item_content(&self) -> ParseResult<Document> {
        unimplemented!()
    }
}