mod dialect;
mod prose;
mod python;
mod walk;
mod zig;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
pub use dialect::{Dialect, Import, all as dialects, by_name as dialect};
pub use prose::Prose;
pub use walk::{SKIP, tracked};
use crate::pattern::Pattern;
#[derive(Clone)]
pub struct Edge {
pub src: String,
pub dst: String,
pub line: usize,
pub col: usize,
pub width: usize,
pub hops: u32,
pub spec: String,
}
impl Edge {
#[must_use]
pub fn key(&self) -> String {
format!("{} -> {}", self.src, self.dst)
}
}
pub struct Departure {
pub src: String,
pub spec: String,
pub line: usize,
pub col: usize,
pub width: usize,
}
impl Departure {
#[must_use]
pub fn key(&self) -> String {
format!("{} -> {}", self.src, self.spec)
}
}
pub struct Ask<'a> {
pub repo_root: &'a Path,
pub module_root: &'a Path,
pub exclude: &'a [Pattern],
pub dialect: &'static dyn Dialect,
pub package: &'a str,
pub tracked: Option<&'a HashSet<PathBuf>>,
}
pub struct Survey {
pub repo_root: PathBuf,
pub module_root: PathBuf,
pub files: Vec<String>,
pub edges: Vec<Edge>,
pub escapes: Vec<Departure>,
pub outside: Vec<Departure>,
pub skipped: usize,
pub spent: HashSet<String>,
pub dialect: &'static dyn Dialect,
}
impl Survey {
#[must_use]
pub fn of(ask: &Ask<'_>) -> Self {
let mut spent = HashSet::new();
let admitted: Vec<(PathBuf, String)> =
walk::source_files(ask.module_root, ask.dialect.extensions())
.into_iter()
.filter(|(_, rel)| !ask.dialect.manifests().contains(&rel.as_str()))
.filter(|(abs, rel)| {
let held: Vec<&str> = ask
.exclude
.iter()
.filter(|p| p.matches(rel))
.map(Pattern::as_str)
.collect();
if held.is_empty() {
ask.tracked.is_none_or(|t| t.contains(abs))
} else {
spent.extend(held.into_iter().map(str::to_owned));
false
}
})
.collect();
let judged: HashSet<&str> = admitted.iter().map(|(_, rel)| rel.as_str()).collect();
let roots: Vec<&str> = {
let mut set: Vec<&str> = admitted
.iter()
.map(|(_, rel)| match rel.split_once('/') {
Some((first, _)) => first,
None => stem(rel, ask.dialect.extensions()),
})
.collect();
set.sort_unstable();
set.dedup();
set
};
let (mut edges, mut escapes, mut skipped) = (Vec::new(), Vec::new(), 0);
let mut outside = Vec::new();
for (abs, src) in &admitted {
let Ok(raw) = fs::read_to_string(abs) else { continue };
let code = ask.dialect.prose().code_only(&raw);
let lines = Lines::of(&raw);
for import in ask.dialect.imports(src, &roots, ask.package, &raw, &code) {
let line = lines.at(import.offset);
let col = column(&raw, import.offset);
let width = raw[import.offset..]
.chars()
.take_while(|character| !character.is_whitespace() && *character != '(')
.count()
.max(1);
if !ask.dialect.is_local(&import.spec) {
outside.push(Departure {
src: src.clone(),
spec: import.spec,
line,
col,
width,
});
continue;
}
let Some(dst) = resolve(src, &import.spec) else {
escapes.push(Departure {
src: src.clone(),
spec: import.spec,
line,
col,
width,
});
continue;
};
if dst == *src {
continue;
}
if !judged.contains(dst.as_str()) {
skipped += 1;
continue;
}
edges.push(Edge {
hops: import.spec.matches("../").count() as u32,
src: src.clone(),
dst,
line,
col,
width,
spec: import.spec,
});
}
}
Self {
repo_root: ask.repo_root.to_path_buf(),
module_root: ask.module_root.to_path_buf(),
files: admitted.into_iter().map(|(_, rel)| rel).collect(),
edges,
escapes,
outside,
skipped,
spent,
dialect: ask.dialect,
}
}
#[must_use]
pub fn hypothetically(&self, edge: Edge) -> Self {
Self {
repo_root: self.repo_root.clone(),
module_root: self.module_root.clone(),
files: self.files.clone(),
edges: vec![edge],
escapes: Vec::new(),
outside: Vec::new(),
skipped: 0,
spent: self.spent.clone(),
dialect: self.dialect,
}
}
#[must_use]
pub fn modules(&self) -> Vec<&str> {
let mut names: Vec<&str> = self.outside.iter().map(|o| o.spec.as_str()).collect();
names.sort_unstable();
names.dedup();
names
}
#[must_use]
pub fn rel(&self, path: &str) -> String {
let absolute = self.module_root.join(path);
absolute.strip_prefix(&self.repo_root).map_or_else(
|_| absolute.to_string_lossy().into_owned(),
|p| p.to_string_lossy().replace('\\', "/"),
)
}
#[must_use]
pub fn importers(&self) -> HashMap<&str, Vec<&str>> {
let mut out: HashMap<&str, Vec<&str>> = HashMap::new();
for edge in &self.edges {
out.entry(&edge.dst).or_default().push(&edge.src);
}
out
}
#[must_use]
pub fn span_at(&self, path: &str, line: usize) -> (usize, usize) {
self.edges
.iter()
.map(|edge| (&edge.src, edge.line, edge.col, edge.width))
.chain(
self.escapes
.iter()
.chain(&self.outside)
.map(|edge| (&edge.src, edge.line, edge.col, edge.width)),
)
.find(|(source, edge_line, _, _)| source == &path && *edge_line == line)
.map_or((1, 1), |(_, _, col, width)| (col, width))
}
}
fn stem<'a>(rel: &'a str, extensions: &[&str]) -> &'a str {
extensions.iter().find_map(|ext| rel.strip_suffix(&format!(".{ext}"))).unwrap_or(rel)
}
fn column(source: &str, offset: usize) -> usize {
source[..offset.min(source.len())]
.rsplit_once('\n')
.map_or(source[..offset.min(source.len())].chars().count(), |(_, tail)| {
tail.chars().count()
})
+ 1
}
fn resolve(src: &str, spec: &str) -> Option<String> {
let mut parts: Vec<&str> =
src.rsplit_once('/').map_or_else(Vec::new, |(dir, _)| dir.split('/').collect());
for part in spec.split('/') {
match part {
"" | "." => {}
".." => {
parts.pop()?;
}
other => parts.push(other),
}
}
Some(parts.join("/"))
}
struct Lines(Vec<usize>);
impl Lines {
fn of(text: &str) -> Self {
Self(text.bytes().enumerate().filter(|&(_, b)| b == b'\n').map(|(i, _)| i).collect())
}
fn at(&self, offset: usize) -> usize {
self.0.partition_point(|&start| start < offset) + 1
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn imports_resolve_lexically_and_escapes_are_detected() {
assert_eq!(resolve("a/b/c.zig", "d.zig").as_deref(), Some("a/b/d.zig"));
assert_eq!(resolve("a/b/c.zig", "../d.zig").as_deref(), Some("a/d.zig"));
assert_eq!(resolve("a/b/c.zig", "../../d.zig").as_deref(), Some("d.zig"));
assert_eq!(resolve("a/b/c.zig", "../../../d.zig"), None, "climbs out");
assert_eq!(resolve("root.zig", "a/b.zig").as_deref(), Some("a/b.zig"));
assert_eq!(resolve("root.zig", "../x.zig"), None);
assert_eq!(resolve("a/b.zig", "./c.zig").as_deref(), Some("a/c.zig"));
}
#[test]
fn line_numbers_are_one_based_and_land_on_the_statement() {
let text = "one\ntwo\nthree\n";
let lines = Lines::of(text);
assert_eq!(lines.at(0), 1);
assert_eq!(lines.at(4), 2);
assert_eq!(lines.at(8), 3);
}
}