1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
use std::cmp::Ordering;
use crate::State;
///
pub mod entries {
use bstr::BString;
/// The error returned by [`State::verify_entries()`][crate::State::verify_entries()].
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error("Entry '{current_path}' (stage = {current_stage}) at index {current_index} should order after prior entry '{previous_path}' (stage = {previous_stage})")]
OutOfOrder {
current_index: usize,
current_path: BString,
current_stage: u8,
previous_path: BString,
previous_stage: u8,
},
}
}
///
pub mod extensions {
use crate::extension;
/// An implementation of a `find` function that never finds or returns any object, a no-op.
pub fn no_find<'a>(_: &gix_hash::oid, _: &'a mut Vec<u8>) -> Option<gix_object::TreeRefIter<'a>> {
None
}
/// The error returned by [`State::verify_extensions()`][crate::State::verify_extensions()].
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error(transparent)]
Tree(#[from] extension::tree::verify::Error),
}
}
impl State {
/// Assure our entries are consistent.
pub fn verify_entries(&self) -> Result<(), entries::Error> {
let mut previous = None::<&crate::Entry>;
for (idx, entry) in self.entries.iter().enumerate() {
if let Some(prev) = previous {
if prev.cmp(entry, self) != Ordering::Less {
return Err(entries::Error::OutOfOrder {
current_index: idx,
current_path: entry.path(self).into(),
current_stage: entry.flags.stage() as u8,
previous_path: prev.path(self).into(),
previous_stage: prev.flags.stage() as u8,
});
}
}
previous = Some(entry);
}
Ok(())
}
/// Note: `find` cannot be `Option<F>` as we can't call it with a closure then due to the indirection through `Some`.
pub fn verify_extensions<F>(&self, use_find: bool, find: F) -> Result<(), extensions::Error>
where
F: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Option<gix_object::TreeRefIter<'a>>,
{
self.tree().map(|t| t.verify(use_find, find)).transpose()?;
// TODO: verify links by running the whole set of tests on the index
// - do that once we load it as well, or maybe that's lazy loaded? Too many questions for now.
Ok(())
}
}
|
