rcmark 0.1.0

Bindings to cmark for parsing and rendering CommonMark.
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


use {raw, Node, CmarkOptions};
use util::Binding;

use std::ffi::CString;
use libc;

pub struct Parser {
    raw: *mut raw::cmark_parser,
}

impl Parser {
    pub unsafe fn from_raw(raw: *mut raw::cmark_parser) -> Parser {
        Parser {
            raw: raw,
        }
    }

    pub fn raw(&self) -> *mut raw::cmark_parser { self.raw }

    pub fn new(options: CmarkOptions) -> Parser {
        unsafe {
            Parser::from_raw(raw::cmark_parser_new(options.raw()))
        }
    }

    pub fn feed(&mut self, data: &str) {
        unsafe {
            let cstr = CString::new(data).unwrap();
            raw::cmark_parser_feed(self.raw, cstr.as_ptr(), cstr.to_bytes().len() as libc::size_t)
        }
    }

    pub fn finish(&mut self) -> Node {
        unsafe {
            Node::from_raw(raw::cmark_parser_finish(self.raw), true)
        }
    }
}

impl Drop for Parser {
    fn drop(&mut self) {
        unsafe {
            raw::cmark_parser_free(self.raw)
        }
    }
}

// TODO: maybe implement appropriate Write traits

pub fn parse_document(doc: &str, options: CmarkOptions) -> Node {
    unsafe {
        let c_doc = CString::new(doc).unwrap();
        Node::from_raw(raw::cmark_parse_document(c_doc.as_ptr(), c_doc.to_bytes().len() as libc::size_t, options.raw()), true)
    }
}

#[cfg(test)]
mod test{
    use super::*;
    use super::super::{NodeType, DEFAULT};

    #[test]
    pub fn basic_parse() {
        let markdown = "**Hi**";
        let tree = parse_document(markdown, DEFAULT);

        assert!(tree.node_type() == NodeType::Document);
        let paragraph = tree.first_child().unwrap();
        assert!(paragraph.node_type() == NodeType::Paragraph);
        let strong = paragraph.first_child().unwrap();
        assert!(strong.node_type() == NodeType::Strong);
        let text = strong.first_child().unwrap();
        assert!(text.literal() == "Hi");
    }
}