Struct TemplateService 

pub struct TemplateService { /* private fields */ }

Template service for code generation

Examples

use mecha10_cli::services::TemplateService;
use std::collections::HashMap;

// Create service with default templates
let template_service = TemplateService::new();

// Render a template
let mut vars = HashMap::new();
vars.insert("name", "camera_driver");
let rendered = template_service.render("drivers/sensor.rs.template", &vars)?;

// Render to file
template_service.render_to_file(
    "drivers/sensor.rs.template",
    "output/camera_driver.rs",
    &vars
).await?;

Implementations

impl TemplateService

pub fn new() -> Self

Create a new template service with default templates

pub fn with_template_dir(template_dir: impl Into<PathBuf>) -> Self

Create a template service with a custom template directory

Arguments

• template_dir - Path to directory containing templates

pub fn render( &self, template_path: &str, variables: &HashMap<&str, &str>, ) -> Result<String>

Render a template with variables

Arguments

• template_path - Path to template file relative to template directory
• variables - HashMap of variable names to values

Errors

Returns an error if:

• The template file doesn’t exist
• The template file cannot be read
• Variable substitution fails

pub async fn render_to_file( &self, template_path: &str, output_path: impl AsRef<Path>, variables: &HashMap<&str, &str>, ) -> Result<()>

Render a template and write it to a file

Arguments

• template_path - Path to template file relative to template directory
• output_path - Destination file path
• variables - HashMap of variable names to values

Errors

Returns an error if:

• The template file doesn’t exist
• The template file cannot be read
• The output file cannot be written

pub fn list_templates(&self, category: &str) -> Result<Vec<String>>

List available templates in a category

Arguments

• category - Template category (e.g., “drivers”, “nodes”, “types”)

Returns

Vector of template names without the .template extension

pub fn template_exists(&self, template_path: &str) -> bool

Check if a template exists

Arguments

• template_path - Path to template file relative to template directory

pub fn create_vars(&self) -> TemplateVars

Create a template variables builder

Helper method to create a TemplateVars instance for building variable mappings with name transformations.

Examples

let service = TemplateService::new();
let mut vars = service.create_vars();
vars.add_name("camera_driver");
// Now vars contains: name, PascalName, snake_name, UPPER_NAME

pub async fn generate_node( &self, node_name: &str, node_type: &str, output_dir: impl AsRef<Path>, ) -> Result<()>

Generate a node file from template

Convenience method for generating node files with standard naming.

Arguments

• node_name - Name of the node (snake_case)
• node_type - Type of node (“sensor”, “actuator”, “controller”, etc.)
• output_dir - Directory where the node will be generated

pub async fn generate_driver( &self, driver_name: &str, driver_type: &str, output_dir: impl AsRef<Path>, ) -> Result<()>

Generate a driver file from template

Convenience method for generating driver files with standard naming.

Arguments

• driver_name - Name of the driver (snake_case)
• driver_type - Type of driver (“camera”, “motor”, “sensor”, etc.)
• output_dir - Directory where the driver will be generated

pub async fn generate_type( &self, type_name: &str, output_dir: impl AsRef<Path>, ) -> Result<()>

Generate a custom type file from template

Convenience method for generating type files with standard naming.

Arguments

• type_name - Name of the type (PascalCase or snake_case)
• output_dir - Directory where the type will be generated

pub async fn generate_cargo_toml( &self, package_name: &str, package_type: &str, output_dir: impl AsRef<Path>, ) -> Result<()>

Generate a Cargo.toml file for a package

Arguments

• package_name - Name of the package
• package_type - Type of package (“node”, “driver”, “type”)
• output_dir - Directory where Cargo.toml will be generated

pub fn render_string( &self, template_content: &str, variables: &HashMap<&str, &str>, ) -> Result<String>

Render a string template directly (not from file)

Arguments

• template_content - Template content as string
• variables - HashMap of variable names to values

Trait Implementations

impl Default for TemplateService

fn default() -> Self

Returns the “default value” for a type.