tf_bindgen/
lib.rs

1pub mod builder;
2pub mod codegen;
3pub mod config;
4pub mod model;
5pub mod value;
6
7use std::collections::HashMap;
8
9use codegen::Generator;
10use semver::VersionReq;
11use tf_bindgen_schema::provider;
12
13pub use tf_bindgen_core::*;
14
15pub use crate::builder::Builder;
16pub use serde;
17pub use serde_json as json;
18pub use tf_bindgen_cli as cli;
19pub use tf_bindgen_schema as schema;
20
21pub use value::Value;
22
23pub struct Bindings {
24    version: HashMap<String, VersionReq>,
25    schema: provider::Schema,
26}
27use std::path::Path as StdPath;
28
29impl Bindings {
30    pub fn write_to_file(
31        self,
32        base_path: impl AsRef<StdPath>,
33        root_file: impl AsRef<StdPath>,
34    ) -> std::io::Result<()> {
35        let provider_dir = base_path.as_ref().join("provider");
36        std::fs::create_dir_all(&provider_dir)?;
37
38        let result = Generator::from_schema(self.schema, self.version);
39        let mut root_content = String::new();
40        for provider in result.providers {
41            let name = &provider.provider.name();
42            let name = name.split('/').last().unwrap();
43            let provider_dir = provider_dir.join(name);
44            let resource_dir = provider_dir.join("resource");
45            std::fs::create_dir_all(&resource_dir)?;
46            let data_dir = provider_dir.join("data");
47            std::fs::create_dir_all(&data_dir)?;
48
49            let resources: String = provider
50                .resources
51                .iter()
52                .map(|construct| {
53                    let filename = format!("{}.rs", construct.ty());
54                    let path = resource_dir.join(filename);
55                    std::fs::write(path, construct.gen_rust())?;
56                    Ok(construct.ty())
57                })
58                .map(|name: std::io::Result<_>| Ok(format!("pub mod {};\n", name?)))
59                .collect::<std::io::Result<_>>()?;
60            let data_sources: String = provider
61                .data_sources
62                .iter()
63                .map(|construct| {
64                    let filename = format!("{}.rs", construct.ty());
65                    let path = data_dir.join(filename);
66                    std::fs::write(path, construct.gen_rust())?;
67                    Ok(construct.ty())
68                })
69                .map(|name: std::io::Result<_>| Ok(format!("pub mod {};\n", name?)))
70                .collect::<std::io::Result<_>>()?;
71            let content = provider.provider.gen_rust()
72                + "pub mod resource {\n"
73                + &resources
74                + "}\npub mod data {\n"
75                + &data_sources
76                + "}";
77
78            let provider_file = provider_dir.join("mod.rs");
79            std::fs::write(provider_file, content)?;
80            root_content += &format!(
81                "#[path = \"{}/mod.rs\"]\npub mod {name};\n",
82                provider_dir.to_str().unwrap()
83            )
84        }
85        let root_file = base_path.as_ref().join(root_file);
86        std::fs::write(root_file, root_content)
87    }
88}