sefy 0.19.0

An inconspicuous encrypted store for notes, credentials and files
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Printing a line-by-line comparison, with long unchanged stretches folded.

use sefy_core::Line;

/// Unchanged lines kept on each side of a change; the rest are folded.
const CONTEXT: usize = 2;

/// Prints a comparison: `-` for what went, `+` for what came, and enough of
/// what stayed to see where. A stretch of unchanged lines longer than the
/// context on both sides becomes one line saying how many were skipped.
pub fn print(lines: &[Line<'_>]) {
    for line in render(lines) {
        println!("{line}");
    }
}

fn render(lines: &[Line<'_>]) -> Vec<String> {
    let changed: Vec<usize> = lines
        .iter()
        .enumerate()
        .filter(|(_, line)| !matches!(line, Line::Same(_)))
        .map(|(index, _)| index)
        .collect();
    let near_a_change = |index: usize| {
        changed
            .iter()
            .any(|&at| index + CONTEXT >= at && index <= at + CONTEXT)
    };

    let mut out = Vec::new();
    let mut folded = 0;
    for (index, line) in lines.iter().enumerate() {
        if let Line::Same(_) = line
            && !near_a_change(index)
        {
            folded += 1;
            continue;
        }
        if folded > 0 {
            out.push(fold(folded));
            folded = 0;
        }
        out.push(match line {
            Line::Same(text) => format!("    {text}"),
            Line::Removed(text) => format!("  - {text}"),
            Line::Added(text) => format!("  + {text}"),
        });
    }
    if folded > 0 {
        out.push(fold(folded));
    }
    out
}

fn fold(count: usize) -> String {
    format!("    … {}", crate::output::count(count, "unchanged line"))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_long_unchanged_stretch_is_folded_and_counted() {
        let old: Vec<String> = (0..20).map(|n| format!("line {n}")).collect();
        let mut new = old.clone();
        new[10] = "changed".to_owned();
        let (old, new) = (old.join("\n"), new.join("\n"));

        let rendered = render(&sefy_core::history::lines(&old, &new));

        assert_eq!(
            rendered,
            [
                "    … 8 unchanged lines",
                "    line 8",
                "    line 9",
                "  - line 10",
                "  + changed",
                "    line 11",
                "    line 12",
                "    … 7 unchanged lines",
            ]
        );
    }

    #[test]
    fn a_one_line_value_shows_as_what_went_and_what_came() {
        let rendered = render(&sefy_core::history::lines(
            "https://old.example.com",
            "https://new.example.com",
        ));
        assert_eq!(
            rendered,
            ["  - https://old.example.com", "  + https://new.example.com"]
        );
    }
}