gitwell 0.1.1

Surface abandoned work in git repositories — stale branches, forgotten stashes, orphaned commits, WIP markers.
Documentation 
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

//! Integration tests for `scanner::stashes::StashScanner`.

mod common;

use common::TempRepo;
use gitwell::git::Repo;
use gitwell::scanner::stashes::StashScanner;
use gitwell::scanner::{Finding, Scanner};

#[test]
fn single_stash_is_captured_with_diff_stats() {
    let tr = TempRepo::new("stashes-one");
    tr.stash("draft.txt", "first line\nsecond line\n", "WIP draft work");

    let repo = Repo::open(tr.path()).expect("open repo");
    let findings = StashScanner.scan(&repo);

    assert_eq!(
        findings.len(),
        1,
        "expected exactly one stash; got {:?}",
        findings
    );

    match &findings[0] {
        Finding::Stash {
            index,
            sha,
            message,
            files_changed,
            insertions,
            deletions,
            ..
        } => {
            assert_eq!(index, "stash@{0}");
            assert!(
                !sha.is_empty(),
                "stash SHA must be captured for execute-time resolution"
            );
            assert_eq!(sha.len(), 40, "expected full 40-char SHA, got {}", sha);
            assert!(
                message.contains("WIP draft work"),
                "stash message should contain the user's text; got {:?}",
                message
            );
            assert_eq!(*files_changed, 1, "one file staged → one file in numstat");
            assert_eq!(*insertions, 2, "two lines added");
            assert_eq!(*deletions, 0);
        }
        other => panic!("expected Finding::Stash; got {:?}", other),
    }
}

#[test]
fn no_stashes_returns_empty() {
    let tr = TempRepo::new("stashes-none");

    let repo = Repo::open(tr.path()).expect("open repo");
    let findings = StashScanner.scan(&repo);

    assert!(
        findings.is_empty(),
        "repo with no stashes should yield no findings; got {:?}",
        findings
    );
}

#[test]
fn multiple_stashes_all_found_with_distinct_shas() {
    let tr = TempRepo::new("stashes-many");

    tr.stash("a.txt", "alpha\n", "WIP alpha work");
    tr.stash("b.txt", "beta line\nbeta line two\n", "WIP beta work");
    tr.stash("c.txt", "gamma\n", "WIP gamma work");

    let repo = Repo::open(tr.path()).expect("open repo");
    let findings = StashScanner.scan(&repo);

    assert_eq!(findings.len(), 3, "expected 3 stashes; got {:?}", findings);

    let mut shas: Vec<String> = Vec::new();
    for f in &findings {
        match f {
            Finding::Stash { sha, index, .. } => {
                assert!(
                    !sha.is_empty(),
                    "every stash should have a SHA (got {} with empty sha)",
                    index
                );
                shas.push(sha.clone());
            }
            other => panic!("expected Finding::Stash, got {:?}", other),
        }
    }
    // All distinct.
    shas.sort();
    shas.dedup();
    assert_eq!(shas.len(), 3, "stashes should have distinct SHAs");
}