nene 0.7.0

Google Cloud Spanner ORM 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

use crate::helper::register;
use crate::model::Table;
use crate::repository::TableRepository;

use convert_case::{Case, Casing};
use handlebars::Handlebars;

use std::fs::File;
use std::io::Write;
use std::{fs, io};

const DEFAULT_MODEL_TEMPLATE: &str = include_str!("default/multi/${table_name}.tmpl");
const DEFAULT_MOD_TEMPLATE: &str = include_str!("default/single/mod.tmpl");

pub struct TableGenerator {
    repository: TableRepository,
}

impl TableGenerator {
    pub fn new(repository: TableRepository) -> Self {
        Self { repository }
    }

    pub async fn generate_default(&self, output_dir: &str) -> anyhow::Result<()> {
        let mut handlebars = Handlebars::new();
        register(&mut handlebars);
        let tables = self.repository.read_all().await?;

        self.generate_multi(
            &handlebars,
            &tables,
            DEFAULT_MODEL_TEMPLATE,
            "${table_name}",
            output_dir,
        )
        .await?;
        self.generate_single(
            &handlebars,
            &tables,
            DEFAULT_MOD_TEMPLATE,
            "mod",
            output_dir,
        )
        .await?;
        Ok(())
    }

    pub async fn generate(&self, input_dir: &str, output_dir: &str) -> anyhow::Result<()> {
        let mut handlebars = Handlebars::new();
        register(&mut handlebars);

        let multi_templates = fs::read_dir(format!("{}/multi", input_dir))?
            .map(|res| res.map(|e| e.path()))
            .collect::<Result<Vec<_>, io::Error>>()?;

        let single_templates = fs::read_dir(format!("{}/single", input_dir))?
            .map(|res| res.map(|e| e.path()))
            .collect::<Result<Vec<_>, io::Error>>()?;

        let tables = self.repository.read_all().await?;

        for mut e in multi_templates.into_iter() {
            let template_string = fs::read_to_string(e.clone())?;
            e.set_extension("");
            let file_name = e.file_name().unwrap().to_str().unwrap().to_string();
            self.generate_multi(
                &handlebars,
                &tables,
                &template_string,
                &file_name,
                output_dir,
            )
            .await?;
        }

        for mut e in single_templates.into_iter() {
            let template_string = fs::read_to_string(e.clone())?;
            e.set_extension("");
            let file_name = e.file_name().unwrap().to_str().unwrap().to_string();
            self.generate_single(
                &handlebars,
                &tables,
                &template_string,
                &file_name,
                output_dir,
            )
            .await?;
        }
        Ok(())
    }

    async fn generate_single(
        &self,
        handlebars: &Handlebars<'_>,
        tables: &Vec<Table>,
        template_string: &str,
        file_name: &str,
        output_dir: &str,
    ) -> anyhow::Result<()> {
        let rendered = handlebars.render_template::<Vec<Table>>(template_string, tables)?;
        let file_path = format!("{}/{}.rs", output_dir, file_name);
        log::info!("generate {}", file_path);
        let mut file = File::create(file_path)?;
        write!(file, "{}", rendered)?;
        Ok(file.flush()?)
    }

    async fn generate_multi(
        &self,
        handlebars: &Handlebars<'_>,
        tables: &Vec<Table>,
        template_string: &str,
        file_name: &str,
        output_dir: &str,
    ) -> anyhow::Result<()> {
        for table in tables.iter() {
            let rendered = handlebars.render_template::<Table>(template_string, table)?;
            let file_path = format!(
                "{}/{}.rs",
                output_dir,
                file_name.replace("${table_name}", &table.table_name.to_case(Case::Snake))
            );
            log::info!("generate {}", file_path);
            let mut file = File::create(file_path)?;
            write!(file, "{}", rendered)?;
            file.flush()?;
        }
        Ok(())
    }
}