grit-lib 0.5.24

Core library for the grit Git implementation
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! `grit_lib::diff::DiffStat`: per-file counts, totals and change bars from listed file diffs.

use grit_lib::diff::{
    build_file_diffs, DiffDetail, DiffOptions, DiffStat, DiffStatus, DiffTotals, FileStat,
    LineStat, ListedFileDiff, StatBar,
};
use grit_lib::objects::{serialize_tree, ObjectId, ObjectKind, TreeEntry};
use grit_lib::parallel::ThreadPolicy;
use grit_lib::repo::{InitOptions, Repository};

fn tree_with(repo: &Repository, entries: &[(&str, &[u8])]) -> ObjectId {
    let entries: Vec<TreeEntry> = entries
        .iter()
        .map(|(name, data)| TreeEntry {
            mode: 0o100644,
            name: name.as_bytes().to_vec(),
            oid: repo.odb().write(ObjectKind::Blob, data).expect("blob"),
        })
        .collect();
    repo.odb()
        .write(ObjectKind::Tree, &serialize_tree(&entries))
        .expect("tree")
}

fn listed(
    repo: &Repository,
    old: &ObjectId,
    new: &ObjectId,
    detail: DiffDetail,
) -> Vec<ListedFileDiff> {
    let entries = repo
        .diff()
        .tree_to_tree(Some(old), Some(new))
        .expect("tree diff");
    let config = repo.config().expect("config");
    build_file_diffs(
        repo.odb(),
        entries,
        detail,
        DiffOptions::default(),
        config.as_ref(),
        &ThreadPolicy::default(),
    )
    .expect("file diffs")
    .files
}

#[test]
fn stat_and_patch_details_give_the_same_diffstat() {
    let dir = tempfile::tempdir().expect("tempdir");
    let repo = Repository::init(dir.path(), &InitOptions::default()).expect("init");
    let old = tree_with(
        &repo,
        &[
            ("bin.dat", &[0, 1, 2]),
            ("edit.txt", b"a\nb\nc\nd\n"),
            ("gone.txt", b"x\ny\n"),
        ],
    );
    let new = tree_with(
        &repo,
        &[
            ("bin.dat", &[0, 1, 2, 3]),
            ("edit.txt", b"a\nB\nc\nd\ne\n"),
            ("new.txt", b"1\n2\n3\n"),
        ],
    );

    let from_stat = DiffStat::from_files(&listed(&repo, &old, &new, DiffDetail::Stat));
    let from_patch = DiffStat::from_files(&listed(&repo, &old, &new, DiffDetail::Patch));
    assert_eq!(from_stat, from_patch);

    let rows: Vec<_> = from_stat
        .files()
        .iter()
        .map(|f| (f.path.as_str(), f.status, f.binary, f.lines))
        .collect();
    let lines = |insertions, deletions| LineStat {
        insertions,
        deletions,
    };
    assert_eq!(
        rows,
        [
            ("bin.dat", DiffStatus::Modified, true, LineStat::default()),
            ("edit.txt", DiffStatus::Modified, false, lines(2, 1)),
            ("gone.txt", DiffStatus::Deleted, false, lines(0, 2)),
            ("new.txt", DiffStatus::Added, false, lines(3, 0)),
        ]
    );
    assert_eq!(
        from_stat.totals(),
        DiffTotals {
            files_changed: 4,
            insertions: 5,
            deletions: 3,
        }
    );
    assert_eq!(from_stat.max_changes(), 3);
    assert_eq!(
        from_stat.files()[1].lines.bar(from_stat.max_changes(), 40),
        StatBar { plus: 2, minus: 1 }
    );

    // Name-only listings carry no counts.
    let names = DiffStat::from_files(&listed(&repo, &old, &new, DiffDetail::NameOnly));
    assert_eq!(names.totals().files_changed, 4);
    assert_eq!(names.totals().insertions + names.totals().deletions, 0);
}

#[test]
fn diffstat_from_rows_sums_totals_in_order() {
    let row = |path: &str, insertions, deletions| FileStat {
        path: path.to_owned(),
        old_path: None,
        status: DiffStatus::Modified,
        binary: false,
        similarity: None,
        lines: LineStat {
            insertions,
            deletions,
        },
    };
    let stat: DiffStat = [row("z", 100, 0), row("a", 1, 1)].into_iter().collect();
    assert_eq!(stat.files()[0].path, "z");
    assert_eq!(stat.totals().insertions, 101);
    assert_eq!(stat.max_changes(), 100);
    assert_eq!(
        stat.files()[0].lines.bar(stat.max_changes(), 40),
        StatBar { plus: 40, minus: 0 }
    );
    assert_eq!(
        stat.files()[1].lines.bar(stat.max_changes(), 40),
        StatBar { plus: 0, minus: 1 }
    );
    assert_eq!(stat.clone().into_files().len(), 2);
    assert_eq!(DiffStat::new(Vec::new()), DiffStat::default());
}