use std::collections::{BTreeMap, BTreeSet};
use toml_edit::{DocumentMut, Item, Key, Table};
use crate::decor::{Marker, Prefix, PrefixLine};
use crate::path::DottedPath;
use crate::source::SourceDocument;
#[derive(Debug, Clone, Default)]
pub struct Template {
pub(crate) root: Table,
pub(crate) unread: BTreeSet<String>,
pub(crate) read: BTreeSet<String>,
pub(crate) written_above: BTreeMap<DottedPath, DottedPath>,
}
impl Template {
pub fn of(defaults: &SourceDocument, marker: &Marker) -> Self {
let mut template = Self::default();
let Some(root) = defaults.root() else {
return template;
};
let mut section = None;
template.walk(root, None, &mut section, marker);
let prefix = Prefix::from_text(defaults.trailing());
let (mut lines, touching) = prefix.split(marker);
lines.extend(touching);
template.read_region(&lines, section.as_ref(), None, marker);
template
}
fn walk(
&mut self,
table: &Table,
within: Option<&DottedPath>,
section: &mut Option<DottedPath>,
marker: &Marker,
) {
for (name, item) in table.iter() {
let Some(key) = table.key(name) else {
continue;
};
let child = match within {
Some(path) => path.child(name),
None => DottedPath::new(name),
};
let reading = match item {
Item::Table(sub) if !sub.is_dotted() => section.clone(),
Item::ArrayOfTables(_) => section.clone(),
_ => within.cloned(),
};
let (floating, _) = Prefix::of(crate::merge::decor_of(key, item)).split(marker);
self.read_region(&floating, reading.as_ref(), Some(&child), marker);
if let Item::Table(sub) = item {
if !sub.is_dotted() {
*section = Some(child.clone());
}
self.walk(sub, Some(&child), section, marker);
}
}
}
fn read_region(
&mut self,
lines: &[PrefixLine],
within: Option<&DottedPath>,
above: Option<&DottedPath>,
marker: &Marker,
) {
let mut scaffold = within.cloned();
for block in crate::merge::blocks(lines, marker) {
if let Some(header) = header_of(block, marker) {
scaffold = Some(header);
}
let text = block
.iter()
.filter(|line| !matches!(line, PrefixLine::User { .. }))
.map(|line| line.text().to_owned())
.collect::<Vec<_>>()
.join("\n");
if self.read_block(block, scaffold.as_ref(), above, marker) {
self.read.insert(text);
} else {
self.unread.insert(text);
}
}
}
fn read_block(
&mut self,
block: &[PrefixLine],
scaffold: Option<&DottedPath>,
above: Option<&DottedPath>,
marker: &Marker,
) -> bool {
if !block
.iter()
.any(|line| matches!(line, PrefixLine::Sample { .. }))
{
return false;
}
let Ok(document) = source_of(block, scaffold, marker).parse::<DocumentMut>() else {
return false;
};
if document
.trailing()
.as_str()
.is_some_and(|text| !text.trim().is_empty())
{
return false;
}
let mut merged = self.root.clone();
if !graft(&mut merged, document.as_table()) {
return false;
}
self.root = merged;
if let Some(above) = above {
let mut paths = Vec::new();
collect_paths(document.as_table(), None, &mut paths);
for path in paths {
self.written_above
.entry(path)
.or_insert_with(|| above.clone());
}
}
true
}
pub(crate) fn written_before(&self, path: &DottedPath) -> Option<&DottedPath> {
self.written_above.get(path)
}
pub(crate) fn knows(&self, path: &DottedPath) -> bool {
let mut table = &self.root;
let mut segments = path.segments().peekable();
while let Some(segment) = segments.next() {
let Some(item) = table.get(segment) else {
return false;
};
if segments.peek().is_none() {
return true;
}
table = match item {
Item::Table(sub) => sub,
Item::ArrayOfTables(array) => match array.get(0) {
Some(first) => first,
None => return false,
},
_ => return false,
};
}
false
}
pub(crate) fn under(&self, path: Option<&DottedPath>) -> Option<&Table> {
let Some(path) = path else {
return Some(&self.root);
};
let mut table = &self.root;
for segment in path.segments() {
table = match table.get(segment)? {
Item::Table(sub) => sub,
Item::ArrayOfTables(array) => array.get(0)?,
_ => return None,
};
}
Some(table)
}
}
fn source_of(block: &[PrefixLine], scaffold: Option<&DottedPath>, marker: &Marker) -> String {
let mut source = String::new();
if let Some(path) = scaffold
&& header_of(block, marker).is_none()
{
source.push_str(&format!("[{path}]\n"));
}
for line in block {
match line {
PrefixLine::Sample { text } => source.push_str(&marker.undress(text)),
PrefixLine::Prose { text } => source.push_str(text.trim_start()),
PrefixLine::Blank { text } => source.push_str(text),
PrefixLine::User { .. } => continue,
}
source.push('\n');
}
source
}
fn collect_paths(table: &Table, within: Option<&DottedPath>, out: &mut Vec<DottedPath>) {
for (name, item) in table.iter() {
let child = match within {
Some(path) => path.child(name),
None => DottedPath::new(name),
};
out.push(child.clone());
match item {
Item::Table(sub) => collect_paths(sub, Some(&child), out),
Item::ArrayOfTables(array) => {
for entry in array.iter() {
collect_paths(entry, Some(&child), out);
}
}
_ => {}
}
}
}
fn space_tables(item: &mut Item) {
let tables: Vec<&mut Table> = match item {
Item::Table(table) => vec![table],
Item::ArrayOfTables(array) => {
for entry in array.iter_mut().skip(1) {
space(entry.decor_mut());
}
array.iter_mut().collect()
}
_ => return,
};
for table in tables {
for (_, nested) in table.iter_mut() {
match nested {
Item::Table(sub) => space(sub.decor_mut()),
Item::ArrayOfTables(array) => {
for entry in array.iter_mut() {
space(entry.decor_mut());
}
}
_ => continue,
}
space_tables(nested);
}
}
}
fn space(decor: &mut toml_edit::Decor) {
let prefix = decor
.prefix()
.and_then(|raw| raw.as_str())
.unwrap_or_default()
.to_owned();
if prefix.trim().is_empty() {
decor.clear();
} else if !prefix.starts_with('\n') {
decor.set_prefix(format!("\n{prefix}"));
}
}
fn header_of(block: &[PrefixLine], marker: &Marker) -> Option<DottedPath> {
let body = block.iter().find_map(|line| match line {
PrefixLine::Sample { text } => {
let body = marker.undress(text);
body.trim_start().starts_with('[').then_some(body)
}
_ => None,
})?;
let body = body.trim();
let inner = body
.strip_prefix("[[")
.and_then(|rest| rest.split("]]").next())
.or_else(|| {
body.strip_prefix('[')
.and_then(|rest| rest.split(']').next())
})?;
DottedPath::parse(inner).ok()
}
fn graft(into: &mut Table, from: &Table) -> bool {
for (name, item) in from.iter() {
let Some(key) = from.key(name) else {
continue;
};
match (into.get_mut(name), item) {
(None, _) => {
into.insert_formatted(key, item.clone());
}
(Some(Item::Table(there)), Item::Table(here)) => {
if !graft(there, here) {
return false;
}
}
(Some(Item::ArrayOfTables(there)), Item::Table(here)) => match there.get_mut(0) {
Some(first) => {
if !graft(first, here) {
return false;
}
}
None => return false,
},
(Some(Item::ArrayOfTables(there)), Item::ArrayOfTables(here)) => {
for entry in here.iter() {
there.push(entry.clone());
}
}
_ => return false,
}
}
true
}
pub(crate) fn comment_out(
path: &DottedPath,
key: &Key,
item: &Item,
marker: &Marker,
) -> Vec<String> {
let mut document = DocumentMut::new();
let mut table = document.as_table_mut();
let mut segments: Vec<&str> = if matches!(item, Item::Value(_)) {
Vec::new()
} else {
path.segments().collect()
};
segments.pop();
for segment in segments {
let entry = table.entry(segment).or_insert_with(|| {
let mut created = Table::new();
created.set_implicit(true);
Item::Table(created)
});
let Some(sub) = entry.as_table_mut() else {
return Vec::new();
};
table = sub;
}
let mut item = item.clone();
space_tables(&mut item);
table.insert_formatted(key, item);
document
.to_string()
.lines()
.map(|line| {
if marker.owns(line) || line.trim().is_empty() && line.is_empty() {
line.to_owned()
} else if line.trim().is_empty() {
marker.sample().to_owned()
} else {
format!("{} {line}", marker.sample())
}
})
.collect()
}