rssg 1.3.0

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

use std::fs::{copy, create_dir_all};
use std::{fs, io, path::Path, str::FromStr};

use log::{info, error, debug};

use crate::filepath::FilePath;
use crate::rule::Rule;

fn visit_dirs(dir: &Path) -> io::Result<Vec<FilePath>> {
    let mut files = Vec::new();
    if dir.is_dir() {
        for entry in fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_dir() {
                files.append(&mut visit_dirs(&path)?);
            } else {
                files.push(FilePath::from_str(&entry.path().to_string_lossy()).unwrap());
            }
        }
    }

    Ok(files)
}

pub fn build(rules: Vec<Rule>, content: String, output: String, public: String) -> bool {
    _ = fs::remove_dir_all(&output);
    _ = fs::remove_dir_all("temp");

    fs::create_dir_all(&output).unwrap();
    fs::create_dir_all("temp").unwrap();

    let files = visit_dirs(Path::new(&content))
        .unwrap()
        .iter()
        .map(|f| f.clone().strip_prefix("/"))
        .collect::<Vec<_>>();

    info!("Building site");
    info!("Generating data from `{}/`", content);
    for file in files {
        info!("Building file {}", file.full());
        for rule in &rules {
            if rule.matches(&file) {
                debug!("Found matching rule");
                if !rule.exec(file, &content, &output) {
                    error!("Rule failed, aborting");
                    return false;
                }

                break;
            }
        }
    }

    info!("Site generation complete, copying `{}/`", public);
    let files = visit_dirs(Path::new(&public))
        .unwrap()
        .iter()
        .map(|f| f.clone().strip_prefix("/"))
        .collect::<Vec<_>>();

    for file in files {
        if let Err(e) = create_dir_all(file.clone().strip_prefix(&public).prefix(&output).dir()) {
            error!("Failed to create {}: {}", file.dir(), e);
            return false;
        }

        if let Err(e) = copy(
            file.full(),
            file.clone().strip_prefix(&public).prefix(&output).full(),
        ) {
            error!("Failed to copy {file}: {}", e);
            return false;
        }
    }

    info!("Done building site, output at `{}/`", output);

    true
}