UI: Reduce context in config diff when space is limited

Author: davidlattimore

src/ui/full_term/problems_ui.rs

@@ -481,8 +481,13 @@ impl ProblemsUi {
             return;
         };
 
-        let lines = config_diff_lines(&self.config_path, &**edit, &self.edit_opts())
-            .unwrap_or_else(error_lines);
+        let lines = config_diff_lines(
+            &self.config_path,
+            &**edit,
+            &self.edit_opts(),
+            (area.height as usize).saturating_sub(4),
+        )
+        .unwrap_or_else(error_lines);
 
         let block = Block::default().title("Edit details").borders(Borders::ALL);
         let paragraph = Paragraph::new(lines)
@@ -740,6 +745,7 @@ fn config_diff_lines(
     config_path: &Path,
     edit: &dyn Edit,
     opts: &EditOpts,
+    max_lines: usize,
 ) -> Result<Vec<Line<'static>>> {
     let mut lines = Vec::new();
     lines.push(Line::from(edit.help().to_string()));
@@ -755,6 +761,7 @@ fn config_diff_lines(
         lines.push(Line::from(""));
         lines.push(Line::from("=== Diff of cackle.toml ==="));
     }
+    diff::remove_excess_context(&mut diff, max_lines - lines.len());
     lines.append(&mut diff);
     Ok(lines)
 }

src/ui/full_term/problems_ui/diff.rs

@@ -56,6 +56,72 @@ pub(super) fn diff_lines(original: &str, updated: &str) -> Vec<Line<'static>> {
     lines
 }
 
+/// Attempts, where possible to trim the supplied diff to less than `max_lines`.
+pub(super) fn remove_excess_context(lines: &mut Vec<Line>, max_lines: usize) {
+    struct ContextBlock {
+        start: usize,
+        length: usize,
+        to_take: usize,
+    }
+
+    let mut blocks = Vec::new();
+    let mut current_block = None;
+    for (offset, line) in lines.iter().enumerate() {
+        let is_context = line
+            .spans
+            .first()
+            .map(|span| span.content.starts_with(' '))
+            .unwrap_or(false);
+        if is_context {
+            current_block
+                .get_or_insert(ContextBlock {
+                    start: offset,
+                    length: 0,
+                    to_take: 0,
+                })
+                .length += 1;
+        } else if let Some(block) = current_block.take() {
+            blocks.push(block);
+        }
+    }
+    blocks.extend(current_block);
+
+    let mut to_reclaim = (lines.len() as isize).saturating_sub(max_lines as isize);
+    while to_reclaim > 0 {
+        if let Some(block) = blocks.iter_mut().max_by_key(|b| b.length - b.to_take) {
+            if block.length - block.to_take == 0 {
+                // We've run out of context to remove.
+                break;
+            }
+            if block.to_take > 0 {
+                to_reclaim -= 1;
+            }
+            block.to_take += 1;
+        }
+    }
+
+    let old_lines = std::mem::take(lines);
+    let mut block_index = 0;
+    blocks.retain(|block| block.to_take > 0);
+    for (offset, line) in old_lines.into_iter().enumerate() {
+        let Some(block) = blocks.get(block_index) else {
+            lines.push(line);
+            continue;
+        };
+        let skip_start = block.start + (block.length - block.to_take) / 2;
+        let skip_end = skip_start + block.to_take;
+        if offset < skip_start {
+            lines.push(line);
+            continue;
+        }
+        if offset >= skip_end {
+            lines.push(Line::from("..."));
+            lines.push(line);
+            block_index += 1;
+        }
+    }
+}
+
 #[test]
 fn test_diff_lines() {
     fn line_to_string(line: &Line) -> String {
@@ -115,3 +181,75 @@ fn test_diff_lines() {
     ];
     assert_eq!(lines, expected);
 }
+
+#[test]
+fn test_remove_excess_context() {
+    fn to_lines(text: &str) -> Vec<Line<'static>> {
+        text.lines()
+            .filter_map(|l| {
+                // Ignore @ - it's just there to tell indoc where the left margin is.
+                if !l.starts_with('@') {
+                    Some(Line::from(l.to_owned()))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    fn to_text(lines: &[Line]) -> String {
+        lines
+            .iter()
+            .map(|line| {
+                line.spans
+                    .iter()
+                    .map(|s| s.content.as_ref())
+                    .collect::<Vec<_>>()
+                    .join("")
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    use indoc::indoc;
+
+    let mut lines = to_lines(indoc! {r#"
+        @
+         [common]
+        -version = 1
+        +version = 2
+         a
+         b
+         c
+         d
+         e
+         f
+         g
+         h
+         i
+         j
+         k
+        +foo = 1
+         l
+         m
+         n
+    "#});
+    remove_excess_context(&mut lines, 11);
+    assert_eq!(
+        to_text(&lines),
+        to_text(&to_lines(indoc! {r#"
+            @
+             [common]
+            -version = 1
+            +version = 2
+             a
+            ...
+             j
+             k
+            +foo = 1
+             l
+             m
+             n
+        "#}))
+    );
+}