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

use std::collections::HashMap;

use crate::error::*;
use crate::filter::Filter;
use crate::parse::filter::parse_filter;
use crate::rule::Rule;
use crate::{array, field};

pub fn parse_rule(data: &toml::Table, filter_map: &HashMap<String, Filter>) -> ParseResult<Rule> {
    let rule = field!(data, rule, String);
    let fs = field!(data, filters, Array);
    let templates = array!(data, templates, String);
    let output = field!(data, output, String);

    let mut filters = Vec::new();
    for filter in fs {
        if let toml::Value::String(f) = filter {
            if let Some(f) = filter_map.get(f) {
                filters.push(f.clone());
            } else {
                return Err(ParseError::NoSuchFilter(f.clone()));
            }
        } else if let toml::Value::Table(filter) = filter {
            filters.push(parse_filter(filter)?.0);
        }
    }

    let mut rule =
        Rule::new(rule, output.clone()).map_err(|_| ParseError::BadRegex(rule.clone()))?;
    rule.filter_all(filters);
    rule.template_all(templates.into_iter().cloned().collect());

    Ok(rule)
}

pub fn parse_rules(
    rules: &Vec<toml::Value>,
    filters: &HashMap<String, Filter>,
) -> ParseResult<Vec<Rule>> {
    let mut new = Vec::new();
    for i in rules {
        if let toml::Value::Table(v) = i {
            new.push(parse_rule(v, filters)?);
        } else {
            return Err(ParseError::BadArrayItem);
        }
    }

    Ok(new)
}