Merge pull request #253 from google:buffered-summary-refactor

PiperOrigin-RevId: 553777118

Author: copybara-github

googletest/src/matcher_support/summarize_diff.rs

@@ -47,7 +47,7 @@ pub(crate) fn create_diff(
             "\nDifference({} / {}):{}",
             LineStyle::extra_actual_style().style("actual"),
             LineStyle::extra_expected_style().style("expected"),
-            edit_list_summary(&edit_list)
+            edit_list.into_iter().collect::<BufferedSummary>(),
         )
         .into(),
         edit_distance::Difference::Unrelated => "".into(),
@@ -83,73 +83,150 @@ pub(crate) fn create_diff_reversed(
                 "\nDifference({} / {}):{}",
                 LineStyle::extra_actual_style().style("actual"),
                 LineStyle::extra_expected_style().style("expected"),
-                edit_list_summary(&edit_list)
+                edit_list.into_iter().collect::<BufferedSummary>(),
             )
             .into()
         }
         edit_distance::Difference::Unrelated => "".into(),
     }
 }
 
-fn edit_list_summary(edit_list: &[edit_distance::Edit<&str>]) -> String {
-    let mut summary = String::new();
-    // Use to collect common line and compress them.
-    let mut common_line_buffer = vec![];
-    for edit in edit_list {
-        let (style, line) = match edit {
-            edit_distance::Edit::Both(same) => {
-                common_line_buffer.push(*same);
-                continue;
-            }
-            edit_distance::Edit::ExtraActual(actual) => (LineStyle::extra_actual_style(), *actual),
-            edit_distance::Edit::ExtraExpected(expected) => {
-                (LineStyle::extra_expected_style(), *expected)
-            }
-            edit_distance::Edit::AdditionalActual => {
-                (LineStyle::comment_style(), "<---- remaining lines omitted ---->")
-            }
-        };
-        summary.push_str(&compress_common_lines(std::mem::take(&mut common_line_buffer)));
+// Aggregator collecting the lines to be printed in the difference summary.
+//
+// This is buffered in order to allow a future line to potentially impact how
+// the current line would be printed.
+struct BufferedSummary<'a> {
+    summary: String,
+    buffer: Buffer<'a>,
+}
+
+impl<'a> BufferedSummary<'a> {
+    // Appends a new line which is common to both actual and expected.
+    fn feed_common_lines(&mut self, common_line: &'a str) {
+        let Buffer::CommonLineBuffer(ref mut common_lines) = self.buffer;
+        common_lines.push(common_line);
+    }
+
+    // Appends a new line which is found only in the actual string.
+    fn feed_extra_actual(&mut self, extra_actual: &'a str) {
+        self.buffer.flush(&mut self.summary).unwrap();
+        write!(&mut self.summary, "\n{}", LineStyle::extra_actual_style().style(extra_actual))
+            .unwrap();
+    }
 
-        write!(&mut summary, "\n{}", style.style(line)).unwrap();
+    // Appends a new line which is found only in the expected string.
+    fn feed_extra_expected(&mut self, extra_expected: &str) {
+        self.flush_buffer();
+        write!(&mut self.summary, "\n{}", LineStyle::extra_expected_style().style(extra_expected))
+            .unwrap();
     }
-    summary.push_str(&compress_common_lines(common_line_buffer));
 
-    summary
+    // Appends a comment for the additional line at the start or the end of the
+    // actual string which should be omitted.
+    fn feed_additional_actual(&mut self) {
+        self.flush_buffer();
+        write!(
+            &mut self.summary,
+            "\n{}",
+            LineStyle::comment_style().style("<---- remaining lines omitted ---->")
+        )
+        .unwrap();
+    }
+
+    fn flush_buffer(&mut self) {
+        self.buffer.flush(&mut self.summary).unwrap();
+    }
 }
 
-// The number of the lines kept before and after the compressed lines.
-const COMMON_LINES_CONTEXT_SIZE: usize = 2;
+impl<'a> FromIterator<edit_distance::Edit<&'a str>> for BufferedSummary<'a> {
+    fn from_iter<T: IntoIterator<Item = edit_distance::Edit<&'a str>>>(iter: T) -> Self {
+        let mut buffered_summary =
+            BufferedSummary { summary: String::new(), buffer: Buffer::CommonLineBuffer(vec![]) };
+        for edit in iter {
+            match edit {
+                edit_distance::Edit::Both(same) => {
+                    buffered_summary.feed_common_lines(same);
+                }
+                edit_distance::Edit::ExtraActual(actual) => {
+                    buffered_summary.feed_extra_actual(actual);
+                }
+                edit_distance::Edit::ExtraExpected(expected) => {
+                    buffered_summary.feed_extra_expected(expected);
+                }
+                edit_distance::Edit::AdditionalActual => {
+                    buffered_summary.feed_additional_actual();
+                }
+            };
+        }
+        buffered_summary.flush_buffer();
 
-fn compress_common_lines(common_lines: Vec<&str>) -> String {
-    if common_lines.len() <= 2 * COMMON_LINES_CONTEXT_SIZE + 1 {
-        let mut all_lines = String::new();
-        for line in common_lines {
-            write!(&mut all_lines, "\n{}", LineStyle::unchanged_style().style(line)).unwrap();
+        buffered_summary
+    }
+}
+
+impl<'a> Display for BufferedSummary<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if !matches!(self.buffer, Buffer::CommonLineBuffer(ref b) if b.is_empty()) {
+            panic!("Buffer is not empty. This is a bug in gtest_rust.")
         }
-        return all_lines;
+        self.summary.fmt(f)
     }
