path: root/src/edits.rs

use std::cmp::max;

use syntect::highlighting::StyleModifier;

use crate::edits::string_pair::StringPair;

/// Create background style sections for a region of removed/added lines.
/*
  This function is called iff a region of n minus lines followed
  by n plus lines is encountered, e.g. n successive lines have
  been partially changed.

  Consider the i-th such line and let m, p be the i-th minus and
  i-th plus line, respectively.  The following cases exist:

  1. Whitespace deleted at line beginning.
     => The deleted section is highlighted in m; p is unstyled.

  2. Whitespace inserted at line beginning.
     => The inserted section is highlighted in p; m is unstyled.

  3. An internal section of the line containing a non-whitespace character has been deleted.
     => The deleted section is highlighted in m; p is unstyled.

  4. An internal section of the line containing a non-whitespace character has been changed.
     => The original section is highlighted in m; the replacement is highlighted in p.

  5. An internal section of the line containing a non-whitespace character has been inserted.
     => The inserted section is highlighted in p; m is unstyled.

  Note that whitespace can be neither deleted nor inserted at the
  end of the line: the line by definition has no trailing
  whitespace.
*/
pub fn get_diff_style_sections(
    minus_lines: &Vec<String>,
    plus_lines: &Vec<String>,
    minus_style_modifier: StyleModifier,
    minus_emph_style_modifier: StyleModifier,
    plus_style_modifier: StyleModifier,
    plus_emph_style_modifier: StyleModifier,
) -> (
    Vec<Vec<(StyleModifier, String)>>,
    Vec<Vec<(StyleModifier, String)>>,
) {
    let mut minus_line_sections = Vec::new();
    let mut plus_line_sections = Vec::new();

    for (minus, plus) in minus_lines.iter().zip(plus_lines.iter()) {
        let string_pair = StringPair::new(minus, plus);
        let change_begin = string_pair.common_prefix_length;

        // We require that (right-trimmed length) >= (common prefix length). Consider:
        // minus = "a    "
        // plus  = "a b  "
        // Here, the right-trimmed length of minus is 1, yet the common prefix length is
        // 2. We resolve this by taking the following maxima:
        let minus_length = max(string_pair.lengths[0], string_pair.common_prefix_length);
        let plus_length = max(string_pair.lengths[1], string_pair.common_prefix_length);

        // We require that change_begin <= change_end. Consider:
        // minus = "a c"
        // plus  = "a b c"
        // Here, the common prefix length is 2, and the common suffix length is 2, yet the
        // length of minus is 3. This overlap between prefix and suffix leads to a violation of
        // the requirement. We resolve this by taking the following maxima:
        let minus_change_end = max(
            minus_length - string_pair.common_suffix_length,
            change_begin,
        );
        let plus_change_end = max(plus_length - string_pair.common_suffix_length, change_begin);

        minus_line_sections.push(vec![
            (minus_style_modifier, minus[0..change_begin].to_string()),
            (
                minus_emph_style_modifier,
                minus[change_begin..minus_change_end].to_string(),
            ),
            (minus_style_modifier, minus[minus_change_end..].to_string()),
        ]);
        plus_line_sections.push(vec![
            (plus_style_modifier, plus[0..change_begin].to_string()),
            (
                plus_emph_style_modifier,
                plus[change_begin..plus_change_end].to_string(),
            ),
            (plus_style_modifier, plus[plus_change_end..].to_string()),
        ]);
    }
    (minus_line_sections, plus_line_sections)
}

#[cfg(test)]
mod tests {
    use super::*;
    use syntect::highlighting::{Color, FontStyle};

    #[test]
    fn test_get_diff_style_sections_1() {
        let actual_edits = get_diff_style_sections(
            &vec!["aaa\n".to_string()],
            &vec!["aba\n".to_string()],
            MINUS,
            MINUS_EMPH,
            PLUS,
            PLUS_EMPH,
        );
        let expected_edits = (
            vec![as_strings(vec![
                (MINUS, "a"),
                (MINUS_EMPH, "a"),
                (MINUS, "a\n"),
            ])],
            vec![as_strings(vec![
                (PLUS, "a"),
                (PLUS_EMPH, "b"),
                (PLUS, "a\n"),
            ])],
        );

        assert_consistent(&expected_edits);
        assert_consistent(&actual_edits);
        assert_eq!(actual_edits, expected_edits);
    }

    #[test]
    fn test_get_diff_style_sections_2() {
        let actual_edits = get_diff_style_sections(
            &vec!["d.iteritems()\n".to_string()],
            &vec!["d.items()\n".to_string()],
            MINUS,
            MINUS_EMPH,
            PLUS,
            PLUS_EMPH,
        );
        let expected_edits = (
            vec![as_strings(vec![
                (MINUS, "d."),
                (MINUS_EMPH, "iter"),
                (MINUS, "items()\n"),
            ])],
            vec![as_strings(vec![
                (PLUS, "d."),
                (PLUS_EMPH, ""),
                (PLUS, "items()\n"),
            ])],
        );
        assert_consistent(&expected_edits);
        assert_consistent(&actual_edits);
        assert_eq!(actual_edits, expected_edits);
    }

    type StyleSection = (StyleModifier, String);
    type StyleSections = Vec<StyleSection>;
    type LineStyleSections = Vec<StyleSections>;
    type Edits = (LineStyleSections, LineStyleSections);

    fn assert_consistent(edits: &Edits) {
        let (minus_line_style_sections, plus_line_style_sections) = edits;
        for (minus_style_sections, plus_style_sections) in minus_line_style_sections
            .iter()
            .zip(plus_line_style_sections)
        {
            let (minus_total, minus_delta) = summarize_style_sections(minus_style_sections);
            let (plus_total, plus_delta) = summarize_style_sections(plus_style_sections);
            assert_eq!(minus_total - minus_delta, plus_total - plus_delta);
        }
    }

    fn summarize_style_sections(sections: &StyleSections) -> (usize, usize) {
        let mut total = 0;
        let mut delta = 0;
        for (style, s) in sections {
            total += s.len();
            if is_emph(style) {
                delta += s.len();
            }
        }
        (total, delta)
    }

    const RED: Color = Color::BLACK;
    const GREEN: Color = Color::WHITE;

    const MINUS: StyleModifier = StyleModifier {
        foreground: None,
        background: Some(RED),
        font_style: None,
    };

    const MINUS_EMPH: StyleModifier = StyleModifier {
        foreground: None,
        background: Some(RED),
        font_style: Some(FontStyle::BOLD),
    };

    const PLUS: StyleModifier = StyleModifier {
        foreground: None,
        background: Some(GREEN),
        font_style: None,
    };

    const PLUS_EMPH: StyleModifier = StyleModifier {
        foreground: None,
        background: Some(GREEN),
        font_style: Some(FontStyle::BOLD),
    };

    fn as_strings(sections: Vec<(StyleModifier, &str)>) -> StyleSections {
        let mut new_sections = Vec::new();
        for (style, s) in sections {
            new_sections.push((style, s.to_string()));
        }
        new_sections
    }

    // For debugging test failures:

    #[allow(dead_code)]
    fn compare_style_sections(actual: Edits, expected: Edits) {
        let (minus, plus) = actual;
        println!("actual minus:");
        print_line_style_sections(minus);
        println!("actual plus:");
        print_line_style_sections(plus);

        let (minus, plus) = expected;
        println!("expected minus:");
        print_line_style_sections(minus);
        pri