use bstr::{BStr, ByteSlice}; use crate::parse::parse_signature;use crate::{Commit, CommitRef, TagRef}; /// The well-known field name for signatures on SHA-1 commits.pub const SIGNATURE_FIELD_NAME: &str = "gpgsig";/// The well-known field name for signatures on SHA-256 commits.pub const SIGNATURE_FIELD_NAME_SHA256: &str = "gpgsig-sha256"; /// Return the signature field name Git uses for `hash_kind`.pub fn signature_field_name(hash_kind: gix_hash::Kind) -> &'static str {    #[cfg(feature = "sha256")]    if hash_kind == gix_hash::Kind::Sha256 {        return SIGNATURE_FIELD_NAME_SHA256;    }    let _ = hash_kind;    SIGNATURE_FIELD_NAME} mod decode;///pub mod message; /// A parsed commit message that assumes a title separated from the body by two consecutive newlines.////// Titles can have any amount of whitespace#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]pub struct MessageRef<'a> {    /// The title of the commit, as separated from the body with two consecutive newlines. The newlines are not included.    #[cfg_attr(feature = "serde", serde(borrow))]    pub title: &'a BStr,    /// All bytes not consumed by the title, excluding the separating newlines.    ///    /// The body is `None` if there was now title separation or the body was empty after the separator.    pub body: Option<&'a BStr>,} ///pub mod ref_iter; mod write; /// Lifecycleimpl<'a> CommitRef<'a> {    /// Deserialize a commit from the given `data` bytes while avoiding most allocations, using `object_hash` to know    /// what kind of hash to expect for validation.    pub fn from_bytes(mut data: &'a [u8], object_hash: gix_hash::Kind) -> Result<CommitRef<'a>, crate::decode::Error> {        let input = &mut data;        match decode::commit(input, object_hash) {            Ok(tag) => Ok(tag),            Err(err) => Err(err),        }    }} /// Accessimpl<'a> CommitRef<'a> {    /// Return the `tree` fields hash digest.    pub fn tree(&self) -> gix_hash::ObjectId {        gix_hash::ObjectId::from_hex(self.tree).expect("prior validation of tree hash during parsing")    }     /// Returns an iterator of parent object ids    pub fn parents(&self) -> impl Iterator<Item = gix_hash::ObjectId> + '_ {        self.parents            .iter()            .map(|hex_hash| gix_hash::ObjectId::from_hex(hex_hash).expect("prior validation of hashes during parsing"))    }     /// Returns a convenient iterator over all extra headers.    pub fn extra_headers(&self) -> ExtraHeaders<impl Iterator<Item = (&BStr, &BStr)>> {        ExtraHeaders::new(            self.extra_headers.iter().map(|(k, v)| (*k, v.as_ref())),            self.tree().kind(),        )    }     /// Return the author, with whitespace trimmed.    ///    /// This is different from the `author` field which may contain whitespace.    pub fn author(&self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {        parse_signature(self.author).map(|signature| signature.trim())    }     /// Return the committer, with whitespace trimmed.    ///    /// This is different from the `committer` field which may contain whitespace.    pub fn committer(&self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {        parse_signature(self.committer).map(|signature| signature.trim())    }     /// Returns a partially parsed message from which more information can be derived.    pub fn message(&self) -> MessageRef<'a> {        MessageRef::from_bytes(self.message)    }     /// Returns the time at which this commit was created, or a default time if it could not be parsed.    pub fn time(&self) -> Result<gix_date::Time, crate::decode::Error> {        parse_signature(self.committer).map(|signature| signature.time().unwrap_or_default())    }} /// Conversionimpl CommitRef<'_> {    /// Copy all fields of this instance into a fully owned commit, consuming this instance.    pub fn into_owned(self) -> Result<Commit, crate::decode::Error> {        self.try_into()    }     /// Copy all fields of this instance into a fully owned commit, internally cloning this instance.    pub fn to_owned(self) -> Result<Commit, crate::decode::Error> {        self.try_into()    }} impl Commit {    /// Returns a convenient iterator over all extra headers.    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())),            self.tree.kind(),        )    }} /// An iterator over extra headers in [owned][crate::Commit] and [borrowed][crate::CommitRef] commits.pub struct ExtraHeaders<I> {    inner: I,    hash_kind: gix_hash::Kind,} /// Instantiation and convenience.impl<'a, I> ExtraHeaders<I>where    I: Iterator<Item = (&'a BStr, &'a BStr)>,{    /// Create a new instance from an iterator over tuples of (name, value) pairs.    pub fn new(iter: I, hash_kind: gix_hash::Kind) -> Self {        ExtraHeaders { inner: iter, hash_kind }    }     /// Find the _value_ of the _first_ header with the given `name`.    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 })    }     /// Find the entry index with the given name, or return `None` if unavailable.    pub fn find_pos(self, name: &str) -> Option<usize> {        self.inner            .enumerate()            .find_map(|(pos, (field, _value))| (field == name).then_some(pos))    }     /// Return an iterator over all _values_ of headers with the given `name`.    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 })    }     /// Return an iterator over all git mergetags.    ///    /// A merge tag is a tag object embedded within the respective header field of a commit, making    /// it a child object of sorts.    pub fn mergetags(self) -> impl Iterator<Item = Result<TagRef<'a>, crate::decode::Error>> {        let hash_kind = self.hash_kind;        self.find_all("mergetag").map(move |b| TagRef::from_bytes(b, hash_kind))    }     /// Return the cryptographic signature provided by gpg/pgp verbatim.    pub fn pgp_signature(self) -> Option<&'a BStr> {        let field_name = signature_field_name(self.hash_kind);        self.find(field_name)    }}