gen_plugin 0.1.0

GenUI plugin analyzer and generator
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::{parse2, parse_str, Block, Stmt};
use toml_edit::{Formatted, InlineTable, Value};

mod category;
use super::PluginError;
pub use category::*;

#[derive(Debug, Clone)]
pub struct Macro {
    pub name: String,
    pub category: Category,
    pub stmts: Vec<Stmt>,
}

impl From<Macro> for toml_edit::Item {
    fn from(value: Macro) -> Self {
        let mut table = InlineTable::new();
        table.insert("category", value.category.into());
        if !value.stmts.is_empty() {
            let stmts = value.stmts;
            table.insert(
                "stmts",
                Value::String(Formatted::new(
                    quote! {
                        #(#stmts)*
                    }
                    .to_string(),
                )),
            );
        }

        toml_edit::Item::Value(Value::InlineTable(table))
    }
}

impl TryFrom<&InlineTable> for Macro {
    type Error = PluginError;

    fn try_from(value: &InlineTable) -> Result<Self, Self::Error> {
        let category = value
            .get("category")
            .ok_or_else(|| PluginError::from("Invalid category [macros.category]"))?;
        let stmts = value.get("stmts").map_or_else(
            || Err(PluginError::from("Invalid stmt [macros.stmt]")),
            |stmt| {
                let stmt_str = stmt
                    .as_str()
                    .ok_or_else(|| PluginError::from("Invalid stmts [macros.stmt]"))?;

                let stmt: Block =
                    parse2(parse_str::<TokenStream>(&format!("{{{}}}", stmt_str)).unwrap())
                        .map_err(|e| {
                            PluginError::from(format!("parse block [macros.stmt]: {}", e))
                        })?;

                Ok(stmt)
            },
        )?;

        Ok(Macro {
            name: String::new(),
            category: Category::try_from(category)?,
            stmts: stmts.stmts,
        })
    }
}

impl TryFrom<(&str, &InlineTable)> for Macro {
    type Error = PluginError;

    fn try_from(value: (&str, &InlineTable)) -> Result<Self, Self::Error> {
        let (name, table) = value;
        let mut mac = Macro::try_from(table)?;
        mac.name = name.to_string();
        Ok(mac)
    }
}

impl Macro {
    pub fn to_table(self) -> (String, toml_edit::Item) {
        (self.name.clone(), self.into())
    }
    pub fn to_expr(&self) -> TokenStream {
        if let Category::PropMacro = self.category {
            let stmt = &self.stmts;
            quote! {
                #(#stmt)*
            }
        } else {
            unimplemented!("Macro category not supported now!")
        }
    }
}