spin_templates/
renderer.rs

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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
use anyhow::anyhow;
use lazy_static::lazy_static;
use std::{collections::HashMap, path::PathBuf};

use crate::writer::{TemplateOutput, TemplateOutputs};

// A template that has been evaluated and parsed, with all the values
// it needs to render.
pub(crate) struct TemplateRenderer {
    pub render_operations: Vec<RenderOperation>,
    pub parameter_values: HashMap<String, String>,
}

pub(crate) enum TemplateContent {
    Template(liquid::Template),
    Binary(Vec<u8>),
}

pub(crate) enum RenderOperation {
    AppendToml(PathBuf, TemplateContent),
    MergeToml(PathBuf, MergeTarget, TemplateContent), // file to merge into, table to merge into, content to merge
    WriteFile(PathBuf, TemplateContent),
    CreateDirectory(PathBuf, std::sync::Arc<liquid::Template>),
}

pub(crate) enum MergeTarget {
    Application(&'static str),
}

impl TemplateRenderer {
    pub(crate) fn render(self) -> anyhow::Result<TemplateOutputs> {
        let globals = self.renderer_globals();

        let outputs = self
            .render_operations
            .into_iter()
            .map(|so| so.render(&globals))
            .collect::<anyhow::Result<Vec<_>>>()?;

        if outputs.is_empty() {
            return Err(anyhow!("Nothing to create"));
        }

        Ok(TemplateOutputs::new(outputs))
    }

    fn renderer_globals(&self) -> liquid::Object {
        let mut object = liquid::Object::new();

        for (k, v) in &self.parameter_values {
            object.insert(
                k.to_owned().into(),
                liquid_core::Value::Scalar(v.to_owned().into()),
            );
        }

        object
    }
}

impl RenderOperation {
    fn render(self, globals: &liquid::Object) -> anyhow::Result<TemplateOutput> {
        match self {
            Self::WriteFile(path, content) => {
                let rendered = content.render(globals)?;
                Ok(TemplateOutput::WriteFile(path, rendered))
            }
            Self::AppendToml(path, content) => {
                let rendered = content.render(globals)?;
                let rendered_text = String::from_utf8(rendered)?;
                Ok(TemplateOutput::AppendToml(path, rendered_text))
            }
            Self::MergeToml(path, target, content) => {
                let rendered = content.render(globals)?;
                let rendered_text = String::from_utf8(rendered)?;
                let MergeTarget::Application(target_table) = target;
                Ok(TemplateOutput::MergeToml(path, target_table, rendered_text))
            }
            Self::CreateDirectory(path, template) => {
                let rendered = template.render(globals)?;
                let path = path.join(rendered); // TODO: should we validate that `rendered` was relative?`
                Ok(TemplateOutput::CreateDirectory(path))
            }
        }
    }
}

impl TemplateContent {
    pub(crate) fn infer_from_bytes(
        raw: Vec<u8>,
        parser: &liquid::Parser,
    ) -> anyhow::Result<TemplateContent> {
        match string_from_bytes(&raw) {
            None => Ok(TemplateContent::Binary(raw)),
            Some(s) => {
                match parser.parse(&s) {
                    Ok(t) => Ok(TemplateContent::Template(t)),
                    Err(e) => match understand_liquid_error(e) {
                        TemplateParseFailure::Other(_e) => {
                            // TODO: emit a warning?
                            Ok(TemplateContent::Binary(raw))
                        }
                        TemplateParseFailure::UnknownFilter(id) => {
                            Err(anyhow!("internal error in template: unknown filter '{id}'"))
                        }
                    },
                }
            }
        }
    }

    fn render(self, globals: &liquid::Object) -> anyhow::Result<Vec<u8>> {
        match self {
            Self::Template(t) => {
                let text = t.render(globals)?;
                Ok(text.bytes().collect())
            }
            Self::Binary(v) => Ok(v),
        }
    }
}

// TODO: this doesn't truly belong in a module that claims to be about
// rendering but the only thing that uses it is the TemplateContent ctor
fn string_from_bytes(bytes: &[u8]) -> Option<String> {
    match std::str::from_utf8(bytes) {
        Ok(s) => Some(s.to_owned()),
        Err(_) => None, // TODO: try other encodings!
    }
}

enum TemplateParseFailure {
    UnknownFilter(String),
    Other(liquid::Error),
}

lazy_static! {
    static ref UNKNOWN_FILTER: regex::Regex =
        regex::Regex::new("requested filter=(\\S+)").expect("Invalid unknown filter regex");
}

fn understand_liquid_error(e: liquid::Error) -> TemplateParseFailure {
    let err_str = e.to_string();

    // They should use typed errors like we, er, don't
    match err_str.lines().next() {
        None => TemplateParseFailure::Other(e),
        Some("liquid: Unknown filter") => match UNKNOWN_FILTER.captures(&err_str) {
            None => TemplateParseFailure::Other(e),
            Some(captures) => match captures.get(1) {
                None => TemplateParseFailure::Other(e),
                Some(id) => TemplateParseFailure::UnknownFilter(id.as_str().to_owned()),
            },
        },
        _ => TemplateParseFailure::Other(e),
    }
}