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>,
}
fn read_source(root: &Path) -> Result<String, String> {
let path = root.join("SPEC.md");
std::fs::read_to_string(&path)
.map_err(|e| format!("adopt: {}: {e}", path.display()))
}
pub fn unreadable(root: &Path) -> Result<Vec<spec::Unreadable>, String> {
Ok(spec::unreadable_rows(&read_source(root)?))
}
pub fn propose(root: &Path) -> Result<Proposal, String> {
let source = read_source(root)?;
let homes: Vec<fed::Home> = fed::declared(root)
.into_iter()
.filter(|h| h.node != ".")
.collect();
let rows = spec::rows(&source);
let mut out = Proposal {
rows_in: rows.len(),
placements: vec![],
unplaced: vec![],
};
for row in rows {
place(&mut out, row, &homes);
}
Ok(out)
}
fn place(out: &mut Proposal, row: spec::Row, homes: &[fed::Home]) {
match best(&row, homes) {
Some((home, why)) => out.placements.push(Placement {
id: row.id,
home,
why,
}),
None => out.unplaced.push(row.id),
}
}
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> {
let declared: BTreeSet<String> =
fed::declared(root).into_iter().map(|h| h.node).collect();
let source = read_source(root).unwrap_or_default();
let mut out: Vec<String> = map
.iter()
.filter_map(|(id, node)| refusal(root, &declared, &source, (id, node)))
.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>,
source: &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 !spec::declares(source, id) {
return Some(format!("adopt: the source declares no `{id}`"));
}
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>,
) -> BTreeMap<String, String> {
rows.iter()
.map(|r| {
let home =
map.get(&r.id).cloned().unwrap_or_else(|| ".".to_string());
(r.id.clone(), home)
})
.collect()
}
pub fn apply(
root: &Path,
map: &BTreeMap<String, String>,
) -> Result<Report, String> {
let refused = refusals(root, map);
if !refused.is_empty() {
return Err(refused.join("\n"));
}
let source = read_source(root)?;
let rows = spec::rows(&source);
let homes = homes_of(&rows, map);
let writes = writes_for(root, &source, &rows, &homes);
checked(&writes)?;
let carried = carried(&writes);
commit(&writes)?;
let mut out = report(&rows, &homes, &writes);
out.carried = carried;
Ok(out)
}
fn writes_for(
root: &Path,
source: &str,
rows: &[spec::Row],
homes: &BTreeMap<String, String>,
) -> Vec<(PathBuf, String)> {
let moved: BTreeSet<String> = homes
.iter()
.filter(|(_, h)| *h != ".")
.map(|(id, _)| id.clone())
.collect();
let mut out =
vec![(root.join("SPEC.md"), root_after(source, &moved, homes))];
out.extend(
destinations(homes)
.into_iter()
.map(|node| write_for(root, rows, homes, node)),
);
out
}
fn write_for(
root: &Path,
rows: &[spec::Row],
homes: &BTreeMap<String, String>,
node: String,
) -> (PathBuf, String) {
let batch: Vec<&spec::Row> = rows
.iter()
.filter(|r| 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 = receive(&text, &node, &batch, homes);
(path, new)
}
fn destinations(homes: &BTreeMap<String, String>) -> BTreeSet<String> {
homes.values().filter(|h| *h != ".").cloned().collect()
}
fn root_after(
source: &str,
moved: &BTreeSet<String>,
homes: &BTreeMap<String, String>,
) -> String {
let kept: Vec<String> = source
.lines()
.filter(|l| !opens_a_moved_row(l, moved))
.map(|l| spec::requalify(l, ".", 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],
homes: &BTreeMap<String, String>,
writes: &[(PathBuf, String)],
) -> Report {
let moved = rows
.iter()
.filter(|r| homes.get(&r.id).is_some_and(|h| h != "."))
.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;