git-ref 0.24.1

Please use `gix-<thiscrate>` instead ('git' -> 'gix')
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
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

type Result = std::result::Result<(), Box<dyn std::error::Error>>;

mod reference {
    use nom::error::VerboseError;

    use super::Result;
    use crate::{
        store_impl::{packed, packed::decode},
        FullNameRef,
    };

    /// Convert a hexadecimal hash into its corresponding `ObjectId` or _panic_.
    fn hex_to_id(hex: &str) -> git_hash::ObjectId {
        git_hash::ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")
    }

    #[test]
    fn invalid() {
        assert!(decode::reference::<()>(b"# what looks like a comment",).is_err());
        assert!(
            decode::reference::<()>(b"^e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37\n",).is_err(),
            "lonely peel"
        );
    }

    #[test]
    fn two_refs_in_a_row() -> Result {
        let input: &[u8] = b"d53c4b0f91f1b29769c9430f2d1c0bcab1170c75 refs/heads/alternates-after-packs-and-loose
^e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37\neaae9c1bc723209d793eb93f5587fa2604d5cd92 refs/heads/avoid-double-lookup\n";
        let (input, parsed) = decode::reference::<VerboseError<_>>(input)?;

        assert_eq!(
            parsed,
            packed::Reference {
                name: FullNameRef::new_unchecked("refs/heads/alternates-after-packs-and-loose".into()),
                target: "d53c4b0f91f1b29769c9430f2d1c0bcab1170c75".into(),
                object: Some("e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37".into())
            }
        );
        assert_eq!(parsed.target(), hex_to_id("d53c4b0f91f1b29769c9430f2d1c0bcab1170c75"));
        assert_eq!(parsed.object(), hex_to_id("e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37"));

        let (input, parsed) = decode::reference::<VerboseError<_>>(input)?;
        assert!(input.is_empty(), "exhausted");
        assert_eq!(
            parsed.name,
            FullNameRef::new_unchecked("refs/heads/avoid-double-lookup".into())
        );
        assert_eq!(parsed.target, "eaae9c1bc723209d793eb93f5587fa2604d5cd92");
        assert!(parsed.object.is_none());
        Ok(())
    }
}

mod header {
    use git_object::bstr::ByteSlice;
    use git_testtools::to_bstr_err;

    use super::Result;
    use crate::store_impl::packed::{
        decode,
        decode::{Header, Peeled},
    };

    #[test]
    fn invalid() {
        assert!(
            decode::header::<()>(b"# some user comment").is_err(),
            "something the user put there"
        );
        assert!(decode::header::<()>(b"# pack-refs: ").is_err(), "looks right but isn't");
        assert!(
            decode::header::<()>(b" # pack-refs with: ").is_err(),
            "does not start with #"
        );
    }

    #[test]
    fn valid_fully_peeled_stored() -> Result {
        let input: &[u8] = b"# pack-refs with: peeled fully-peeled sorted  \nsomething else";
        let (rest, header) = decode::header::<nom::error::VerboseError<_>>(input).map_err(to_bstr_err)?;

        assert_eq!(rest.as_bstr(), "something else", "remainder starts after newline");
        assert_eq!(
            header,
            Header {
                peeled: Peeled::Fully,
                sorted: true
            }
        );
        Ok(())
    }

    #[test]
    fn valid_peeled_unsorted() -> Result {
        let input: &[u8] = b"# pack-refs with: peeled\n";
        let (rest, header) = decode::header::<()>(input)?;

        assert!(rest.is_empty());
        assert_eq!(
            header,
            Header {
                peeled: Peeled::Partial,
                sorted: false
            }
        );
        Ok(())
    }

    #[test]
    fn valid_empty() -> Result {
        let input: &[u8] = b"# pack-refs with: \n";
        let (rest, header) = decode::header::<()>(input)?;

        assert!(rest.is_empty());
        assert_eq!(
            header,
            Header {
                peeled: Peeled::Unspecified,
                sorted: false
            }
        );
        Ok(())
    }
}