Improved codegen templates loading (#36)

Author: EehMauro

cli/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "telchar"
 description = "A toolchain that improves the developer experience of integrating Plutus validators in off-chain processes"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 repository = "https://github.com/txpipe/telchar"
 homepage = "https://registry.telchar.txpipe.io"

cli/Cargo.toml

@@ -1,11 +1,13 @@
 use std::str::FromStr;
 
-use telchar_codegen::{template::Template, get_blueprint_from_path, get_template_from_blueprint};
+use telchar_codegen::Codegen;
+use telchar_codegen::template::Template;
 
 pub async fn run(sub_matches: &clap::ArgMatches) {
+    let codegen = Codegen::new();
     let blueprint_reference = sub_matches.get_one::<String>("blueprint_path").expect("required");
     let template_reference = sub_matches.get_one::<String>("template").expect("required");
-    let blueprint = get_blueprint_from_path(blueprint_reference.to_string());
+    let blueprint = codegen.get_blueprint_from_path(blueprint_reference.to_string());
     let template = Template::from_str(&template_reference).unwrap();
-    println!("{}", get_template_from_blueprint(blueprint, template));
+    println!("{}", codegen.get_template_from_blueprint(blueprint, template));
 }

cli/src/command/codegen_local.rs

@@ -7,7 +7,7 @@ use oci_client::{
     Client, Reference,
 };
 
-use telchar_codegen::get_blueprint_from_json;
+use telchar_codegen::Codegen;
 use telchar_codegen::blueprint::Blueprint;
 
 use serde::{Deserialize, Serialize};
@@ -154,10 +154,11 @@ fn get_blueprint_file(path: String) -> (Blueprint, String) {
     let plutus_exists = fs::exists(&path_buf).unwrap_or(false);
 
     if plutus_exists {
+        let codegen = Codegen::new();
         println!("Found blueprint file at: {:?}", path_buf.display());
         println!("Processing...");
         let output_string = fs::read_to_string(path_buf).expect("Unable to read file");
-        let output = get_blueprint_from_json(output_string.clone());
+        let output = codegen.get_blueprint_from_json(output_string.clone());
         println!("Blueprint processed successfully!");
         return (output, output_string);
     }

cli/src/command/publish.rs

@@ -4,17 +4,23 @@ use std::str::FromStr;
 use handlebars::{handlebars_helper, Handlebars};
 use super::schema;
 
-mod blaze;
+static TEMPLATE_BLAZE: &'static str = include_str!(".././templates/blaze.hbs");
+static TEMPLATE_LUCID_EVOLUTION: &'static str = include_str!(".././templates/lucid-evolution.hbs");
+static TEMPLATE_MESH: &'static str = include_str!(".././templates/mesh.hbs");
 
 pub enum Template {
     Blaze,
+    LucidEvolution,
+    Mesh,
 }
 
 impl str::FromStr for Template {
     type Err = ();
     fn from_str(input: &str) -> Result<Template, Self::Err> {
         match input {
             "blaze" => Ok(Template::Blaze),
+            "lucid-evolution" => Ok(Template::LucidEvolution),
+            "mesh" => Ok(Template::Mesh),
             _ => Err(()),
         }
     }
@@ -24,26 +30,30 @@ impl fmt::Display for Template {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Template::Blaze => write!(f, "blaze"),
+            Template::LucidEvolution => write!(f, "lucid-evolution"),
+            Template::Mesh => write!(f, "mesh"),
         }
     }
 }
 
-fn get_template_name(template: Template) -> String {
+pub fn get_template_name(template: Template) -> String {
     match template {
         Template::Blaze => "blaze".to_string(),
+        Template::LucidEvolution => "lucid-evolution".to_string(),
+        Template::Mesh => "mesh".to_string(),
     }
 }
 
 fn helper_is_type(type_name_str: String, type_name: schema::TypeName) -> bool {
     schema::TypeName::from_str(&type_name_str).unwrap().eq(&type_name)
 }
 
-pub fn get_template_from_schemas(schemas: Vec<schema::Schema>, template: Template) -> String {
-    let template_name = get_template_name(template);
-
+pub fn init_handlebars() -> Handlebars<'static> {
     let mut handlebars = Handlebars::new();
 
-    handlebars.register_template_string("blaze", blaze::get_template()).unwrap();
+    handlebars.register_template_string("blaze", TEMPLATE_BLAZE).unwrap();
+    handlebars.register_template_string("lucid-evolution", TEMPLATE_LUCID_EVOLUTION).unwrap();
+    handlebars.register_template_string("mesh", TEMPLATE_MESH).unwrap();
 
     handlebars_helper!(is_integer: |type_name: str| helper_is_type(type_name.into(), schema::TypeName::Integer));
     handlebars.register_helper("is_integer", Box::new(is_integer));
@@ -69,5 +79,5 @@ pub fn get_template_from_schemas(schemas: Vec<schema::Schema>, template: Templat
     handlebars_helper!(is_list: |type_name: str| helper_is_type(type_name.into(), schema::TypeName::List));
     handlebars.register_helper("is_list", Box::new(is_list));
 
-    handlebars.render(&template_name, &schemas).unwrap()
-}
+    handlebars
+}

codegen/src/lib.rs

@@ -1,6 +1,3 @@
-
-pub fn get_template() -> String {
-    r#"
 import { Data } from "@blaze-cardano/sdk";
 
 {{#each this}}
@@ -49,6 +46,4 @@ const {{name}} = Data.Tuple([
 const {{name}} = Data.Array({{properties.[0].schema_name}});
   {{/if}}
 
-{{/each}}
-    "#.to_string()
-}
+{{/each}}

codegen/src/template/mod.rs codegen/src/template.rscodegen/src/template/mod.rs renamed to codegen/src/template.rs

@@ -1,6 +1,7 @@
 use oci_client::{client::ImageData, secrets::RegistryAuth, Client, Reference};
 use serde::{Deserialize, Serialize};
 use serde_json::{Number, Value};
+use telchar_codegen::Codegen;
 use telchar_codegen::blueprint;
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -161,8 +162,9 @@ pub fn get_blueprint(image: &ImageData) -> Option<blueprint::Blueprint> {
     let blueprint = image.layers.iter().find(|l| l.media_type == "application/vnd.telchar.blueprint.v1+json");
 
     if let Some(blueprint) = blueprint {
+        let codegen = Codegen::new();
         let data = String::from_utf8_lossy(&blueprint.data).to_string();
-        return Some(telchar_codegen::get_blueprint_from_json(data));
+        return Some(codegen.get_blueprint_from_json(data));
     }
 
     return None;