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('"', """);
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(", ")
}