tmpl_resolver

A lightweight template resolution engine with conditional logic support.

Its syntax is similar to Mozilla Fluent, but it doesn't have as many features as Fluent.

The parser is implemented using nom and can be used in no_std.

Key Concepts

• Templates: Contain either direct text parts or conditional selectors
• Selectors: Enable branch logic based on parameter values
• Variable Resolution: Recursive resolution with context-aware lookup

Features

• []
  • Minimal configuration for no_std use
• ["all"]: Enable all features
• ["std"]
  • Enables standard library
  • Uses ahash::HashMap for faster lookups
• ["serde"]
  • Adds serialization capabilities
  • Enables template storage/transmission
• ["bincode"]
  • Efficient binary serialization

Examples

Quick Start

cargo add toml
cargo add tmpl-resolver --features=std,serde

use tmpl_resolver::{TemplateResolver, resolver::AHashRawMap, error::ResolverResult};

fn raw_toml_to_hashmap() -> Result<AHashRawMap, toml::de::Error> {
  let text = r##"
g = "Good"
time-period = """
  $period ->
    [morning] {g} Morning
    [evening] {g} evening
    *[other] {g} {$period}
"""

gender = """

$attr ->
  [male] Mr.
  *[female] Ms.
"""
greeting = "{ time-period }! { gender }{ $name }"
  "##;

  toml::from_str(text)
}

fn main() -> ResolverResult<()> {
  let resolver: TemplateResolver = raw_toml_to_hashmap()
    .expect("Failed to deserialize toml str to AHashRawMap")
    .try_into()?;

 let text = resolver.get_with_context(
    "greeting",
    &[
      ("period", "evening"),
      ("name", "Alice"),
      ("attr", "unknown"),
    ],
  )?;
  assert_eq!(text, "Good evening! Ms.Alice");

  let text = resolver.get_with_context(
    "greeting",
    &[
      ("period", "night"),
      ("name", "Tom"),
      ("attr", "male"),
    ],
  )?;
  assert_eq!(text, "Good night! Mr.Tom");

  let g = resolver.get_with_context("g", &[])?;
  assert_eq!(g, "Good");

  Ok(())
}

Basic

use tmpl_resolver::{TemplateResolver, error::ResolverResult};

fn main() -> ResolverResult<()> {
  let resolver: TemplateResolver = [
      ("h", "Hello"),
      ("greeting", "{h} { $name }! Today is {$day}")
    ]
    .try_into()?;

  let result = resolver.get_with_context("greeting", &[("name", "Alice"), ("day", "Monday")])?;
  assert_eq!(result, "Hello Alice! Today is Monday");
  Ok(())
}

Conditional Logic

use tmpl_resolver::{TemplateResolver, error::ResolverResult};

fn main() -> ResolverResult<()> {
  let selector_msg = [(
    "message",
    r#"$status ->
      [success] Operation succeeded!
      [error] Error occurred!
      *[default] Unknown status: {$status}
    "#
  )];

  let resolver = TemplateResolver::from_raw_slice(&selector_msg)?;

  let success_msg = resolver.get_with_context("message", &[("status", "success")])?;

  assert_eq!(success_msg, "Operation succeeded!");
  Ok(())
}