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

#![allow(dead_code)]
extern crate yaml_rust;

mod frontmatter {
    use yaml_rust::{Yaml, YamlLoader};
    use yaml_rust::scanner::ScanError;

    pub fn parse(text: &str) -> Result<Option<Yaml>, ScanError> {
        println!("Parse Test: {}", text);
        match text.starts_with("---\n") {
            true => {
                println!("Starts with marker");

                let slice_after_marker = &text[4..];
                let fm_end = slice_after_marker.find("---");

                println!("{:?}", fm_end);

                if fm_end.is_none() {
                    return Ok(None)
                };

                let fm_end = fm_end.unwrap();

                println!("{:?}", fm_end);

                let yaml_str = &text[4..4+fm_end];

                println!("{:?}", yaml_str);

                let mut documents = try!(YamlLoader::load_from_str(yaml_str));

                Ok(documents.pop())
            },
            false => Ok(None)
        }
    }

    #[test]
    fn test_valid() {
        let test_string = "---\ntitle: Valid Yaml Test\n---\nsomething that's not yaml";

        let matter = parse(test_string);
        println!("Original String{:?}", test_string);
        println!("Matter: {:?}", matter);
        assert!(matter.is_ok());
        let matter = matter.unwrap();
        assert!(matter.is_some());
        let matter = matter.unwrap();
        assert!(matter.as_hash().is_some());
    }

    #[test]
    fn test_none() {
        let test_string = "something that's not yaml even if it has\n---\nsome: yaml\n--";

        let matter = parse(test_string);
        println!("Original String{:?}", test_string);
        println!("Matter: {:?}", matter);
        assert!(matter.is_ok());
        let matter = matter.unwrap();
        assert!(matter.is_none());
    }


    #[test]
    fn test_empty() {
        let test_string = "---\n---\nsomething that's not yaml";

        let matter = parse(test_string);
        println!("Original String{:?}", test_string);
        println!("Matter: {:?}", matter);
        assert!(matter.is_ok());
        let matter = matter.unwrap();
        assert!(matter.is_none());
    }
}


#[test]
fn test_tests() {
    assert_eq!(2+2, 4);
}