alef 0.25.33

Opinionated polyglot binding generator for Rust libraries
Documentation 
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

//! Built-in `TemplateExtension` — consumes `[[extensions.template]]` blocks.

use crate::core::backend::GeneratedFile;
use crate::core::config::Language;
use crate::core::extension::{Extension, ExtensionConfig};
use crate::core::ir::ApiSurface;
use crate::core::template_env::TemplateEnv;
use anyhow::{Context as _, Result};
use serde::Deserialize;
use std::path::{Path, PathBuf};

/// One `[[extensions.template]]` block in `alef.toml`.
#[derive(Debug, Clone, Deserialize)]
pub struct TemplateBlock {
    pub name: String,
    pub language: Language,
    pub template: PathBuf,
    pub output: PathBuf,
}

/// Parsed config for [`TemplateExtension`].
#[derive(Debug, Clone, Default)]
pub struct TemplateExtensionConfig {
    pub blocks: Vec<TemplateBlock>,
}

/// Built-in extension that renders `[[extensions.template]]` blocks.
pub struct TemplateExtension;

impl Extension for TemplateExtension {
    fn name(&self) -> &str {
        "template"
    }

    fn parse_config(&self, raw: Option<&toml::Value>) -> Result<ExtensionConfig> {
        let Some(raw) = raw else {
            return Ok(ExtensionConfig::empty());
        };
        let blocks: Vec<TemplateBlock> = raw
            .clone()
            .try_into()
            .context("failed to parse [[extensions.template]] blocks")?;
        Ok(ExtensionConfig::with_typed(
            TemplateExtensionConfig { blocks },
            Some(raw.clone()),
        ))
    }

    fn emit_for_language(
        &self,
        api: &ApiSurface,
        cfg: &ExtensionConfig,
        language: Language,
        _env: &TemplateEnv,
    ) -> Result<Vec<GeneratedFile>> {
        let Some(typed) = cfg.downcast::<TemplateExtensionConfig>() else {
            return Ok(vec![]);
        };

        let mut files = Vec::new();
        for block in typed.blocks.iter().filter(|b| b.language == language) {
            let template_src = read_template(&block.template)?;
            let mut local_env = minijinja::Environment::new();
            local_env.set_trim_blocks(true);
            local_env.set_lstrip_blocks(true);
            local_env.set_keep_trailing_newline(true);
            local_env
                .add_template_owned(block.name.clone(), template_src)
                .with_context(|| format!("failed to load template `{}`", block.template.display()))?;

            let ctx = minijinja::context! {
                crate_name => &api.crate_name,
                version => &api.version,
                language => language.to_string(),
            };

            let content = local_env
                .get_template(&block.name)
                .unwrap()
                .render(ctx)
                .with_context(|| format!("failed to render template `{}`", block.template.display()))?;

            files.push(GeneratedFile {
                path: block.output.clone(),
                content,
                generated_header: true,
            });
        }

        Ok(files)
    }
}

fn read_template(path: &Path) -> Result<String> {
    std::fs::read_to_string(path).with_context(|| format!("failed to read template file `{}`", path.display()))
}