+}
 
-    let mut truncated_lines = String::new();
+// This needs to be an enum as there will be in a follow-up PR new types of
+// buffer, most likely actual and expected lines, to be compared with expected
+// and actual lines for line to line comparison.
+enum Buffer<'a> {
+    CommonLineBuffer(Vec<&'a str>),
+}
 
-    for line in &common_lines[0..COMMON_LINES_CONTEXT_SIZE] {
-        write!(&mut truncated_lines, "\n{}", LineStyle::unchanged_style().style(line)).unwrap();
+impl<'a> Buffer<'a> {
+    fn flush(&mut self, writer: impl std::fmt::Write) -> std::fmt::Result {
+        match self {
+            Buffer::CommonLineBuffer(common_lines) => {
+                Self::flush_common_lines(std::mem::take(common_lines), writer)?
+            }
+        };
+        Ok(())
     }
 
-    write!(
-        &mut truncated_lines,
-        "\n{}",
-        LineStyle::comment_style().style(&format!(
-            "<---- {} common lines omitted ---->",
-            common_lines.len() - 2 * COMMON_LINES_CONTEXT_SIZE
-        )),
-    )
-    .unwrap();
-
-    for line in &common_lines[common_lines.len() - COMMON_LINES_CONTEXT_SIZE..common_lines.len()] {
-        write!(&mut truncated_lines, "\n{}", LineStyle::unchanged_style().style(line)).unwrap();
+    fn flush_common_lines(
+        common_lines: Vec<&'a str>,
+        mut writer: impl std::fmt::Write,
+    ) -> std::fmt::Result {
+        // The number of the lines kept before and after the compressed lines.
+        const COMMON_LINES_CONTEXT_SIZE: usize = 2;
+
+        if common_lines.len() <= 2 * COMMON_LINES_CONTEXT_SIZE + 1 {
+            for line in common_lines {
+                write!(writer, "\n{}", LineStyle::unchanged_style().style(line))?;
+            }
+            return Ok(());
+        }
+
+        let start_context = &common_lines[0..COMMON_LINES_CONTEXT_SIZE];
+
+        for line in start_context {
+            write!(writer, "\n{}", LineStyle::unchanged_style().style(line))?;
+        }
+
+        write!(
+            writer,
+            "\n{}",
+            LineStyle::comment_style().style(&format!(
+                "<---- {} common lines omitted ---->",
+                common_lines.len() - 2 * COMMON_LINES_CONTEXT_SIZE
+            )),
+        )?;
+
+        let end_context =
+            &common_lines[common_lines.len() - COMMON_LINES_CONTEXT_SIZE..common_lines.len()];
+
+        for line in end_context {
+            write!(writer, "\n{}", LineStyle::unchanged_style().style(line))?;
+        }
+        Ok(())
     }
-    truncated_lines
 }
 
 // Use ANSI code to enable styling on the summary lines.