rssg 1.4.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
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
128
129
130
131
132
133
134
135
136
137

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

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

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

fn visit_dirs(dir: &Path) -> io::Result<Vec<FilePath>> {
    let mut files = Vec::new();
    if dir.is_dir() {
        for entry in 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");

    if let Err(e) = fs::create_dir_all(&output) {
        if !matches!(e.kind(), ErrorKind::AlreadyExists) {
            error!("Failed to make `{}/`: {}", output, e);
            return false;
        }
    }

    if let Err(e) = fs::create_dir_all("temp") {
        if !matches!(e.kind(), ErrorKind::AlreadyExists) {
            error!("Failed to make `temp/`: {}", e);
            return false;
        }
    }

    
    let content_files = visit_dirs(Path::new(&content))
        .unwrap();
    let public_files = visit_dirs(Path::new(&public))
        .unwrap();

    let files = content_files.iter()
        .chain(public_files.iter()).collect::<Vec<_>>();

    let mut file_cache = cache::read_cache(Path::new(".rssg-cache"));
    let modified = cache::modified(&file_cache, &content, &public, &String::from("templates"))
        .unwrap_or_default();

    let template_modified = modified.iter()
        .any(|s| s.dir().starts_with("templates/"));

    info!("Building site");
    for file in file_cache.keys() {
        if !files.contains(&file) {
            for rule in &rules {
                if rule.matches(file) {
                    if let Ok(path) = rule.out(file) {
                        if let Err(e) = remove_file(Path::new(&path.full())) {
                            warn!("Failed to delete outdated file `{}`: {}", file.full(), e);
                        }
                    }
                }
            }
        }
    }

    info!("Generating data from `{}/`", content);
    for file in &content_files {
        if !(template_modified || modified.contains(file)) {
            debug!("Skipping file `{}`", file.full());
            continue;
        }

        debug!("Caching file `{}`", file.full());
        cache::cache_file(Path::new(&file.full()), &mut file_cache);

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

                break;
            }
        }
    }

    info!("Site generation complete, copying `{}/`", public);

    for file in &public_files {
        if !modified.contains(file) {
            debug!("Skipping file `{}`", file.full());
            continue;
        }

        debug!("Caching file `{}`", file.full());
        cache::cache_file(Path::new(&file.full()), &mut file_cache);

        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;
        }
    }

    for file in files {
        debug!("Caching file `{}`", file.full());
        cache::cache_file(Path::new(&file.full()), &mut file_cache);
    }

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

    debug!("Writing cache");
    cache::write_cache(Path::new(".rssg-cache"), file_cache);

    true
}