use crate::{fed, spec};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
#[derive(Debug, Clone)]
pub struct Placement {
pub id: String,
pub home: String,
pub why: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct Proposal {
pub rows_in: usize,
pub placements: Vec<Placement>,
pub unplaced: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct Report {
pub rows_in: usize,
pub moved: usize,
pub stayed: usize,
pub files: Vec<String>,
pub carried: Vec<String>,
}
const ROOT: &str = ".";
fn dir_of(root: &Path, node: &str) -> PathBuf {
if node == ROOT {
root.to_path_buf()
} else {
root.join(node)
}
}
fn read_source(root: &Path, node: &str) -> Result<String, String> {
let path = dir_of(root, node).join("SPEC.md");
std::fs::read_to_string(&path)
.map_err(|e| format!("adopt: {}: {e}", path.display()))
}
fn below(home: &str, node: &str) -> bool {
if node == ROOT {
return home != ROOT;
}
home.strip_prefix(node).is_some_and(|r| r.starts_with('/'))
}
fn spec_of(node: &str) -> String {
if node == ROOT {
"SPEC.md".into()
} else {
format!("{node}/SPEC.md")
}
}
pub fn unreadable(root: &Path) -> Result<Vec<spec::Unreadable>, String> {
unreadable_at(root, ROOT)
}
pub fn unreadable_at(
root: &Path,
node: &str,
) -> Result<Vec<spec::Unreadable>, String> {
Ok(spec::unreadable_rows(&read_source(root, node)?))
}
pub fn propose(root: &Path) -> Result<Proposal, String> {
propose_at(root, ROOT)
}
pub fn propose_at(root: &Path, node: &str) -> Result<Proposal, String> {
let source = read_source(root, node)?;
let homes: Vec<fed::Home> = fed::declared(root)
.into_iter()
.filter(|h| below(&h.node, node))
.collect();
let rows = spec::rows(&source);
let mut out = Proposal {
rows_in: rows.len(),
placements: vec![],
unplaced: vec![],
};
let scripts = fed::script_files(root);
for row in rows {
place(&mut out, row, &homes, (root, &scripts));
}
Ok(out)
}
fn place(
out: &mut Proposal,
row: spec::Row,
homes: &[fed::Home],
tree: (&Path, &[PathBuf]),
) {
let decided =
by_script(&row, homes, tree).unwrap_or_else(|| best(&row, homes));
match decided {
Some((home, why)) => out.placements.push(Placement {
id: row.id,
home,
why,
}),
None => out.unplaced.push(row.id),
}
}
fn by_script(
row: &spec::Row,
homes: &[fed::Home],
(root, scripts): (&Path, &[PathBuf]),
) -> Option<Option<(String, Vec<String>)>> {
let cited = crate::split::cited_scripts(&row.text, scripts);
if cited.is_empty() {
return None;
}
let owners: BTreeSet<Option<&str>> =
cited.iter().map(|s| owner(s, homes, root)).collect();
let why: Vec<String> = cited
.iter()
.map(|s| {
s.strip_prefix(root)
.unwrap_or(s)
.to_string_lossy()
.into_owned()
})
.collect();
let only: Vec<Option<&str>> = owners.into_iter().collect();
Some(match only.as_slice() {
[Some(home)] => Some(((*home).to_string(), why)),
_ => None,
})
}
fn owner<'h>(
script: &Path,
homes: &'h [fed::Home],
root: &Path,
) -> Option<&'h str> {
homes
.iter()
.filter(|h| script.starts_with(root.join(&h.node)))
.max_by_key(|h| Path::new(&h.node).components().count())
.map(|h| h.node.as_str())
}
fn best(row: &spec::Row, homes: &[fed::Home]) -> Option<(String, Vec<String>)> {
let words = significant(&subject(&row.text));
let mut hits: Vec<(String, Vec<String>)> = homes
.iter()
.map(|h| (h.node.clone(), matched(&words, &h.owns)))
.filter(|(_, w)| !w.is_empty())
.collect();
let top = hits.iter().map(|(_, w)| w.len()).max()?;
hits.retain(|(_, w)| w.len() == top);
(hits.len() == 1).then(|| hits.pop()).flatten()
}
fn subject(text: &str) -> String {
text.split('`')
.enumerate()
.filter(|(i, part)| i % 2 == 0 || !is_citation(part))
.map(|(_, part)| format!("{part} "))
.collect()
}
fn is_citation(span: &str) -> bool {
span.split_once(':').is_some_and(|(owner, id)| {
!owner.is_empty() && !spec::rows(&format!("{id}:")).is_empty()
})
}
fn significant(text: &str) -> Vec<String> {
let mut words: Vec<String> = text
.to_lowercase()
.split(|c: char| !c.is_alphanumeric())
.filter(|w| w.chars().count() >= 4)
.map(str::to_string)
.collect();
words.sort();
words.dedup();
words
}
fn matched(words: &[String], lens: &str) -> Vec<String> {
let lens = significant(lens);
words.iter().filter(|w| lens.contains(w)).cloned().collect()
}
pub fn read_map(text: &str) -> Result<BTreeMap<String, String>, String> {
let mut out = BTreeMap::new();
for raw in text.lines() {
let line = raw.split('#').next().unwrap_or("").trim();
if line.is_empty() {
continue;
}
let (id, node) = line
.split_once(char::is_whitespace)
.ok_or_else(|| format!("adopt: `{line}` is not `<id> <node>`"))?;
let seen = out.insert(id.to_string(), node.trim().to_string());
if seen.is_some() {
return Err(format!("adopt: {id} is given two homes"));
}
}
Ok(out)
}
#[must_use]
pub fn refusals(root: &Path, map: &BTreeMap<String, String>) -> Vec<String> {
refusals_at(root, ROOT, map)
}
#[must_use]
pub fn refusals_at(
root: &Path,
node: &str,
map: &BTreeMap<String, String>,
) -> Vec<String> {
let declared: BTreeSet<String> =
fed::declared(root).into_iter().map(|h| h.node).collect();
let source = read_source(root, node).unwrap_or_default();
let mut out: Vec<String> = map
.iter()
.filter_map(|entry| refusal(root, &declared, (node, &source), entry))
.collect();
out.extend(ranges_that_would_break(&source, map));
out
}
fn ranges_that_would_break(
source: &str,
map: &BTreeMap<String, String>,
) -> Vec<String> {
spec::milestone_cells(source)
.into_iter()
.filter_map(|(id, cell)| {
let claimed = claims_of(source, &id)?;
let spelled = cell.split(',').count();
if claimed.len() <= spelled {
return None;
}
let moving: Vec<String> = claimed
.iter()
.map(|n| format!("T{n}"))
.filter(|t| map.contains_key(t))
.collect();
(!moving.is_empty()).then(|| {
format!(
"adopt: `{id}` lists its tasks as a RANGE (`{cell}`) and this map moves {} -- a range cannot survive a split. Expand it into ids before adopting.",
moving.join(", ")
)
})
})
.collect()
}
fn claims_of(source: &str, id: &str) -> Option<Vec<u32>> {
spec::milestones(source)
.into_iter()
.find(|(m, _)| m == id)
.map(|(_, claimed)| claimed)
}
fn refusal(
root: &Path,
declared: &BTreeSet<String>,
(from, source): (&str, &str),
entry: (&String, &String),
) -> Option<String> {
let (id, node) = entry;
if !declared.contains(node) {
return Some(format!(
"adopt: no `\u{a7}F` row declares `{node}` -- adoption places rows onto structure that exists ({id})"
));
}
if node != from && !below(node, from) {
return Some(format!(
"adopt: `{node}` is not below `{from}` -- a row moves down the tree, into a node the source declares ({id})"
));
}
if !spec::declares(source, id) {
return Some(format!(
"adopt: the source, {}, declares no `{id}`",
spec_of(from)
));
}
let held = std::fs::read_to_string(root.join(node).join("SPEC.md"))
.is_ok_and(|t| spec::declares(&t, id));
held.then(|| {
format!("adopt: `{node}` already declares `{id}` -- moving it would make two rows with one id")
})
}
fn homes_of(
rows: &[spec::Row],
map: &BTreeMap<String, String>,
from: &str,
) -> BTreeMap<String, String> {
rows.iter()
.map(|r| {
let home =
map.get(&r.id).cloned().unwrap_or_else(|| from.to_string());
(r.id.clone(), home)
})
.collect()
}
struct Move<'a> {
from: &'a str,
homes: BTreeMap<String, String>,
}
impl Move<'_> {
fn moved(&self) -> BTreeMap<String, String> {
self.homes
.iter()
.filter(|(_, h)| *h != self.from)
.map(|(id, h)| (id.clone(), h.clone()))
.collect()
}
fn rehome(&self, text: &str, here: &str) -> String {
let moved = self.moved();
let lines: Vec<String> = text
.split_inclusive('\n')
.map(|l| spec::rehome(l, here, self.from, &moved))
.collect();
lines.concat()
}
}
pub fn apply(
root: &Path,
map: &BTreeMap<String, String>,
) -> Result<Report, String> {
apply_at(root, ROOT, map)
}
pub fn apply_at(
root: &Path,
node: &str,
map: &BTreeMap<String, String>,
) -> Result<Report, String> {
let refused = refusals_at(root, node, map);
if !refused.is_empty() {
return Err(refused.join("\n"));
}
let source = read_source(root, node)?;
let rows = spec::rows(&source);
let mv = Move {
from: node,
homes: homes_of(&rows, map, node),
};
let writes = writes_for(root, &source, &rows, &mv);
checked(&writes)?;
let carried = carried(&writes);
commit(&writes)?;
let mut out = report(&rows, &mv, &writes);
out.carried = carried;
Ok(out)
}
fn writes_for(
root: &Path,
source: &str,
rows: &[spec::Row],
mv: &Move,
) -> Vec<(PathBuf, String)> {
let moved: BTreeSet<String> = mv.moved().into_keys().collect();
let mut out = vec![(
dir_of(root, mv.from).join("SPEC.md"),
mv.rehome(&source_after(source, &moved, mv), mv.from),
)];
out.extend(
destinations(mv)
.into_iter()
.map(|node| write_for(root, rows, mv, node)),
);
out.extend(bystanders(root, mv, &out));
out
}
fn bystanders(
root: &Path,
mv: &Move,
written: &[(PathBuf, String)],
) -> Vec<(PathBuf, String)> {
fed::discover(root)
.into_iter()
.map(|dir| dir.join("SPEC.md"))
.filter(|p| written.iter().all(|(w, _)| w != p))
.filter_map(|path| {
let text = std::fs::read_to_string(&path).ok()?;
let here = node_name(root, path.parent()?);
let new = mv.rehome(&text, &here);
(new != text).then_some((path, new))
})
.collect()
}
fn node_name(root: &Path, dir: &Path) -> String {
let rel = dir.strip_prefix(root).unwrap_or(dir);
if rel.as_os_str().is_empty() {
ROOT.into()
} else {
rel.to_string_lossy().into_owned()
}
}
fn write_for(
root: &Path,
rows: &[spec::Row],
mv: &Move,
node: String,
) -> (PathBuf, String) {
let batch: Vec<&spec::Row> = rows
.iter()
.filter(|r| mv.homes.get(&r.id).is_some_and(|h| *h == node))
.collect();
let path = root.join(&node).join("SPEC.md");
let text = std::fs::read_to_string(&path).unwrap_or_default();
let new = mv.rehome(&receive(&text, &node, &batch, &mv.homes), &node);
(path, new)
}
fn destinations(mv: &Move) -> BTreeSet<String> {
mv.moved().into_values().collect()
}
fn source_after(source: &str, moved: &BTreeSet<String>, mv: &Move) -> String {
let kept: Vec<String> = source
.lines()
.filter(|l| !opens_a_moved_row(l, moved))
.map(|l| spec::requalify(l, mv.from, &mv.homes))
.collect();
format!("{}\n", kept.join("\n").trim_end())
}
fn opens_a_moved_row(line: &str, moved: &BTreeSet<String>) -> bool {
spec::rows(line)
.first()
.is_some_and(|r| moved.contains(&r.id))
}
fn receive(
text: &str,
node: &str,
rows: &[&spec::Row],
homes: &BTreeMap<String, String>,
) -> String {
let mut out = text.to_string();
for letter in ['R', 'V', 'T', 'B'] {
let batch: Vec<String> = rows
.iter()
.filter(|r| r.section == letter)
.map(|r| spec::requalify(&r.text, node, homes))
.collect();
if !batch.is_empty() {
out = add_rows(&out, letter, &batch);
}
}
out
}
fn add_rows(text: &str, letter: char, batch: &[String]) -> String {
let Some(anchor) = anchor_for(text, letter) else {
return text.to_string();
};
let head = existing_body(text, letter).unwrap_or_else(|| {
format!("## \u{a7}{}{}", name(letter), header(letter))
});
let body = in_id_order(&head, batch);
let (sec, at) = (letter.to_string(), anchor.to_string());
spec::upsert_section(text, &sec, body.trim_end(), &at)
}
fn in_id_order(head: &str, batch: &[String]) -> String {
let mut lines: Vec<String> = head.lines().map(str::to_string).collect();
for row in batch {
let n = id_number(row).unwrap_or(u64::MAX);
let at = lines
.iter()
.position(|l| id_number(l).is_some_and(|m| m > n))
.unwrap_or(lines.len());
lines.insert(at, row.clone());
}
lines.join("\n")
}
fn id_number(line: &str) -> Option<u64> {
let row = spec::rows(line).into_iter().next()?;
row.id.get(1..)?.parse().ok()
}
fn existing_body(text: &str, letter: char) -> Option<String> {
let head = format!("## \u{a7}{letter}");
spec::sections(text)
.into_iter()
.find(|(h, _)| h.starts_with(&head))
.map(|(h, b)| format!("{h}\n{}", b.trim_end()))
}
const ORDER: [char; 9] = ['G', 'F', 'N', 'C', 'I', 'R', 'V', 'T', 'B'];
fn anchor_for(text: &str, letter: char) -> Option<char> {
if existing_body(text, letter).is_some() {
return Some(letter);
}
let want = ORDER.iter().position(|c| *c == letter)?;
let present: BTreeSet<char> = spec::sections(text)
.iter()
.filter_map(|(h, _)| h.strip_prefix("## \u{a7}")?.chars().next())
.collect();
ORDER
.iter()
.take(want)
.rev()
.find(|c| present.contains(c))
.copied()
}
fn name(letter: char) -> &'static str {
match letter {
'R' => "R RESEARCH",
'V' => "V INVARIANTS",
'T' => "T TASKS",
_ => "B BUGS",
}
}
fn header(letter: char) -> &'static str {
match letter {
'R' => "\n\nid|topic|finding|src",
'T' => "\n\nid|status|task|cites",
'B' => "\n\nid|date|cause|fix",
_ => "\n",
}
}
fn checked(writes: &[(PathBuf, String)]) -> Result<(), String> {
let bad: Vec<String> =
writes.iter().flat_map(|(p, t)| introduced(p, t)).collect();
if bad.is_empty() {
return Ok(());
}
Err(format!(
"adopt: the migration would ADD these, so nothing was written:\n{}",
bad.join("\n")
))
}
fn introduced(path: &Path, after: &str) -> Vec<String> {
let existing = std::fs::read_to_string(path).unwrap_or_default();
let mut before = counted(&existing);
spec::check(after)
.into_iter()
.map(|v| v.to_string())
.filter(|v| !spend(&mut before, v))
.map(|v| format!("{}: {v}", path.display()))
.collect()
}
fn counted(text: &str) -> BTreeMap<String, usize> {
let mut out: BTreeMap<String, usize> = BTreeMap::new();
for v in spec::check(text) {
let n = out.entry(v.to_string()).or_default();
*n = n.saturating_add(1);
}
out
}
fn spend(before: &mut BTreeMap<String, usize>, v: &str) -> bool {
match before.get_mut(v) {
Some(n) if *n > 0 => {
*n = n.saturating_sub(1);
true
}
_ => false,
}
}
fn carried(writes: &[(PathBuf, String)]) -> Vec<String> {
writes
.iter()
.flat_map(|(p, _)| {
let text = std::fs::read_to_string(p).unwrap_or_default();
spec::check(&text)
.into_iter()
.map(move |v| format!("{}: {v}", p.display()))
})
.collect()
}
fn commit(writes: &[(PathBuf, String)]) -> Result<(), String> {
for (path, text) in writes {
std::fs::write(path, text)
.map_err(|e| format!("adopt: {}: {e}", path.display()))?;
}
Ok(())
}
fn report(
rows: &[spec::Row],
mv: &Move,
writes: &[(PathBuf, String)],
) -> Report {
let moved = rows
.iter()
.filter(|r| mv.homes.get(&r.id).is_some_and(|h| h != mv.from))
.count();
Report {
rows_in: rows.len(),
moved,
stayed: rows.len().saturating_sub(moved),
files: writes
.iter()
.map(|(p, _)| p.display().to_string())
.collect(),
carried: vec![],
}
}
#[cfg(test)]
#[path = "tests/adopt.rs"]
mod tests;
#[cfg(test)]
#[path = "tests/subtree.rs"]
mod subtree_tests;
#[cfg(test)]
#[path = "tests/script.rs"]
mod script_tests;