zamm_yang 0.1.8

A basic, experimental code 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
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

use super::tao::TaoConfig;
use crate::codegen::template::basic::{AtomicFragment, FileFragment, ImplementationFragment};
use crate::codegen::StructConfig;
use indoc::formatdoc;
use std::cell::RefCell;
use std::rc::Rc;

/// Config values at the time of Form code generation.
#[derive(Default)]
pub struct FormFormatConfig {
    /// Regular concept config.
    pub tao_cfg: TaoConfig,
    /// Meta archetype specifically for this type, if one exists.
    pub meta_archetype: Option<StructConfig>,
    /// All ancestors of the concept.
    pub ancestors: Vec<StructConfig>,
}

fn form_impl_fragment(cfg: &TaoConfig) -> ImplementationFragment {
    let mut implementation = ImplementationFragment::new_trait_impl(
        StructConfig::new("zamm_yin::tao::form::FormTrait".to_owned()),
        cfg.this.clone(),
    );
    implementation.mark_same_file_as_struct();
    implementation
}

fn deref_fragment(this_name: &str, ancestor: &StructConfig) -> ImplementationFragment {
    let mut implementation = ImplementationFragment::new_trait_impl(
        StructConfig {
            name: format!("From<{}>", this_name),
            import: "std::convert::From".to_owned(),
        },
        ancestor.clone(),
    );
    implementation.append(Rc::new(RefCell::new(AtomicFragment {
        imports: vec![ancestor.import.clone()],
        atom: formatdoc! {"
            fn from(this: {this}) -> {parent} {{
                {parent}::from(this.base)
            }}",
        this = this_name,
        parent = ancestor.name},
    })));
    implementation.mark_same_file_as_struct();
    implementation
}

/// Get the form extension fragment, if there is a meta object to be had.
fn form_extension_fragment(cfg: &FormFormatConfig) -> ImplementationFragment {
    let mut implementation = ImplementationFragment::new_trait_impl(
        StructConfig::new("zamm_yin::tao::form::FormExtension".to_owned()),
        cfg.tao_cfg.this.clone(),
    );
    implementation.mark_same_file_as_struct();
    let meta = cfg.meta_archetype.as_ref().unwrap();
    implementation.append(Rc::new(RefCell::new(AtomicFragment {
        imports: vec![meta.import.clone()],
        atom: format!("type MetaType = {};", meta.name),
    })));
    implementation
}

/// Add the form fragment to a file.
pub fn add_form_fragment(cfg: &FormFormatConfig, file: &mut FileFragment) {
    file.append(Rc::new(RefCell::new(form_impl_fragment(&cfg.tao_cfg))));
    if cfg.meta_archetype.is_some() {
        file.append(Rc::new(RefCell::new(form_extension_fragment(cfg))));
    }
    for ancestor in &cfg.ancestors {
        file.append(Rc::new(RefCell::new(deref_fragment(
            &cfg.tao_cfg.this.name,
            &ancestor,
        ))));
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::codegen::template::basic::CodeFragment;
    use indoc::indoc;

    #[test]
    fn test_form_fragment() {
        assert_eq!(
            form_impl_fragment(&TaoConfig {
                this: StructConfig {
                    name: "MyConcept".to_owned(),
                    ..StructConfig::default()
                },
                ..TaoConfig::default()
            })
            .body(80),
            "impl FormTrait for MyConcept {}"
        );
    }

    #[test]
    fn test_deref_fragment() {
        assert_eq!(
            deref_fragment(
                "MyConcept",
                &StructConfig::new("crate::MyParent".to_owned())
            )
            .body(80),
            indoc! {"
                impl From<MyConcept> for MyParent {
                    fn from(this: MyConcept) -> MyParent {
                        MyParent::from(this.base)
                    }
                }"}
        );
    }

    #[test]
    fn test_archetype_form_trait_fragment() {
        assert_eq!(
            form_extension_fragment(&FormFormatConfig {
                tao_cfg: TaoConfig {
                    this: StructConfig::new("crate::MyAttribute".to_owned()),
                    ..TaoConfig::default()
                },
                meta_archetype: Some(StructConfig::new("crate::MyAttributeArchetype".to_owned())),
                ..FormFormatConfig::default()
            })
            .body(80),
            indoc! {"
                impl FormExtension for MyAttribute {
                    type MetaType = MyAttributeArchetype;
                }"}
        );
    }
}