use super::{Delegate, ObjectKindHint, error};use crate::{ Repository, ext::{ObjectIdExt, ReferenceExt},};use gix_error::{ErrorExt, Exn, ResultExt, message};use gix_hash::ObjectId;use gix_revision::spec::{parse, parse::delegate};use smallvec::SmallVec; type Replacements = SmallVec<[(ObjectId, ObjectId); 1]>; impl<'repo> Delegate<'repo> { pub fn new(repo: &'repo Repository, opts: crate::revision::spec::parse::Options) -> Self { Delegate { refs: Default::default(), objs: Default::default(), paths: Default::default(), ambiguous_objects: Default::default(), idx: 0, kind: None, delayed_errors: Vec::new(), prefix: Default::default(), last_call_was_disambiguate_prefix: Default::default(), opts, repo, } } pub fn into_delayed_errors(mut self) -> Option<Exn> { let repo = self.repo; let mut delayed_errors = self.delayed_errors; let mut ambiguous_errors: Vec<_> = self .ambiguous_objects .iter_mut() .zip(self.prefix) .filter_map(|(a, b)| a.take().filter(|candidates| candidates.len() > 1).zip(b)) .map(|(candidates, prefix)| error::ambiguous(candidates, prefix, repo)) .rev() .map(|err| err.raise_erased()) .collect(); match (ambiguous_errors.pop(), ambiguous_errors.pop()) { (Some(one), None) => Some(one), (Some(one), Some(two)) => Some(Exn::raise_all([one, two], message("Both objects were ambiguous")).erased()), _ => (!delayed_errors.is_empty()).then(|| { if delayed_errors.len() == 1 { delayed_errors.pop().expect("it's exactly one") } else { Exn::raise_all(delayed_errors, message("one or more delayed errors")).erased() } }), } } pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>, gix_error::Error> { fn zero_or_one_objects_or_ambiguity_err( mut candidates: [Option<Vec<ObjectId>>; 2], prefix: [Option<gix_hash::Prefix>; 2], repo: &Repository, ) -> Result<[Option<ObjectId>; 2], gix_error::Error> { let mut out = [None, None]; for ((candidates, prefix), out) in candidates.iter_mut().zip(prefix).zip(out.iter_mut()) { let candidates = candidates.take(); match candidates { None => *out = None, Some(candidates) => match candidates.len() { 0 => { unreachable!("BUG: let's avoid still being around if no candidate matched the requirements") } 1 => { *out = candidates.into_iter().next(); } _ => { let err = error::ambiguous(candidates, prefix.expect("set when obtaining candidates"), repo) .raise_erased(); return Err(err.into_error()); } }, } } Ok(out) } fn kind_to_spec( kind: Option<gix_revision::spec::Kind>, [first, second]: [Option<ObjectId>; 2], ) -> Result<gix_revision::Spec, gix_error::Error> { pub fn malformed() -> gix_error::Error { message!("The rev-spec is malformed and misses a ref name") .raise() .into_error() } use gix_revision::spec::Kind::*; Ok(match kind.unwrap_or_default() { IncludeReachable => gix_revision::Spec::Include(first.ok_or_else(malformed)?), ExcludeReachable => gix_revision::Spec::Exclude(first.ok_or_else(malformed)?), RangeBetween => gix_revision::Spec::Range { from: first.ok_or_else(malformed)?, to: second.ok_or_else(malformed)?, }, ReachableToMergeBase => gix_revision::Spec::Merge { theirs: first.ok_or_else(malformed)?, ours: second.ok_or_else(malformed)?, }, IncludeReachableFromParents => gix_revision::Spec::IncludeOnlyParents(first.ok_or_else(malformed)?), ExcludeReachableFromParents => gix_revision::Spec::ExcludeParents(first.ok_or_else(malformed)?), }) } let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.repo)?; Ok(crate::revision::Spec { path: self.paths[0].take().or(self.paths[1].take()), first_ref: self.refs[0].take(), second_ref: self.refs[1].take(), inner: kind_to_spec(self.kind, range)?, repo: self.repo, }) }} impl parse::Delegate for Delegate<'_> { fn done(&mut self) -> Result<(), Exn> { self.follow_refs_to_objects_if_needed_delay_errors(); self.disambiguate_objects_by_fallback_hint_delay_errors( self.kind_implies_committish() .then_some(ObjectKindHint::Committish) .or(self.opts.object_kind_hint), ); // Never fail, let it be handled by the spec conversion. Ok(()) }} impl delegate::Kind for Delegate<'_> { fn kind(&mut self, kind: gix_revision::spec::Kind) -> Result<(), Exn> { use gix_revision::spec::Kind::*; self.kind = Some(kind); if self.kind_implies_committish() { self.disambiguate_objects_by_fallback_hint_delay_errors(ObjectKindHint::Committish.into()); } if matches!(kind, RangeBetween | ReachableToMergeBase) { self.idx += 1; } Ok(()) }} impl Delegate<'_> { fn has_delayed_err(&self) -> bool { !self.delayed_errors.is_empty() } fn kind_implies_committish(&self) -> bool { self.kind.unwrap_or(gix_revision::spec::Kind::IncludeReachable) != gix_revision::spec::Kind::IncludeReachable } fn disambiguate_objects_by_fallback_hint_delay_errors(&mut self, hint: Option<ObjectKindHint>) { fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<(), Exn> { let obj = repo.find_object(obj).or_erased()?; if obj.kind == kind { Ok(()) } else { Err(message!( "Object {oid} was a {actual}, but needed it to be a {kind}", actual = obj.kind, oid = obj.id.attach(repo).shorten_or_id(), ) .raise_erased()) } } if self.last_call_was_disambiguate_prefix[self.idx] { self.unset_disambiguate_call(); if let Some(objs) = self.objs[self.idx].as_mut() { let repo = self.repo; let errors: Vec<_> = match hint { Some(kind_hint) => match kind_hint { ObjectKindHint::Treeish | ObjectKindHint::Committish => { let kind = match kind_hint { ObjectKindHint::Treeish => gix_object::Kind::Tree, ObjectKindHint::Committish => gix_object::Kind::Commit, _ => unreachable!("BUG: we narrow possibilities above"), }; objs.iter() .filter_map(|obj| peel(repo, obj, kind).err().map(|err| (*obj, err))) .collect() } ObjectKindHint::Tree | ObjectKindHint::Commit | ObjectKindHint::Blob => { let kind = match kind_hint { ObjectKindHint::Tree => gix_object::Kind::Tree, ObjectKindHint::Commit => gix_object::Kind::Commit, ObjectKindHint::Blob => gix_object::Kind::Blob, _ => unreachable!("BUG: we narrow possibilities above"), }; objs.iter() .filter_map(|obj| require_object_kind(repo, obj, kind).err().map(|err| (*obj, err))) .collect() } }, None => return, }; let disambiguation_failed = errors.len() == objs.len(); if disambiguation_failed { self.delayed_errors.extend(errors.into_iter().map(|(_, err)| err)); } else { for (ambiguous_obj, err) in errors { if let Some(pos) = objs.iter().position(|obj| obj == &ambiguous_obj) { objs.remove(pos); } self.delayed_errors.push(err); } } } } } fn follow_refs_to_objects_if_needed_delay_errors(&mut self) { let repo = self.repo; for (r, obj) in self.refs.iter().zip(self.objs.iter_mut()) { if let (Some(ref_), obj_opt @ None) = (r, obj) { if let Some(id) = ref_.target.try_id().map(ToOwned::to_owned).or_else(|| { match ref_.clone().attach(repo).peel_to_id() { Err(err) => { self.delayed_errors.push( err.raise() .raise(message!( "Could not peel '{}' to obtain its target", ref_.name.as_bstr() )) .erased(), ); None } Ok(id) => Some(id.detach()), } }) { let objs = obj_opt.get_or_insert_with(Vec::new); if !objs.contains(&id) { objs.push(id); } } } } } fn unset_disambiguate_call(&mut self) { self.last_call_was_disambiguate_prefix[self.idx] = false; }} fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<ObjectId, Exn> { let mut obj = repo.find_object(obj).or_erased()?; obj = obj.peel_to_kind(kind).or_erased()?; debug_assert_eq!(obj.kind, kind, "bug in Object::peel_to_kind() which didn't deliver"); Ok(obj.id)} mod navigate;mod revision;
use super::{Delegate, ObjectKindHint, error};
use crate::{
Repository,
ext::{ObjectIdExt, ReferenceExt},
};
use gix_error::{ErrorExt, Exn, ResultExt, message};
use gix_hash::ObjectId;
use gix_revision::spec::{parse, parse::delegate};
use smallvec::SmallVec;
type Replacements = SmallVec<[(ObjectId, ObjectId); 1]>;
impl<'repo> Delegate<'repo> {
pub fn new(repo: &'repo Repository, opts: crate::revision::spec::parse::Options) -> Self {
Delegate {
refs: Default::default(),
objs: Default::default(),
paths: Default::default(),
ambiguous_objects: Default::default(),
idx: 0,
kind: None,
delayed_errors: Vec::new(),
prefix: Default::default(),
last_call_was_disambiguate_prefix: Default::default(),
opts,
repo,
}
}
pub fn into_delayed_errors(mut self) -> Option<Exn> {
let repo = self.repo;
let mut delayed_errors = self.delayed_errors;
let mut ambiguous_errors: Vec<_> = self
.ambiguous_objects
.iter_mut()
.zip(self.prefix)
.filter_map(|(a, b)| a.take().filter(|candidates| candidates.len() > 1).zip(b))
.map(|(candidates, prefix)| error::ambiguous(candidates, prefix, repo))
.rev()
.map(|err| err.raise_erased())
.collect();
match (ambiguous_errors.pop(), ambiguous_errors.pop()) {
(Some(one), None) => Some(one),
(Some(one), Some(two)) => Some(Exn::raise_all([one, two], message("Both objects were ambiguous")).erased()),
_ => (!delayed_errors.is_empty()).then(|| {
if delayed_errors.len() == 1 {
delayed_errors.pop().expect("it's exactly one")
} else {
Exn::raise_all(delayed_errors, message("one or more delayed errors")).erased()
}
}),
}
}
pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>, gix_error::Error> {
fn zero_or_one_objects_or_ambiguity_err(
mut candidates: [Option<Vec<ObjectId>>; 2],
prefix: [Option<gix_hash::Prefix>; 2],
repo: &Repository,
) -> Result<[Option<ObjectId>; 2], gix_error::Error> {
let mut out = [None, None];
for ((candidates, prefix), out) in candidates.iter_mut().zip(prefix).zip(out.iter_mut()) {
let candidates = candidates.take();
match candidates {
None => *out = None,
Some(candidates) => match candidates.len() {
0 => {
unreachable!("BUG: let's avoid still being around if no candidate matched the requirements")
}
1 => {
*out = candidates.into_iter().next();
}
_ => {
let err =
error::ambiguous(candidates, prefix.expect("set when obtaining candidates"), repo)
.raise_erased();
return Err(err.into_error());
}
},
}
}
Ok(out)
}
fn kind_to_spec(
kind: Option<gix_revision::spec::Kind>,
[first, second]: [Option<ObjectId>; 2],
) -> Result<gix_revision::Spec, gix_error::Error> {
pub fn malformed() -> gix_error::Error {
message!("The rev-spec is malformed and misses a ref name")
.raise()
.into_error()
}
use gix_revision::spec::Kind::*;
Ok(match kind.unwrap_or_default() {
IncludeReachable => gix_revision::Spec::Include(first.ok_or_else(malformed)?),
ExcludeReachable => gix_revision::Spec::Exclude(first.ok_or_else(malformed)?),
RangeBetween => gix_revision::Spec::Range {
from: first.ok_or_else(malformed)?,
to: second.ok_or_else(malformed)?,
},
ReachableToMergeBase => gix_revision::Spec::Merge {
theirs: first.ok_or_else(malformed)?,
ours: second.ok_or_else(malformed)?,
},
IncludeReachableFromParents => gix_revision::Spec::IncludeOnlyParents(first.ok_or_else(malformed)?),
ExcludeReachableFromParents => gix_revision::Spec::ExcludeParents(first.ok_or_else(malformed)?),
})
}
let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.repo)?;
Ok(crate::revision::Spec {
path: self.paths[0].take().or(self.paths[1].take()),
first_ref: self.refs[0].take(),
second_ref: self.refs[1].take(),
inner: kind_to_spec(self.kind, range)?,
repo: self.repo,
})
}
}
impl parse::Delegate for Delegate<'_> {
fn done(&mut self) -> Result<(), Exn> {
self.follow_refs_to_objects_if_needed_delay_errors();
self.disambiguate_objects_by_fallback_hint_delay_errors(
self.kind_implies_committish()
.then_some(ObjectKindHint::Committish)
.or(self.opts.object_kind_hint),
);
// Never fail, let it be handled by the spec conversion.
Ok(())
}
}
impl delegate::Kind for Delegate<'_> {
fn kind(&mut self, kind: gix_revision::spec::Kind) -> Result<(), Exn> {
use gix_revision::spec::Kind::*;
self.kind = Some(kind);
if self.kind_implies_committish() {
self.disambiguate_objects_by_fallback_hint_delay_errors(ObjectKindHint::Committish.into());
}
if matches!(kind, RangeBetween | ReachableToMergeBase) {
self.idx += 1;
}
Ok(())
}
}
impl Delegate<'_> {
fn has_delayed_err(&self) -> bool {
!self.delayed_errors.is_empty()
}
fn kind_implies_committish(&self) -> bool {
self.kind.unwrap_or(gix_revision::spec::Kind::IncludeReachable) != gix_revision::spec::Kind::IncludeReachable
}
fn disambiguate_objects_by_fallback_hint_delay_errors(&mut self, hint: Option<ObjectKindHint>) {
fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<(), Exn> {
let obj = repo.find_object(obj).or_erased()?;
if obj.kind == kind {
Ok(())
} else {
Err(message!(
"Object {oid} was a {actual}, but needed it to be a {kind}",
actual = obj.kind,
oid = obj.id.attach(repo).shorten_or_id(),
)
.raise_erased())
}
}
if self.last_call_was_disambiguate_prefix[self.idx] {
self.unset_disambiguate_call();
if let Some(objs) = self.objs[self.idx].as_mut() {
let repo = self.repo;
let errors: Vec<_> = match hint {
Some(kind_hint) => match kind_hint {
ObjectKindHint::Treeish | ObjectKindHint::Committish => {
let kind = match kind_hint {
ObjectKindHint::Treeish => gix_object::Kind::Tree,
ObjectKindHint::Committish => gix_object::Kind::Commit,
_ => unreachable!("BUG: we narrow possibilities above"),
};
objs.iter()
.filter_map(|obj| peel(repo, obj, kind).err().map(|err| (*obj, err)))
.collect()
}
ObjectKindHint::Tree | ObjectKindHint::Commit | ObjectKindHint::Blob => {
let kind = match kind_hint {
ObjectKindHint::Tree => gix_object::Kind::Tree,
ObjectKindHint::Commit => gix_object::Kind::Commit,
ObjectKindHint::Blob => gix_object::Kind::Blob,
_ => unreachable!("BUG: we narrow possibilities above"),
};
objs.iter()
.filter_map(|obj| require_object_kind(repo, obj, kind).err().map(|err| (*obj, err)))
.collect()
}
},
None => return,
};
let disambiguation_failed = errors.len() == objs.len();
if disambiguation_failed {
self.delayed_errors.extend(errors.into_iter().map(|(_, err)| err));
} else {
for (ambiguous_obj, err) in errors {
if let Some(pos) = objs.iter().position(|obj| obj == &ambiguous_obj) {
objs.remove(pos);
}
self.delayed_errors.push(err);
}
}
}
}
}
fn follow_refs_to_objects_if_needed_delay_errors(&mut self) {
let repo = self.repo;
for (r, obj) in self.refs.iter().zip(self.objs.iter_mut()) {
if let (Some(ref_), obj_opt @ None) = (r, obj) {
if let Some(id) = ref_.target.try_id().map(ToOwned::to_owned).or_else(|| {
match ref_.clone().attach(repo).peel_to_id() {
Err(err) => {
self.delayed_errors.push(
err.raise()
.raise(message!(
"Could not peel '{}' to obtain its target",
ref_.name.as_bstr()
))
.erased(),
);
None
}
Ok(id) => Some(id.detach()),
}
}) {
let objs = obj_opt.get_or_insert_with(Vec::new);
if !objs.contains(&id) {
objs.push(id);
}
}
}
}
}
fn unset_disambiguate_call(&mut self) {
self.last_call_was_disambiguate_prefix[self.idx] = false;
}
}
fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<ObjectId, Exn> {
let mut obj = repo.find_object(obj).or_erased()?;
obj = obj.peel_to_kind(kind).or_erased()?;
debug_assert_eq!(obj.kind, kind, "bug in Object::peel_to_kind() which didn't deliver");
Ok(obj.id)
}
mod navigate;
mod revision;