Struct TemplateEngineBuilder 

pub struct TemplateEngineBuilder { /* private fields */ }

Comprehensive template engine builder

Provides a fluent API for configuring all aspects of the template engine:

use clnrm_template::TemplateEngineBuilder;

let engine = TemplateEngineBuilder::new()
    .with_search_paths(vec!["./templates", "./configs"])
    .with_context_defaults()
    .with_validation_rules(vec![
        ValidationRule::ServiceName,
        ValidationRule::Semver,
    ])
    .with_custom_function("my_func", |args| Ok(Value::String("custom".to_string())))
    .with_cache(Duration::from_secs(3600))
    .with_hot_reload(true)
    .build()
    .unwrap();

Implementations

impl TemplateEngineBuilder

pub fn new() -> Self

Create new template engine builder

pub fn with_discovery<F>(self, f: F) -> Self

where F: FnOnce(TemplateDiscovery) -> TemplateDiscovery,

Configure template discovery

pub fn with_search_paths<I, P>(self, paths: I) -> Self

where I: IntoIterator<Item = P>, P: AsRef<Path>,

Add search paths for template discovery

pub fn with_glob_patterns<I, S>(self, patterns: I) -> Self

where I: IntoIterator<Item = S>, S: AsRef<str>,

Add glob patterns for template discovery

pub fn with_organization(self, organization: TemplateOrganization) -> Self

Set template organization strategy

pub fn with_context<F>(self, f: F) -> Self

where F: FnOnce(TemplateContextBuilder) -> TemplateContextBuilder,

Configure template context

pub fn with_context_defaults(self) -> Self

Use default PRD v1.0 context variables

pub fn with_variables<I, K, V>(self, variables: I) -> Self

where I: IntoIterator<Item = (K, V)>, K: Into<String>, V: Into<Value>,

Add context variables

pub fn with_context_from_file<P: AsRef<Path>>(self, path: P) -> Result<Self>

Load context from file

pub fn with_validation<F>(self, f: F) -> Self

where F: FnOnce(TemplateValidator) -> TemplateValidator,

Configure validation

pub fn with_validation_rules<I>(self, rules: I) -> Self

where I: IntoIterator<Item = ValidationRule>,

Add validation rules

pub fn with_validation_format(self, format: OutputFormat) -> Self

Set validation format

pub fn with_custom_function<F>(self, func: CustomFunction<F>) -> Self

where F: Fn(&HashMap<String, Value>) -> Result<Value> + Send + Sync + 'static,

Add custom function

pub fn with_custom_filter<F>(self, filter: CustomFilter<F>) -> Self

where F: Fn(&Value, &HashMap<String, Value>) -> Result<Value> + Send + Sync + 'static,

Add custom filter

pub fn with_toml_loader<F>(self, f: F) -> Self

where F: FnOnce(TomlLoader) -> TomlLoader,

Configure TOML loading

pub fn with_toml_writer<F>(self, f: F) -> Self

where F: FnOnce(TomlWriter) -> TomlWriter,

Configure TOML writing

pub fn with_toml_merger<F>(self, f: F) -> Self

where F: FnOnce(TomlMerger) -> TomlMerger,

Configure TOML merging

pub fn with_cache(self, ttl: Duration) -> Self

Configure caching

pub fn with_cache_and_reload(self, ttl: Duration, hot_reload: bool) -> Self

Configure caching with hot-reload

pub fn without_cache(self) -> Self

Disable caching

pub fn with_output_format(self, format: OutputFormat) -> Self

Set output format

pub fn with_debug(self, debug: bool) -> Self

Enable debug mode

pub fn build(self) -> Result<TemplateLoader>

Build the template engine configuration

Returns a configured template loader that can be used for rendering

pub fn build_cached(self) -> Result<CachedRenderer>

Build cached renderer for performance

pub async fn build_async_cached(self) -> Result<AsyncTemplateRenderer>

Build async cached renderer (if async feature is enabled)

pub fn build_complete(self) -> Result<TemplateEngine>

Build complete template engine with all components

Returns a struct containing all configured components for advanced usage

Trait Implementations

impl Default for TemplateEngineBuilder

fn default() -> Self

Returns the “default value” for a type.