tent_codegen 0.2.0

Procedural macros for tent.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

mod css;
mod html;
mod indent;
mod source;
mod text;

use proc_macro::TokenStream;
use proc_macro2::{self, Span};

use crate::css::Css;
use crate::html::Html;
use crate::indent::{Indent, IndentNode};

#[derive(Clone, Copy)]
enum Mode {
    Markup,
    Body,
}

#[derive(Clone, Copy)]
enum Origin {
    Inline,
    File,
}

trait Language {
    type Line: IndentNode<Output = Self::Tree>;
    type Tree;

    fn parse(input: &str) -> Result<Vec<Self::Line>, String>;
    fn emit_markup(roots: Vec<Self::Tree>) -> Result<proc_macro2::TokenStream, String>;
    fn emit_body(roots: Vec<Self::Tree>) -> Result<proc_macro2::TokenStream, String>;
}

struct Compiler;

impl Compiler {
    fn run<L: Language>(input: &str, mode: Mode) -> Result<proc_macro2::TokenStream, String> {
        let roots = Indent::build(L::parse(input)?);
        match mode {
            Mode::Markup => L::emit_markup(roots),
            Mode::Body => L::emit_body(roots),
        }
    }

    fn drive<L: Language>(input: TokenStream, origin: Origin, mode: Mode) -> TokenStream {
        let literal: syn::LitStr = match syn::parse(input) {
            Ok(literal) => literal,
            Err(error) => return error.to_compile_error().into(),
        };
        let span = literal.span();
        let source = match origin {
            Origin::Inline => literal.value(),
            Origin::File => {
                let dir =
                    std::env::var("CARGO_MANIFEST_DIR").expect("tent: CARGO_MANIFEST_DIR unset");
                let path = std::path::Path::new(&dir).join(literal.value());
                match std::fs::read_to_string(&path) {
                    Ok(text) => text,
                    Err(err) => return Self::error(span, format!("{}: {err}", path.display())),
                }
            }
        };
        match Self::run::<L>(&source, mode) {
            Ok(tokens) => tokens.into(),
            Err(message) => Self::error(span, message),
        }
    }

    fn error(span: Span, message: impl std::fmt::Display) -> TokenStream {
        syn::Error::new(span, message).to_compile_error().into()
    }
}

#[proc_macro]
pub fn html(input: TokenStream) -> TokenStream {
    Compiler::drive::<Html>(input, Origin::Inline, Mode::Markup)
}

#[proc_macro]
pub fn html_body(input: TokenStream) -> TokenStream {
    Compiler::drive::<Html>(input, Origin::Inline, Mode::Body)
}

#[proc_macro]
pub fn load_html(input: TokenStream) -> TokenStream {
    Compiler::drive::<Html>(input, Origin::File, Mode::Markup)
}

#[proc_macro]
pub fn load_html_body(input: TokenStream) -> TokenStream {
    Compiler::drive::<Html>(input, Origin::File, Mode::Body)
}

#[proc_macro]
pub fn css(input: TokenStream) -> TokenStream {
    Compiler::drive::<Css>(input, Origin::Inline, Mode::Markup)
}

#[proc_macro]
pub fn css_body(input: TokenStream) -> TokenStream {
    Compiler::drive::<Css>(input, Origin::Inline, Mode::Body)
}

#[proc_macro]
pub fn load_css(input: TokenStream) -> TokenStream {
    Compiler::drive::<Css>(input, Origin::File, Mode::Markup)
}

#[proc_macro]
pub fn load_css_body(input: TokenStream) -> TokenStream {
    Compiler::drive::<Css>(input, Origin::File, Mode::Body)
}