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
use bstr::{BStr, ByteSlice};
use crate::{Commit, CommitRef, TagRef};
mod decode;
pub mod message;
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
pub struct MessageRef<'a> {
#[cfg_attr(feature = "serde1", serde(borrow))]
pub title: &'a BStr,
pub body: Option<&'a BStr>,
}
pub mod ref_iter;
mod write;
impl<'a> CommitRef<'a> {
pub fn from_bytes(data: &'a [u8]) -> Result<CommitRef<'a>, crate::decode::Error> {
decode::commit(data).map(|(_, t)| t).map_err(crate::decode::Error::from)
}
pub fn tree(&self) -> git_hash::ObjectId {
git_hash::ObjectId::from_hex(self.tree).expect("prior validation of tree hash during parsing")
}
pub fn parents(&self) -> impl Iterator<Item = git_hash::ObjectId> + '_ {
self.parents
.iter()
.map(|hex_hash| git_hash::ObjectId::from_hex(hex_hash).expect("prior validation of hashes during parsing"))
}
pub fn extra_headers(&self) -> crate::commit::ExtraHeaders<impl Iterator<Item = (&BStr, &BStr)>> {
crate::commit::ExtraHeaders::new(self.extra_headers.iter().map(|(k, v)| (*k, v.as_ref())))
}
pub fn message(&self) -> MessageRef<'a> {
MessageRef::from_bytes(self.message)
}
}
impl Commit {
pub fn extra_headers(&self) -> ExtraHeaders<impl Iterator<Item = (&BStr, &BStr)>> {
ExtraHeaders::new(self.extra_headers.iter().map(|(k, v)| (k.as_bstr(), v.as_bstr())))
}
}
pub struct ExtraHeaders<I> {
inner: I,
}
impl<'a, I> ExtraHeaders<I>
where
I: Iterator<Item = (&'a BStr, &'a BStr)>,
{
pub fn new(iter: I) -> Self {
ExtraHeaders { inner: iter }
}
pub fn find(mut self, name: &str) -> Option<&'a BStr> {
self.inner
.find_map(move |(k, v)| if k == name.as_bytes().as_bstr() { Some(v) } else { None })
}
pub fn find_all(self, name: &'a str) -> impl Iterator<Item = &'a BStr> {
self.inner
.filter_map(move |(k, v)| if k == name.as_bytes().as_bstr() { Some(v) } else { None })
}
pub fn mergetags(self) -> impl Iterator<Item = Result<TagRef<'a>, crate::decode::Error>> {
self.find_all("mergetag").map(|b| TagRef::from_bytes(b))
}
pub fn pgp_signature(self) -> Option<&'a BStr> {
self.find("gpgsig")
}
}