waltz 0.4.1

Extract code blocks from Markdown and save them as files.
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
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

use std::default::Default;
use std::fs::{create_dir_all, File, OpenOptions};
use std::io::Write;
use std::path::Path;

use code_flags::CodeFlags;

/// Markdown code block
///
/// This is the 'final' representation, with the filename and code already
/// extracted.
#[derive(Debug, Clone)]
pub struct CodeBlock {
    flags: Option<CodeFlags>,
    content: String,
}

impl Default for CodeBlock {
    fn default() -> Self {
        CodeBlock {
            flags: None,
            content: String::new(),
        }
    }
}

impl CodeBlock {
    /// Set the code block's filename
    pub(crate) fn set_flags(&mut self, flags: CodeFlags) {
        self.flags = Some(flags);
    }

    /// Does the code block have a (non-empty) filename?
    pub fn has_filename(&self) -> bool {
        self.filename().is_some()
    }

    /// Get the filename if it exists
    pub fn filename(&self) -> Option<String> {
        if let Some(ref flags) = self.flags {
            flags.filename()
        } else {
            None
        }
    }

    /// Get the `run` flag if it exists
    pub fn run(&self) -> Option<String> {
        if let Some(ref flags) = self.flags {
            flags.run()
        } else {
            None
        }
    }

    /// Get the codeblock's content
    pub fn content(&self) -> &str {
        &self.content
    }

    /// Add to the code block's content
    pub(crate) fn push_content(&mut self, new_content: &str) {
        self.content.push_str(new_content);
    }

    /// Write codeblock to a file in directory `root`
    pub fn to_file<P: AsRef<Path>>(&self, root: P) -> Result<File, ::failure::Error> {
        let filename = if let Some(f) = self.filename() {
            f
        } else {
            bail!("Can't create file from code block with empty file name")
        };

        let path = Path::new(root.as_ref()).join(filename);
        let parent = match path.parent() {
            Some(p) => p,
            None => bail!("Can't create file for code block, path has no parent directory"),
        };

        create_dir_all(parent)?;

        let mut f = OpenOptions::new().create(true).append(true).open(&path)?;
        f.write_all(self.content.as_bytes())?;

        info!("Wrote file {:?}", path);
        Ok(f)
    }
}

#[cfg(test)]
mod test {
    extern crate unindent;
    use self::unindent::unindent;

    #[test]
    fn parsing() {
        let example = unindent(
            r#"
        # Lorem ipsum

        ## Shell

        ```bash
        $ echo "yeah!"
        ```

        ## A Rust example

        ```rust,file=src/lib.rs
        fn main() {
            println!("Dolor sit amet");
        }
        ```
        "#,
        );

        let markdown = ::pulldown_cmark::Parser::new(&example);
        let code_blocks = ::extract_code_blocks(markdown).unwrap();

        assert_eq!(code_blocks.len(), 2);
        assert!(!code_blocks[0].has_filename());
        assert_eq!(code_blocks[0].content().trim(), r#"$ echo "yeah!""#);

        assert_eq!(code_blocks[1].filename(), Some("src/lib.rs".to_string()));
        assert!(code_blocks[1].content().contains("Dolor sit amet"));
    }
}