use std::io::Write;
use crate::mdx::MdxFile;
use crate::write::{MdxBuilder, WriteOptions, WriteSummary};
use crate::{Error, KeyOrdinal, Result};
#[derive(Debug, Clone, Default)]
pub struct EditSet {
deletions: Vec<KeyOrdinal>,
replacements: Vec<(KeyOrdinal, String)>,
insertions: Vec<(String, String)>,
}
impl EditSet {
pub fn new() -> Self {
Self::default()
}
pub fn delete(&mut self, ordinal: KeyOrdinal) -> &mut Self {
self.deletions.push(ordinal);
self
}
pub fn replace_body(&mut self, ordinal: KeyOrdinal, body: impl Into<String>) -> &mut Self {
self.replacements.push((ordinal, body.into()));
self
}
pub fn insert(&mut self, key: impl Into<String>, body: impl Into<String>) -> &mut Self {
self.insertions.push((key.into(), body.into()));
self
}
}
pub fn rebuild_mdx<W: Write>(
source: &MdxFile,
edits: &EditSet,
options: WriteOptions,
out: W,
) -> Result<WriteSummary> {
validate(edits)?;
let mut builder = MdxBuilder::with_options(options);
for entry in source.entries() {
let entry = entry?;
let ordinal = entry.key_entry().ordinal();
if edits.deletions.contains(&ordinal) {
continue;
}
let body = edits
.replacements
.iter()
.find(|(edited, _)| *edited == ordinal)
.map_or_else(|| entry.text(), |(_, body)| body.as_str());
builder.add_entry(entry.key(), body)?;
}
for (key, body) in &edits.insertions {
builder.add_entry(key, body)?;
}
builder.finish(out)
}
fn validate(edits: &EditSet) -> Result<()> {
for (index, ordinal) in edits.deletions.iter().enumerate() {
if edits.deletions[..index].contains(ordinal) {
return Err(Error::InvalidData(format!(
"entry {ordinal:?} is deleted more than once"
)));
}
if edits
.replacements
.iter()
.any(|(edited, _)| edited == ordinal)
{
return Err(Error::InvalidData(format!(
"entry {ordinal:?} is both deleted and replaced"
)));
}
}
for (index, (ordinal, _)) in edits.replacements.iter().enumerate() {
if edits.replacements[..index]
.iter()
.any(|(edited, _)| edited == ordinal)
{
return Err(Error::InvalidData(format!(
"entry {ordinal:?} is replaced more than once"
)));
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn conflicting_edits_are_refused() {
let ordinal = KeyOrdinal::from(0u64);
let mut edits = EditSet::new();
edits.delete(ordinal).replace_body(ordinal, "body");
assert!(validate(&edits).is_err());
let mut edits = EditSet::new();
edits.delete(ordinal).delete(ordinal);
assert!(validate(&edits).is_err());
let mut edits = EditSet::new();
edits
.replace_body(ordinal, "one")
.replace_body(ordinal, "two");
assert!(validate(&edits).is_err());
}
#[test]
fn disjoint_edits_are_accepted() {
let mut edits = EditSet::new();
edits
.delete(KeyOrdinal::from(0u64))
.replace_body(KeyOrdinal::from(1u64), "body")
.insert("key", "body");
assert!(validate(&edits).is_ok());
}
}