jens 0.6.0

Readable templates for code generation
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

extern crate jens;

use jens::{Block, File};

enum Json {
    JsString,
    JsNumber,
    JsArray(Box<Json>),
    JsObject(String),
}

impl Json {
    fn get_ts_type(&self) -> String {
        use Json::*;
        match self {
            JsString => "string".into(),
            JsNumber => "number".into(),
            JsArray(subtype) => format!("{}[]", subtype.get_ts_type()),
            JsObject(module_name) => format!("{}.T", module_name),
        }
    }

    fn get_serialize_func(&self) -> String {
        use Json::*;
        match self {
            JsString => format!("noop"),
            JsNumber => format!("noop"),
            JsArray(subtype) => format!("serialize_array({})", subtype.get_serialize_func()),
            JsObject(module_name) => format!("{}.serialize", module_name),
        }
    }

    fn get_deserialize_func(&self) -> String {
        use Json::*;
        match self {
            JsString => format!("deserialize_string"),
            JsNumber => format!("deserialize_number"),
            JsArray(subtype) => format!("deserialize_array({})", subtype.get_deserialize_func()),
            JsObject(module_name) => format!("{}.deserialize", module_name),
        }
    }
}

struct TsField {
    field_name: String,
    field_type: Json,
}

struct TsType {
    type_name: String,
    fields: Vec<TsField>,
}

fn main() {
    // A sample Json object schema
    let types = vec![
        TsType {
            type_name: "Book".into(),
            fields: vec![TsField {
                field_name: "title".into(),
                field_type: Json::JsString,
            }],
        },
        TsType {
            type_name: "LibraryMeta".into(),
            fields: vec![
                TsField {
                    field_name: "founded_year".into(),
                    field_type: Json::JsNumber,
                },
                TsField {
                    field_name: "name".into(),
                    field_type: Json::JsString,
                },
            ],
        },
        TsType {
            type_name: "Library".into(),
            fields: vec![
                TsField {
                    field_name: "count".into(),
                    field_type: Json::JsNumber,
                },
                TsField {
                    field_name: "meta".into(),
                    field_type: Json::JsObject("LibraryMeta".into()),
                },
                TsField {
                    field_name: "books".into(),
                    field_type: Json::JsArray(Box::new(Json::JsObject("Book".into()))),
                },
            ],
        },
    ];

    let f = File::parse(include_str!("./template.jens")).unwrap();

    let output = f.template("main").set(
        "types",
        Block::join_map(types, |t, _| {
            f.template("type")
                .set("type_name", t.type_name.clone())
                .set("type_def_fields", type_def_fields(&f, &t))
                .set("serialize_fields", serialize_fields(&f, &t))
                .set("deserialize_fields", deserialize_fields(&f, &t))
        }),
    );

    println!("{}", output);
}

fn type_def_fields(f: &File, t: &TsType) -> Block {
    Block::join_map(&t.fields, |field, _| {
        f.template("type_def")
            .set("field_name", field.field_name.clone())
            .set("field_type", field.field_type.get_ts_type())
    })
}

fn serialize_fields(f: &File, t: &TsType) -> Block {
    Block::join_map(&t.fields, |field, _| {
        f.template("serialize_field")
            .set("field_name", field.field_name.clone())
            .set("serialize_func", field.field_type.get_serialize_func())
    })
}

fn deserialize_fields(f: &File, t: &TsType) -> Block {
    Block::join_map(&t.fields, |field, _| {
        f.template("deserialize_field")
            .set("field_name", field.field_name.clone())
            .set("deserialize_func", field.field_type.get_deserialize_func())
    })
}