Struct TemplateResolver 

pub struct TemplateResolver { /* private fields */ }

Template resolver for gpack:template syntax

Implementations

impl TemplateResolver

pub fn new( cache_manager: CacheManager, lockfile_manager: LockfileManager, ) -> Self

Create a new template resolver

Examples

use ggen_core::resolver::TemplateResolver;
use ggen_core::cache::CacheManager;
use ggen_core::lockfile::LockfileManager;
use std::path::Path;

let cache = CacheManager::new()?;
let lockfile = LockfileManager::new(Path::new("."));
let resolver = TemplateResolver::new(cache, lockfile);

pub fn resolve(&self, template_ref: &str) -> Result<TemplateSource>

Resolve a template reference in the format “pack_id:template_path”

Errors

Returns an error if:

• The template reference format is invalid (must be pack_id:template_path)
• The pack is not found in the lockfile
• The pack is not cached locally
• The template path doesn’t exist in the pack
• Path traversal is detected (e.g., ../ in template path)

Examples

Success case

use ggen_core::resolver::TemplateResolver;
use ggen_core::cache::CacheManager;
use ggen_core::lockfile::LockfileManager;
use std::path::Path;

let cache = CacheManager::new()?;
let lockfile = LockfileManager::new(Path::new("."));
let resolver = TemplateResolver::new(cache, lockfile);

// Resolve template reference
let source = resolver.resolve("io.ggen.rust.api:main.tmpl")?;
println!("Template at: {:?}", source.template_path);

Error case - Invalid format

use ggen_core::resolver::TemplateResolver;
use ggen_core::cache::CacheManager;
use ggen_core::lockfile::LockfileManager;
use std::path::Path;

let cache = CacheManager::new()?;
let lockfile = LockfileManager::new(Path::new("."));
let resolver = TemplateResolver::new(cache, lockfile);

// This will fail because the format is invalid (missing colon)
let result = resolver.resolve("invalid-format");
assert!(result.is_err());

Error case - Pack not found

use ggen_core::resolver::TemplateResolver;
use ggen_core::cache::CacheManager;
use ggen_core::lockfile::LockfileManager;
use std::path::Path;

let cache = CacheManager::new()?;
let lockfile = LockfileManager::new(Path::new("."));
let resolver = TemplateResolver::new(cache, lockfile);

// This will fail because the pack is not in the lockfile
let result = resolver.resolve("nonexistent.pack:template.tmpl");
assert!(result.is_err());

pub fn search_templates( &self, query: Option<&str>, ) -> Result<Vec<TemplateSearchResult>>

Search for templates across all installed packs

Example

use ggen_core::resolver::TemplateResolver;
use ggen_core::cache::CacheManager;
use ggen_core::lockfile::LockfileManager;
use std::path::Path;

let cache = CacheManager::new()?;
let lockfile = LockfileManager::new(Path::new("."));
let resolver = TemplateResolver::new(cache, lockfile);

// Search for templates containing "api"
let results = resolver.search_templates(Some("api"))?;
for result in results {
    println!("Found: {}:{}", result.pack_id, result.template_path.display());
}

pub fn get_pack_templates(&self, pack_id: &str) -> Result<Vec<String>>

Get available templates for a specific pack

pub fn get_template_info(&self, template_ref: &str) -> Result<TemplateInfo>

Get template information including frontmatter

Trait Implementations

impl Clone for TemplateResolver

fn clone(&self) -> TemplateResolver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TemplateResolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.