rssg 1.3.1

A rusty static-site generator leveraging shell commands.
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

use std::fs::create_dir_all;
use std::{process::Command, str::FromStr};

use log::{error, debug};
use regex::Regex;
use serde::Deserialize;

use crate::filepath::FilePath;
use crate::tempfile::tempdir;

pub fn substitute(string: &str, path: &FilePath) -> String {
    string
        .replace("{full}", &path.full())
        .replace("{dir}", &path.dir())
        .replace("{name}", &path.name())
        .replace("{ext}", &path.ext())
        .replace("{\\{", "{{")
}

#[derive(Debug, Clone, Deserialize)]
pub struct Filter {
    command: String,
    outfile: String,
}

impl Filter {
    pub fn new(command: String, outfile: String) -> Self {
        Self { command, outfile }
    }

    pub fn tempdir(&self, path: &FilePath) -> Result<FilePath, String> {
        match FilePath::from_str(&substitute(&self.outfile, path)) {
            Ok(new) => Ok(tempdir(&self.command, &new)),

            Err(e) => Err(format!("Filter outfile {} invalid: {e}", self.outfile)),
        }
    }

    // Execute the filter.
    //
    // Logs directly to stdout/stderr. Returns true on a successful run.
    // Returns the frontmatter, if any.
    pub fn exec(&self, path: &FilePath) -> bool {
        // If outfile is an invalid path, then don't bother running the filter
        let out = match self.tempdir(path) {
            Ok(new) => new,

            Err(e) => {
                error!("{}", e);
                return false;
            }
        };

        if let Err(e) = create_dir_all(out.dir()) {
            error!("Failed to create tempfile directory structure for filter: {}", e);
            return false;
        }

        // Split command on non-quoted whitespace, removing the quotes
        let re = Regex::new("([^\"]+\"|[^\\s]+)").unwrap();
        let quotes = Regex::new("\"(.+)\"").unwrap();

        let subbed_command = substitute(&self.command, path).replace("{outfile}", &out.full());

        let mut args = re.captures_iter(&subbed_command);

        let mut command = match args.next() {
            Some(c) => c,
            None => {
                error!("`{}` is not a valid command", self.command);
                return false;
            }
        }[0]
        .to_string();

        command = quotes.replace_all(&command, "$1").to_string();

        if let Err(e) = create_dir_all(out.dir()) {
            error!("Failed to create parent directories: {}", e);
            return false;
        }

        debug!("Running filter `{}`", subbed_command);
        match Command::new(command)
            .args(
                args.map(|s| quotes.replace_all(&s[0], "$1").to_string())
                    .collect::<Vec<_>>(),
            )
            .spawn()
        {
            Ok(mut child) => match child.wait() {
                Ok(code) => {
                    if !code.success() {
                        error!(
                            "Filter `{}` exited with non-zero code: {}",
                            subbed_command,
                            code.code().unwrap_or(1)
                        );
                        return false;
                    }
                }

                Err(e) => {
                    error!("Filter `{}` failed with error: {}", subbed_command, e);
                    return false;
                }
            },

            Err(e) => {
                error!("Filter `{}` failed with error: {}", subbed_command, e);
                return false;
            }
        }

        debug!("Filter `{}` exited successfully", subbed_command);

        true
    }
}