rustantic 0.2.0

Rust to Pydantic 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

use std::path::PathBuf;
use std::{env, fs};

use crate::collector::MetadataCollector;
use crate::generators::generator_base::PydanticCodeGenerator;
use crate::models::ItemMetadata;
use convert_case::{Case, Casing};

use super::generator_base::{GeneratorConfig, PydanticCodeGeneratorFactory};

pub struct PydanticGenerator {
    header_comment: String,
    package_name: String,
    base_path: String,
    models_package_name: String,
    collector: MetadataCollector,
    generators: Vec<Box<dyn PydanticCodeGenerator>>,
}

impl PydanticGenerator {
    pub(crate) fn new(
        package_name: String,
        base_path: String,
        models_package_name: String,
        collector: MetadataCollector,
    ) -> Self {
        let version = env::var("CARGO_PKG_VERSION").unwrap();
        let header_comment = format!("# Generated by rustantic version: {}", version).to_string();
        Self {
            header_comment,
            package_name,
            base_path,
            models_package_name,
            collector,
            generators: Vec::new(),
        }
    }

    pub(crate) fn register<T>(mut self) -> Self
    where
        T: PydanticCodeGeneratorFactory,
    {
        self.generators.push(T::create());
        self
    }

    pub(crate) fn generate(&mut self) {
        println!(
            "cargo::warning=Rustantic generator stated, packageName='{}', basePath'{}', modelPackage='{}'",
            &self.package_name, &self.base_path, &self.models_package_name
        );

        self.collector.collect();

        println!(
            "cargo:warning=Rustantic collected '{}' items",
            self.collector.entities().len()
        );
        self.generate_init_file();
        self.collector
            .entities()
            .iter()
            .for_each(|(_, meta)| self.generate_entity_file(meta));
    }

    fn generate_entity_file(&self, meta: &ItemMetadata) {
        for generator in self.generators.iter() {
            if generator.is_item_supported(meta) {
                let config = GeneratorConfig {
                    header_comment: &self.header_comment,
                    package_name: &self.package_name,
                    models_package_name: &self.models_package_name,
                };
                let generated_code = generator
                    .generate(config, &self.collector, meta)
                    .expect("Generation failed for entity");
                self.create_pydantic_file(meta.ident(), &generated_code);
            }
        }
    }

    fn generate_init_file(&self) {
        let mut path = PathBuf::from(&self.base_path);
        path.push("__init__.py");
        fs::create_dir_all(path.parent().unwrap()).unwrap();
        fs::write(&path, "").unwrap();
    }

    fn create_pydantic_file(&self, ident: &str, generated_code: &str) {
        println!("cargo:warning=Start Rustantic generator for '{}'", ident);

        let mut path = PathBuf::from(&self.base_path);
        path.push(self.create_path(ident));

        fs::create_dir_all(path.parent().unwrap()).unwrap();
        fs::write(&path, generated_code).unwrap();
    }

    fn create_path(&self, identifier: &str) -> String {
        format!("{}.py", identifier.to_string().to_case(Case::Snake))
    }
}