A high-performance inference engine for AI models
use std::{collections::BTreeMap, fs, path::Path};
use anyhow::{Context, Result, anyhow};
use minijinja::{Environment, context, value::Serde};
use serde::Serialize;
use crate::{
configs::{Paths, PlatformsConfig, WorkspaceManifest},
sync::SyncTask,
types::Language,
};
pub struct ReadmeSyncTask {
languages: Vec<Language>,
}
impl ReadmeSyncTask {
pub fn new(languages: Vec<Language>) -> Self {
Self {
languages,
}
}
}
#[derive(Serialize)]
struct LanguageContext {
name: String,
display: String,
code_fence: String,
dependency: String,
quick_start: String,
examples: BTreeMap<String, String>,
}
#[derive(Serialize)]
struct ExampleEntry {
name: String,
title: String,
description: String,
explanation: Option<String>,
}
impl SyncTask for ReadmeSyncTask {
fn process(
&self,
platforms: &PlatformsConfig,
workspace: &WorkspaceManifest,
_input: &str,
) -> Result<String> {
validate_examples(platforms)?;
let paths = Paths::new()?;
let primary_language = self.languages.first().copied().context("Languages list is empty")?;
let metadata = platforms
.languages
.get(&primary_language)
.with_context(|| format!("Missing [languages.{}]", primary_language.name()))?
.metadata
.clone()
.with_context(|| format!("Missing [languages.{}].metadata", primary_language.name()))?;
let badges = resolve_badges(platforms, &metadata.badges, &workspace.workspace.package.version)?;
let template_body = fs::read_to_string(paths.readme_template_path())?;
let mut environment = Environment::new();
environment.add_template("readme", &template_body)?;
let template = environment.get_template("readme")?;
let mut language_contexts = Vec::new();
for language in &self.languages {
language_contexts.push(language_context(*language, platforms, workspace, &paths)?);
}
let intro = fs::read_to_string(paths.readme_fragments_path().join("intro.md"))?.trim().to_string();
let example_entries: Vec<ExampleEntry> = platforms
.examples
.iter()
.map(|(name, config)| ExampleEntry {
name: name.clone(),
title: config.title.clone(),
description: config.description.clone(),
explanation: config.explanation.clone(),
})
.collect();
let rendered = template.render(context! {
title => "uzu",
version => &workspace.workspace.package.version,
image_url => metadata.image_url,
badges => badges,
has_multiple_languages => self.languages.len() > 1,
intro => intro,
languages => Serde(language_contexts),
examples => Serde(example_entries),
})?;
Ok(format!("{}\n", rendered.trim_end()))
}
}
fn resolve_badges(
platforms: &PlatformsConfig,
badge_ids: &[String],
version: &str,
) -> Result<Vec<String>> {
let mut environment = Environment::new();
badge_ids
.iter()
.map(|id| {
let body = platforms
.badges
.get(id)
.with_context(|| format!("Unknown badge id '{id}' in platforms.toml [badges]"))?;
environment.add_template(id, body)?;
let rendered = environment.get_template(id)?.render(context! { version => version })?;
Ok(rendered)
})
.collect()
}
fn language_context(
language: Language,
platforms: &PlatformsConfig,
workspace: &WorkspaceManifest,
paths: &Paths,
) -> Result<LanguageContext> {
let fragments_root = paths.readme_fragments_path().join(language.name());
let dependency = render_fragment(&fragments_root.join("dependency.md"), &workspace.workspace.package.version)?;
let examples_root = platforms.examples_path_for_language(language)?;
let mut examples = BTreeMap::new();
for name in platforms.examples.keys() {
examples.insert(name.clone(), read_example(&examples_root, language, name)?);
}
let quick_start = examples
.get("quick-start")
.cloned()
.with_context(|| format!("Missing 'quick-start' example for {}", language.name()))?;
Ok(LanguageContext {
name: language.name(),
display: language.display(),
code_fence: language.code_fence().to_string(),
dependency,
quick_start,
examples,
})
}
fn render_fragment(
path: &Path,
version: &str,
) -> Result<String> {
let body = fs::read_to_string(path).with_context(|| format!("Failed to read {}", path.display()))?;
let mut environment = Environment::new();
environment.add_template("fragment", &body)?;
let rendered = environment.get_template("fragment")?.render(context! {
version => version,
})?;
Ok(rendered.trim_end().to_string())
}
fn read_example(
examples_root: &Path,
language: Language,
canonical_name: &str,
) -> Result<String> {
let converted_name = language.convert_file_name(canonical_name);
let path = examples_root.join(format!("{converted_name}.{}", language.file_extension()));
fs::read_to_string(&path)
.with_context(|| format!("Missing example '{canonical_name}' for {} at {}", language.name(), path.display()))
.map(|body| body.trim_end().to_string())
}
fn validate_examples(platforms: &PlatformsConfig) -> Result<()> {
let paths = Paths::new()?;
for (language, language_config) in &platforms.languages {
let Some(examples_path) = &language_config.examples_path else {
continue;
};
let examples_root = paths.root_path.join(examples_path);
for name in platforms.examples.keys() {
let converted_name = language.convert_file_name(name);
let path = examples_root.join(format!("{converted_name}.{}", language.file_extension()));
if !path.exists() {
return Err(anyhow!(
"Example '{}' missing for {} (expected at {})",
name,
language.name(),
path.display()
));
}
}
}
Ok(())
}