xrune 1.3.1

Declarative UI DSL framework with pluggable codegen backends
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

use proc_macro2::TokenStream;
use quote::quote;

use xrune_nexus::ds_node::DsTreeRef;
use xrune_nexus::ds_node::ds_attr::DsAttr;
use xrune_nexus::ds_rune::DsRune;
use xrune_nexus::ds_rune::decipher::decipher;

/// DefaultRune — generates println-based debug output (default debug output).
pub struct DefaultRune {
    tokens: TokenStream,
    parent_name: String,
}

impl Default for DefaultRune {
    fn default() -> Self {
        Self::new()
    }
}

impl DefaultRune {
    pub fn new() -> Self {
        Self {
            tokens: TokenStream::new(),
            parent_name: String::new(),
        }
    }
}

impl DsRune for DefaultRune {
    fn inscribe_root(&mut self, parent_expr: &syn::Expr) {
        let parent_string = "parent".to_string();
        self.tokens.extend(quote! {
            println!("let {} = {:?}", #parent_string, #parent_expr);
        });
        self.parent_name = "parent".to_string();
    }

    fn inscribe_widget(
        &mut self,
        name: &syn::Ident,
        attrs: &[DsAttr],
        _enchants: &[syn::Expr],
        children: &[DsTreeRef],
    ) {
        let name_string = name.to_string();
        let parent_name = &self.parent_name;

        self.tokens.extend(quote! {
            println!("let {} = obj::new({})", #name_string, #parent_name);
        });

        for attr in attrs {
            let attr_name = attr.name.to_string();
            let attr_value = &attr.value;
            self.tokens.extend(quote! {
                println!("{}.set_{}({:?})", #name_string, #attr_name, #attr_value);
            });
        }

        let prev_parent = self.parent_name.clone();
        self.parent_name = name_string;
        for child in children {
            decipher(child, self);
        }
        self.parent_name = prev_parent;
    }

    fn inscribe_if(&mut self, condition: &syn::Expr, children: &[DsTreeRef]) {
        let con = quote!(#condition).to_string();
        self.tokens.extend(quote! {
            println!("if {} {{", #con);
        });

        for child in children {
            decipher(child, self);
        }

        self.tokens.extend(quote! {
            println!("}}");
        });
    }

    fn inscribe_iter(
        &mut self,
        iterable: &syn::Expr,
        variable: &syn::Ident,
        children: &[DsTreeRef],
    ) {
        let iterable_str = quote!(#iterable).to_string();
        let variable_str = variable.to_string();

        self.tokens.extend(quote! {
            println!("for {} in {} {{", #variable_str, #iterable_str);
        });

        for child in children {
            decipher(child, self);
        }

        self.tokens.extend(quote! {
            println!("}}");
        });
    }

    fn seal(self) -> TokenStream {
        self.tokens
    }
}