use gix_error::message;use gix_hash::ObjectId; use crate::{Repository, bstr, bstr::BString, ext::ObjectIdExt}; /// Additional information about candidates that caused ambiguity.#[derive(Debug)]pub enum CandidateInfo {    /// An error occurred when looking up the object in the database.    FindError {        /// The reported error.        source: crate::object::find::existing::Error,    },    /// The candidate is an object of the given `kind`.    Object {        /// The kind of the object.        kind: gix_object::Kind,    },    /// The candidate is a tag.    Tag {        /// The name of the tag.        name: BString,    },    /// The candidate is a commit.    Commit {        /// The date of the commit.        date: String,        /// The subject line.        title: BString,    },} impl std::fmt::Display for CandidateInfo {    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {        match self {            CandidateInfo::FindError { source } => write!(f, "lookup error: {source}"),            CandidateInfo::Tag { name } => write!(f, "tag {name:?}"),            CandidateInfo::Object { kind } => std::fmt::Display::fmt(kind, f),            CandidateInfo::Commit { date, title } => {                write!(                    f,                    "commit {} {title:?}",                    gix_date::parse_header(date)                        .unwrap_or_default()                        .format_or_unix(gix_date::time::format::SHORT)                )            }        }    }} pub(crate) fn ambiguous(candidates: Vec<ObjectId>, prefix: gix_hash::Prefix, repo: &Repository) -> gix_error::Message {    #[derive(PartialOrd, Ord, Eq, PartialEq, Copy, Clone)]    enum Order {        Tag,        Commit,        Tree,        Blob,        Invalid,    }    let candidates = {        let mut c: Vec<_> = candidates            .into_iter()            .map(|oid| {                let obj = repo.find_object(oid);                let order = match &obj {                    Err(_) => Order::Invalid,                    Ok(obj) => match obj.kind {                        gix_object::Kind::Tag => Order::Tag,                        gix_object::Kind::Commit => Order::Commit,                        gix_object::Kind::Tree => Order::Tree,                        gix_object::Kind::Blob => Order::Blob,                    },                };                (oid, obj, order)            })            .collect();        c.sort_by(|lhs, rhs| lhs.2.cmp(&rhs.2).then_with(|| lhs.0.cmp(&rhs.0)));        c    };    let info: Vec<_> = candidates        .into_iter()        .map(|(oid, find_result, _)| {            let info = match find_result {                Ok(obj) => match obj.kind {                    gix_object::Kind::Tree | gix_object::Kind::Blob => CandidateInfo::Object { kind: obj.kind },                    gix_object::Kind::Tag => {                        let tag = obj.to_tag_ref();                        CandidateInfo::Tag { name: tag.name.into() }                    }                    gix_object::Kind::Commit => {                        use bstr::ByteSlice;                        let commit = obj.to_commit_ref();                        let date = match commit.committer() {                            Ok(signature) => signature.time.trim().to_owned(),                            Err(_) => {                                let committer = commit.committer;                                let manually_parsed_best_effort = committer                                    .rfind_byte(b'>')                                    .map(|pos| committer[pos + 1..].trim().as_bstr().to_string());                                manually_parsed_best_effort.unwrap_or_default()                            }                        };                        CandidateInfo::Commit {                            date,                            title: commit.message().title.trim().into(),                        }                    }                },                Err(err) => CandidateInfo::FindError { source: err },            };            (oid.attach(repo).shorten().unwrap_or_else(|_| oid.into()), info)        })        .collect();    message!(        "Short id {prefix} is ambiguous. Candidates are:\n{info}",        prefix = prefix,        info = info            .iter()            .map(|(oid, info)| format!("\t{oid} {info}"))            .collect::<Vec<_>>()            .join("\n")    )}