#![allow(missing_docs)] use git_hash::ObjectId;use git_ref::FullNameRef; use crate::{easy, easy::Head, ext::ReferenceExt}; pub enum Kind {    /// The existing reference the symbolic HEAD points to.    Symbolic(git_ref::Reference),    /// The not-yet-existing reference the symbolic HEAD refers to.    Unborn(git_ref::FullName),    Detached {        target: ObjectId,        peeled: Option<ObjectId>,    },} impl Kind {    pub fn attach<A>(self, access: &A) -> Head<'_, A> {        Head { kind: self, access }    }} impl<'repo, A> Head<'repo, A> {    pub fn name(&self) -> Option<FullNameRef<'_>> {        Some(match &self.kind {            Kind::Symbolic(r) => r.name.to_ref(),            Kind::Unborn(name) => name.to_ref(),            Kind::Detached { .. } => return None,        })    }    pub fn is_detached(&self) -> bool {        matches!(self.kind, Kind::Detached { .. })    }} impl<'repo, A> Head<'repo, A>where    A: easy::Access + Sized,{    pub fn into_referent(self) -> easy::Reference<'repo, A> {        match self.kind {            Kind::Symbolic(r) => r.attach(self.access),            _ => panic!("BUG: Expected head to be a born symbolic reference"),        }    }} pub mod log {    use std::marker::PhantomData;     use crate::{        easy,        easy::{ext::ReferenceAccessExt, Head},    };     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        BorrowState(#[from] easy::borrow::state::Error),        #[error(transparent)]        FindExistingReference(#[from] easy::reference::find::existing::Error),    }     impl<'repo, A> Head<'repo, A>    where        A: easy::Access + Sized,    {        pub fn log(&self) -> Result<easy::reference::log::State<'repo, A, easy::Reference<'repo, A>>, Error> {            Ok(easy::reference::log::State {                reference: self.access.find_reference("HEAD")?,                buf: self.access.state().try_borrow_mut_buf()?,                _phantom: PhantomData::default(),            })        }    }} pub mod peel {    use crate::{        easy,        easy::{head::Kind, Access, Head},        ext::{ObjectIdExt, ReferenceExt},    };     mod error {        use crate::easy::{object, reference};        #[derive(Debug, thiserror::Error)]        pub enum Error {            #[error(transparent)]            FindExistingObject(#[from] object::find::existing::Error),            #[error(transparent)]            PeelReference(#[from] reference::peel::Error),        }    }    pub use error::Error;     impl<'repo, A> Head<'repo, A>    where        A: Access + Sized,    {        // TODO: tests        pub fn peel_to_id_in_place(&mut self) -> Option<Result<easy::Oid<'repo, A>, Error>> {            Some(match &mut self.kind {                Kind::Unborn(_name) => return None,                Kind::Detached {                    peeled: Some(peeled), ..                } => Ok((*peeled).attach(self.access)),                Kind::Detached { peeled: None, target } => {                    match target                        .attach(self.access)                        .object()                        .map_err(Into::into)                        .and_then(|obj| obj.peel_to_end().map_err(Into::into))                        .map(|peeled| peeled.id)                    {                        Ok(peeled) => {                            self.kind = Kind::Detached {                                peeled: Some(peeled),                                target: *target,                            };                            Ok(peeled.attach(self.access))                        }                        Err(err) => Err(err),                    }                }                Kind::Symbolic(r) => {                    let mut nr = r.clone().attach(self.access);                    let peeled = nr.peel_to_id_in_place().map_err(Into::into);                    *r = nr.detach();                    peeled                }            })        }         pub fn into_fully_peeled_id(self) -> Option<Result<easy::Oid<'repo, A>, Error>> {            Some(match self.kind {                Kind::Unborn(_name) => return None,                Kind::Detached {                    peeled: Some(peeled), ..                } => Ok(peeled.attach(self.access)),                Kind::Detached { peeled: None, target } => target                    .attach(self.access)                    .object()                    .map_err(Into::into)                    .and_then(|obj| obj.peel_to_end().map_err(Into::into))                    .map(|obj| obj.id.attach(self.access)),                Kind::Symbolic(r) => r.attach(self.access).peel_to_id_in_place().map_err(Into::into),            })        }    }}