Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

6.2 KB
Raw Blame
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(())
}