use git_object::bstr::{BStr, BString};use git_revision::{    spec,    spec::parse::{delegate, Delegate},}; #[derive(Default, Debug, Eq, PartialEq, Ord, PartialOrd)]struct Options {    reject_kind: bool,    reject_prefix: bool,} #[derive(Default, Debug, Eq, PartialEq, Ord, PartialOrd)]struct Recorder {    // anchors    find_ref: [Option<BString>; 2],    prefix: [Option<git_hash::Prefix>; 2],    current_branch_reflog_entry: [Option<String>; 2],    nth_checked_out_branch: [Option<usize>; 2],    sibling_branch: [Option<String>; 2],    index_lookups: Vec<(BString, u8)>,     // navigation    traversal: Vec<delegate::Traversal>,    peel_to: Vec<PeelToOwned>,    patterns: Vec<(BString, bool)>,     // range    kind: Option<spec::Kind>,     calls: usize,    opts: Options,    done: bool,} #[derive(Debug, Eq, PartialEq, Ord, PartialOrd)]pub enum PeelToOwned {    ObjectKind(git_object::Kind),    ExistingObject,    RecursiveTagObject,    Path(BString),} impl Recorder {    fn with(options: Options) -> Self {        Recorder {            opts: options,            ..Default::default()        }    }     fn get_ref(&self, idx: usize) -> &BStr {        self.find_ref[idx].as_ref().map(|b| b.as_ref()).unwrap()    }} fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T) -> Option<()> {    for entry in store.iter_mut() {        if entry.is_none() {            *entry = Some(val);            return Some(());        }    }    panic!("called {}() more than twice with '{:?}'", fn_name, val);} impl delegate::Revision for Recorder {    fn find_ref(&mut self, input: &BStr) -> Option<()> {        self.calls += 1;        set_val("find_ref", &mut self.find_ref, input.into())    }     fn disambiguate_prefix(&mut self, input: git_hash::Prefix) -> Option<()> {        self.calls += 1;        if self.opts.reject_prefix {            return None;        }        set_val("disambiguate_prefix", &mut self.prefix, input)    }     fn reflog(&mut self, entry: delegate::ReflogLookup) -> Option<()> {        self.calls += 1;        set_val(            "current_branch_reflog",            &mut self.current_branch_reflog_entry,            match entry {                delegate::ReflogLookup::Entry(no) => no.to_string(),                delegate::ReflogLookup::Date(time) => {                    let mut buf = Vec::new();                    time.write_to(&mut buf).unwrap();                    BString::from(buf).to_string()                }            },        )    }     fn nth_checked_out_branch(&mut self, branch: usize) -> Option<()> {        assert_ne!(branch, 0);        self.calls += 1;        set_val("nth_checked_out_branch", &mut self.nth_checked_out_branch, branch)    }     fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Option<()> {        self.calls += 1;        set_val("sibling_branch", &mut self.sibling_branch, format!("{:?}", kind))    }} impl delegate::Navigate for Recorder {    fn traverse(&mut self, kind: delegate::Traversal) -> Option<()> {        self.calls += 1;        self.traversal.push(kind);        Some(())    }     fn peel_until(&mut self, kind: delegate::PeelTo) -> Option<()> {        self.calls += 1;        self.peel_to.push(match kind {            delegate::PeelTo::ObjectKind(kind) => PeelToOwned::ObjectKind(kind),            delegate::PeelTo::ExistingObject => PeelToOwned::ExistingObject,            delegate::PeelTo::Path(path) => PeelToOwned::Path(path.into()),            delegate::PeelTo::RecursiveTagObject => PeelToOwned::RecursiveTagObject,        });        Some(())    }     fn find(&mut self, regex: &BStr, negated: bool) -> Option<()> {        self.calls += 1;        self.patterns.push((regex.into(), negated));        Some(())    }     fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {        self.calls += 1;        self.index_lookups.push((path.into(), stage));        Some(())    }} impl delegate::Kind for Recorder {    fn kind(&mut self, kind: spec::Kind) -> Option<()> {        self.calls += 1;        if self.opts.reject_kind {            return None;        }        if self.kind.is_none() {            self.kind = Some(kind);        } else {            panic!("called kind more than once with '{:?}'", kind);        }        Some(())    }} impl Delegate for Recorder {    fn done(&mut self) {        self.done = true;    }} fn parse(spec: &str) -> Recorder {    try_parse_opts(spec, Options::default()).unwrap()} fn try_parse(spec: &str) -> Result<Recorder, spec::parse::Error> {    try_parse_opts(spec, Default::default())} fn try_parse_opts(spec: &str, options: Options) -> Result<Recorder, spec::parse::Error> {    let mut rec = Recorder::with(options);    spec::parse(spec.into(), &mut rec)?;    Ok(rec)} #[test]fn empty_specs_are_valid() {    // they should of course be invalid for the delegate. CLIs may pre-process the input as well if they wish    // but git itself doesn't do that.    for spec in [" ", "\n\t"] {        let rec = parse(spec);        assert_eq!(rec.calls, 1);    }    let rec = parse("");    assert_eq!(rec.calls, 0, "but we do not bother to call the delegate with nothing");    assert!(rec.done);} #[test]fn all_characters_are_taken_verbatim_which_includes_whitespace() {    let spec = "  HEAD \n";    let rec = parse(spec);    assert!(rec.kind.is_none());    assert_eq!(rec.get_ref(0), spec);} mod anchor;mod kind;mod navigate;