+/// A single span of changed lines, with 0 or more removed lines
+/// and a vector of 0 or more inserted lines.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ModifiedChunk {
+ /// The first to be removed from the original text
+ pub line_number_orig: u32,
+ /// The number of lines which have been replaced
+ pub lines_removed: u32,
+ /// The new lines
+ pub lines: Vec<String>,
+}
+
+/// Set of changed sections of a file.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ModifiedLines {
+ /// The set of changed chunks.
+ pub chunks: Vec<ModifiedChunk>,
+}
+
+impl From<Vec<Mismatch>> for ModifiedLines {
+ fn from(mismatches: Vec<Mismatch>) -> ModifiedLines {
+ let chunks = mismatches.into_iter().map(|mismatch| {
+ let lines = mismatch.lines.iter();
+ let num_removed = lines
+ .filter(|line| matches!(line, DiffLine::Resulting(_)))
+ .count();
+
+ let new_lines = mismatch.lines.into_iter().filter_map(|line| match line {
+ DiffLine::Context(_) | DiffLine::Resulting(_) => None,
+ DiffLine::Expected(str) => Some(str),
+ });
+
+ ModifiedChunk {
+ line_number_orig: mismatch.line_number_orig,
+ lines_removed: num_removed as u32,
+ lines: new_lines.collect(),
+ }
+ });
+
+ ModifiedLines {
+ chunks: chunks.collect(),
+ }
+ }
+}
+
+// Converts a `Mismatch` into a serialized form, which just includes
+// enough information to modify the original file.
+// Each section starts with a line with three integers, space separated:
+// lineno num_removed num_added
+// followed by (`num_added`) lines of added text. The line numbers are
+// relative to the original file.
+impl fmt::Display for ModifiedLines {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ for chunk in &self.chunks {
+ writeln!(
+ f,
+ "{} {} {}",
+ chunk.line_number_orig,
+ chunk.lines_removed,
+ chunk.lines.len()
+ )?;
+
+ for line in &chunk.lines {
+ writeln!(f, "{}", line)?;
+ }
+ }
+
+ Ok(())
+ }
+}
+
+// Allows to convert `Display`ed `ModifiedLines` back to the structural data.
+impl std::str::FromStr for ModifiedLines {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<ModifiedLines, ()> {
+ let mut chunks = vec![];
+
+ let mut lines = s.lines();
+ while let Some(header) = lines.next() {
+ let mut header = header.split_whitespace();
+ let (orig, rem, new_lines) = match (header.next(), header.next(), header.next()) {
+ (Some(orig), Some(removed), Some(added)) => (orig, removed, added),
+ _ => return Err(()),
+ };
+ let (orig, rem, new_lines): (u32, u32, usize) =
+ match (orig.parse(), rem.parse(), new_lines.parse()) {
+ (Ok(a), Ok(b), Ok(c)) => (a, b, c),
+ _ => return Err(()),
+ };
+ let lines = lines.by_ref().take(new_lines);
+ let lines: Vec<_> = lines.map(ToOwned::to_owned).collect();
+ if lines.len() != new_lines {
+ return Err(());
+ }
+
+ chunks.push(ModifiedChunk {
+ line_number_orig: orig,
+ lines_removed: rem,
+ lines,
+ });
+ }
+
+ Ok(ModifiedLines { chunks })
+ }
+}
+