markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
use std::collections::{BTreeMap, BTreeSet};

use serde::Serialize;

use super::{
    Config,
    model::{Binary, ExternalDependency, Package},
};
use crate::{RenderCtx, domain::ContextEntry, markdown, workspace};

#[derive(Debug, Default, Serialize)]
struct TemplateContext {
    rust_version: Option<String>,
    features: Vec<Feature>,
    dependencies: Vec<Dependency>,
    used_by: Vec<Dependency>,
    binaries: Vec<Binary>,
    tests: Box<[String]>,
    benches: Box<[String]>,
    examples: Box<[String]>,
    external_dependencies: Vec<ExternalDependency>,
    aliases: Vec<Alias>,
    dependency_graph: String,
}

#[derive(Debug, Serialize)]
struct Feature {
    name: String,
    dependencies: String,
}

#[derive(Debug, Serialize)]
struct Dependency {
    name: String,
    path: String,
    description: String,
}

#[derive(Debug, Serialize)]
struct Alias {
    name: String,
    command: String,
}

pub(super) fn collect(
    config: &Config,
    context: &RenderCtx<'_>,
) -> Result<Option<ContextEntry>, crate::domain::Error> {
    let package = package(context.metadata);
    let (aliases, dependency_graph) = if context.is_root() {
        let aliases = match config.aliases.as_ref() {
            Some(path) => aliases(context, path.as_path())?,
            None => Vec::new(),
        };
        let dependency_graph = if config.dependency_graph {
            dependency_graph(&context.workspace)
        } else {
            String::new()
        };

        (aliases, dependency_graph)
    } else {
        (Vec::new(), String::new())
    };

    if package.is_none() && aliases.is_empty() && dependency_graph.is_empty() {
        return Ok(None);
    }

    let value = package.map_or_else(TemplateContext::default, |package| TemplateContext {
        rust_version: package.rust_version.clone(),
        features: package
            .features
            .iter()
            .map(|(name, dependencies)| Feature {
                name: name.clone(),
                dependencies: feature_dependencies(dependencies),
            })
            .collect(),
        dependencies: dependencies(context, package),
        used_by: used_by(context),
        binaries: package.binaries.clone(),
        tests: package.tests.clone(),
        benches: package.benches.clone(),
        examples: package.examples.clone(),
        external_dependencies: package.external_dependencies.clone(),
        aliases: Vec::new(),
        dependency_graph: String::new(),
    });
    let value = TemplateContext {
        aliases,
        dependency_graph,
        ..value
    };

    Ok(Some(("cargo".into(), crate::domain::to_value(&value))))
}

fn dependencies(context: &RenderCtx<'_>, package: &Package) -> Vec<Dependency> {
    package
        .workspace_dependencies
        .iter()
        .map(|(name, dependency)| {
            let target = workspace::normalize(&context.dir.join(&dependency.path));
            let metadata = crate::domain::load(&context.workspace, &target);

            Dependency {
                name: name.clone(),
                path: dependency.path.clone(),
                description: metadata.description.clone().unwrap_or_default(),
            }
        })
        .collect()
}

fn used_by(context: &RenderCtx<'_>) -> Vec<Dependency> {
    let current = workspace::normalize(context.dir);
    let mut dependencies = context
        .workspace
        .metadata_entries()
        .filter_map(|(directory, metadata)| {
            let package = package(metadata)?;
            let depends_on_current = package.workspace_dependencies.values().any(|dependency| {
                workspace::normalize(&directory.join(&dependency.path)) == current
            });

            depends_on_current.then(|| Dependency {
                name: metadata.name.clone().unwrap_or_default(),
                path: workspace::relative_path(context.dir, directory),
                description: metadata.description.clone().unwrap_or_default(),
            })
        })
        .collect::<Vec<_>>();

    dependencies.sort_by(|left, right| left.name.cmp(&right.name));
    dependencies
}

fn aliases(
    context: &RenderCtx<'_>,
    configured_path: &std::path::Path,
) -> Result<Vec<Alias>, crate::domain::Error> {
    let path = context.root.join(configured_path);
    let Some(source) = crate::domain::workspace_source(&context.workspace, &path, "Cargo config")?
    else {
        return Ok(Vec::new());
    };
    let table = source
        .parse::<toml::Table>()
        .map_err(|error| crate::domain::Error::parse(&path, "Cargo config", error))?;
    let Some(aliases) = table.get("alias").and_then(toml::Value::as_table) else {
        return Ok(Vec::new());
    };
    let mut aliases = aliases
        .iter()
        .filter(|(_, value)| value.is_str() || value.is_array())
        .map(|(name, _)| Alias {
            name: name.clone(),
            command: format!("cargo {name}"),
        })
        .collect::<Vec<_>>();

    aliases.sort_by(|left, right| left.name.cmp(&right.name));
    Ok(aliases)
}

fn dependency_graph(workspace_index: &crate::WorkspaceIndex) -> String {
    let packages = workspace_index
        .metadata_entries()
        .filter(|(_, metadata)| package(metadata).is_some())
        .collect::<Vec<_>>();
    let package_ids = packages
        .iter()
        .enumerate()
        .map(|(index, (path, _))| (workspace::normalize(path), index))
        .collect::<BTreeMap<_, _>>();
    let mut edges = BTreeSet::new();

    for (path, metadata) in &packages {
        let Some(from) = package_ids.get(&workspace::normalize(path)) else {
            continue;
        };
        let Some(package) = package(metadata) else {
            continue;
        };

        for dependency in package.workspace_dependencies.values() {
            let target = workspace::normalize(&path.join(&dependency.path));

            if let Some(to) = package_ids.get(&target)
                && from != to
            {
                edges.insert((*from, *to));
            }
        }
    }

    if edges.is_empty() {
        return String::new();
    }

    let mut lines = vec!["graph LR".to_string()];

    for (index, (_, metadata)) in packages.iter().enumerate() {
        let name = metadata
            .name
            .as_deref()
            .unwrap_or("unnamed")
            .replace('"', "&quot;");

        lines.push(format!("    p{index}[\"{name}\"]"));
    }

    lines.extend(
        edges
            .into_iter()
            .map(|(from, to)| format!("    p{from} --> p{to}")),
    );

    markdown::code_block("mermaid", lines.join("\n"))
}

fn package(metadata: &crate::domain::Metadata) -> Option<&Package> {
    metadata.data("cargo")
}

fn feature_dependencies(dependencies: &[String]) -> String {
    if dependencies.is_empty() {
        return "-".to_string();
    }

    dependencies
        .iter()
        .map(markdown::code)
        .collect::<Vec<_>>()
        .join(", ")
}