use crate::{code, fed};
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CodeDep {
pub node: String,
pub needs: Vec<String>,
pub seam: Vec<String>,
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct Schedule {
pub rounds: Vec<Vec<String>>,
pub blocked: Vec<String>,
pub edges: usize,
pub blocking: usize,
}
impl Schedule {
#[must_use]
pub fn depth(&self) -> usize {
self.rounds.len()
}
#[must_use]
pub fn width(&self) -> usize {
self.rounds.iter().map(Vec::len).max().unwrap_or(0)
}
}
#[must_use]
pub fn code_deps(root: &Path) -> Vec<CodeDep> {
let nodes = fed::discover(root);
nodes
.iter()
.map(|n| {
let (needs, seam) = edges_of(root, n, &nodes);
CodeDep {
node: fed::node_label(root, n),
needs,
seam,
}
})
.collect()
}
fn edges_of(
root: &Path,
node: &Path,
nodes: &[PathBuf],
) -> (Vec<String>, Vec<String>) {
let sibs = siblings_of(root, node, nodes);
let mut needs: Vec<String> = Vec::new();
let mut seam: Vec<String> = Vec::new();
for src in owned_sources(node, nodes) {
for import in code::crate_imports(&src) {
let Some(label) = sibling_label(&sibs, &import.module) else {
continue;
};
let target = node_path(root, &label);
if type_only(&import, &declared_types(&target, nodes)) {
seam.push(label);
} else {
needs.push(label);
}
}
}
dedup(&mut needs);
dedup(&mut seam);
seam.retain(|l| !needs.contains(l));
(needs, seam)
}
fn type_only(import: &code::Import, types: &[String]) -> bool {
!import.items.is_empty() && import.items.iter().all(|i| types.contains(i))
}
fn declared_types(node: &Path, nodes: &[PathBuf]) -> Vec<String> {
code::types_in(&owned_sources(node, nodes))
.into_iter()
.map(|t| t.name)
.collect()
}
fn dedup(v: &mut Vec<String>) {
v.sort();
v.dedup();
}
fn sibling_label(sibs: &[(String, String)], name: &str) -> Option<String> {
sibs.iter()
.find(|(n, _)| n == name)
.map(|(_, label)| label.clone())
}
fn siblings_of(
root: &Path,
node: &Path,
nodes: &[PathBuf],
) -> Vec<(String, String)> {
let parent = node.parent();
nodes
.iter()
.filter(|n| n.as_path() != node && n.parent() == parent)
.filter_map(|n| {
let name = n.file_name()?.to_string_lossy().to_string();
Some((name, fed::node_label(root, n)))
})
.collect()
}
fn owned_sources(node: &Path, nodes: &[PathBuf]) -> Vec<String> {
fed::owned_rust_files(node, nodes)
.iter()
.filter_map(|f| std::fs::read_to_string(f).ok())
.collect()
}
#[must_use]
pub fn schedule(deps: &[CodeDep]) -> Schedule {
let mut out = Schedule {
blocking: deps.iter().map(|d| d.needs.len()).sum(),
edges: deps
.iter()
.map(|d| d.needs.len().saturating_add(d.seam.len()))
.sum(),
..Schedule::default()
};
let mut built: Vec<String> = Vec::new();
let mut rest: Vec<&CodeDep> = deps.iter().collect();
while !rest.is_empty() {
let (ready, waiting) = split_ready(rest, &built);
if ready.is_empty() {
out.blocked = labels(&waiting);
break;
}
built.extend(labels(&ready));
out.rounds.push(labels(&ready));
rest = waiting;
}
out
}
fn split_ready<'a>(
rest: Vec<&'a CodeDep>,
built: &[String],
) -> (Vec<&'a CodeDep>, Vec<&'a CodeDep>) {
rest.into_iter()
.partition(|d| d.needs.iter().all(|n| built.contains(n)))
}
fn labels(ds: &[&CodeDep]) -> Vec<String> {
let mut out: Vec<String> = ds.iter().map(|d| d.node.clone()).collect();
out.sort();
out
}
#[must_use]
pub fn wave(root: &Path, dir: &Path) -> Schedule {
let deps = code_deps(root);
let keep: Vec<String> = deps
.iter()
.map(|d| d.node.clone())
.filter(|l| node_path(root, l).starts_with(dir))
.collect();
schedule(&scoped(&deps, &keep))
}
fn node_path(root: &Path, label: &str) -> PathBuf {
if label == "." {
root.to_path_buf()
} else {
root.join(label)
}
}
fn within(labels: &[String], keep: &[String]) -> Vec<String> {
labels
.iter()
.filter(|l| keep.contains(l))
.cloned()
.collect()
}
fn scoped(deps: &[CodeDep], keep: &[String]) -> Vec<CodeDep> {
deps.iter()
.filter(|d| keep.contains(&d.node))
.map(|d| CodeDep {
node: d.node.clone(),
needs: within(&d.needs, keep),
seam: within(&d.seam, keep),
})
.collect()
}
#[cfg(test)]
#[path = "tests/wave.rs"]
mod wave_tests;