zamm_yang 0.0.10

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

use crate::codegen::docstring::into_docstring;
use crate::codegen::CodeConfig;
use heck::{CamelCase, KebabCase};
use itertools::Itertools;

/// Config values at the time of string generation.
pub struct FormatConfig {
    /// Name to use for the yin crate.
    pub yin_crate: String,
    /// Main file imports.
    pub imports: Option<String>,
    /// Name of the class.
    pub name: String,
    /// Name of the concept.
    pub internal_name: String,
    /// Name of the parent class.
    pub parent_name: String,
    /// Import path for the parent class.
    pub parent_import: String,
    /// Name of the archetype used to represent this.
    pub archetype_name: String,
    /// List of attributes this class has.
    pub all_attributes: String,
    /// Imports for above list of introduced attributes.
    pub all_attribute_imports: Vec<String>,
    /// List of attributes this class introduced.
    pub introduced_attributes: String,
    /// Imports for above list of introduced attributes.
    pub introduced_attribute_imports: Vec<String>,
    /// Rustdoc for the class.
    pub doc: String,
    /// ID of the concept.
    pub id: String,
}

impl Default for FormatConfig {
    fn default() -> Self {
        Self {
            yin_crate: "zamm_yin".to_owned(),
            imports: Some("zamm_yin::tao::YIN_MAX_ID".to_owned()),
            name: "Dummy".to_owned(),
            internal_name: "dummy".to_owned(),
            parent_name: "Tao".to_owned(),
            parent_import: "tao::Tao".to_owned(),
            archetype_name: "Archetype".to_owned(),
            all_attributes: "vec![]".to_owned(),
            all_attribute_imports: vec![],
            introduced_attributes: "vec![]".to_owned(),
            introduced_attribute_imports: vec![],
            doc: "".to_owned(),
            id: "1".to_owned(),
        }
    }
}

impl<'a> From<&'a CodeConfig<'a>> for FormatConfig {
    /// Extract format values from code config.
    fn from(cfg: &CodeConfig) -> Self {
        let yin_crate = if cfg.codegen_cfg.yin {
            "crate"
        } else {
            "zamm_yin"
        };
        let imports = if cfg.codegen_cfg.yin {
            None
        } else {
            Some("zamm_yin::tao::YIN_MAX_ID".to_owned())
        };
        let all_attributes = format!(
            "vec![{}]",
            cfg.all_attributes
                .iter()
                .map(|s| format!("{}::archetype()", s.name))
                .format(", ")
        );
        let all_attribute_imports = cfg
            .all_attributes
            .iter()
            .map(|s| s.import.clone())
            .collect();
        let introduced_attributes = format!(
            "vec![{}]",
            cfg.introduced_attributes
                .iter()
                .map(|s| format!("{}::archetype()", s.name))
                .format(", ")
        );
        let introduced_attribute_imports = cfg
            .introduced_attributes
            .iter()
            .map(|s| s.import.clone())
            .collect();
        let archetype_name = if cfg.activate_attribute {
            "AttributeArchetype".to_owned()
        } else {
            "Archetype".to_owned()
        };
        let doc = match &cfg.impl_cfg.doc {
            Some(d) => format!("\n{}", into_docstring(d.as_str(), 0)),
            None => String::new(),
        };
        let id = if cfg.codegen_cfg.yin {
            format!("{}", cfg.impl_cfg.id)
        } else {
            format!("YIN_MAX_ID + {}", cfg.impl_cfg.id)
        };

        Self {
            yin_crate: yin_crate.to_owned(),
            imports,
            name: cfg.name.to_camel_case(),
            parent_name: cfg.parent.name.clone(),
            parent_import: cfg.parent.import.clone(),
            all_attributes,
            all_attribute_imports,
            introduced_attributes,
            introduced_attribute_imports,
            archetype_name,
            internal_name: cfg.name.to_kebab_case(),
            doc,
            id,
        }
    }
}