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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
use std::convert::TryInto;
use bstr::BString;
use gix_hash::ObjectId;
use crate::{
entry,
extension::{Signature, UntrackedCache},
util::{read_u32, split_at_byte_exclusive, split_at_pos, var_int},
};
/// A structure to track filesystem stat information along with an object id, linking a worktree file with what's in our ODB.
#[derive(Clone)]
pub struct OidStat {
/// The file system stat information
pub stat: entry::Stat,
/// The id of the file in our ODB.
pub id: ObjectId,
}
/// A directory with information about its untracked files, and its sub-directories
#[derive(Clone)]
pub struct Directory {
/// The directories name, or an empty string if this is the root directory.
pub name: BString,
/// Untracked files and directory names
pub untracked_entries: Vec<BString>,
/// indices for sub-directories similar to this one.
pub sub_directories: Vec<usize>,
/// The directories stat data, if available or valid // TODO: or is it the exclude file?
pub stat: Option<entry::Stat>,
/// The oid of a .gitignore file, if it exists
pub exclude_file_oid: Option<ObjectId>,
/// TODO: figure out what this really does
pub check_only: bool,
}
/// Only used as an indicator
pub const SIGNATURE: Signature = *b"UNTR";
// #[allow(unused)]
/// Decode an untracked cache extension from `data`, assuming object hashes are of type `object_hash`.
pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<UntrackedCache> {
if !data.last().map(|b| *b == 0).unwrap_or(false) {
return None;
}
let (identifier_len, data) = var_int(data)?;
let (identifier, data) = split_at_pos(data, identifier_len.try_into().ok()?)?;
let hash_len = object_hash.len_in_bytes();
let (info_exclude, data) = decode_oid_stat(data, hash_len)?;
let (excludes_file, data) = decode_oid_stat(data, hash_len)?;
let (dir_flags, data) = read_u32(data)?;
let (exclude_filename_per_dir, data) = split_at_byte_exclusive(data, 0)?;
let (num_directory_blocks, data) = var_int(data)?;
let mut res = UntrackedCache {
identifier: identifier.into(),
info_exclude: (!info_exclude.id.is_null()).then_some(info_exclude),
excludes_file: (!excludes_file.id.is_null()).then_some(excludes_file),
exclude_filename_per_dir: exclude_filename_per_dir.into(),
dir_flags,
directories: Vec::new(),
};
if num_directory_blocks == 0 {
return data.is_empty().then_some(res);
}
let num_directory_blocks = num_directory_blocks.try_into().ok()?;
let directories = &mut res.directories;
directories.reserve(num_directory_blocks);
let data = decode_directory_block(data, directories)?;
if directories.len() != num_directory_blocks {
return None;
}
let (valid, data) = gix_bitmap::ewah::decode(data).ok()?;
let (check_only, data) = gix_bitmap::ewah::decode(data).ok()?;
let (hash_valid, mut data) = gix_bitmap::ewah::decode(data).ok()?;
if valid.num_bits() > num_directory_blocks
|| check_only.num_bits() > num_directory_blocks
|| hash_valid.num_bits() > num_directory_blocks
{
return None;
}
check_only.for_each_set_bit(|index| {
directories[index].check_only = true;
Some(())
})?;
valid.for_each_set_bit(|index| {
let (stat, rest) = crate::decode::stat(data)?;
directories[index].stat = stat.into();
data = rest;
Some(())
});
hash_valid.for_each_set_bit(|index| {
let (hash, rest) = split_at_pos(data, hash_len)?;
data = rest;
directories[index].exclude_file_oid = ObjectId::from(hash).into();
Some(())
});
// null-byte checked in the beginning
if data.len() != 1 {
return None;
}
res.into()
}
fn decode_directory_block<'a>(data: &'a [u8], directories: &mut Vec<Directory>) -> Option<&'a [u8]> {
let (num_untracked, data) = var_int(data)?;
let (num_dirs, data) = var_int(data)?;
let (name, mut data) = split_at_byte_exclusive(data, 0)?;
let mut untracked_entries = Vec::<BString>::with_capacity(num_untracked.try_into().ok()?);
for _ in 0..num_untracked {
let (name, rest) = split_at_byte_exclusive(data, 0)?;
data = rest;
untracked_entries.push(name.into());
}
let index = directories.len();
directories.push(Directory {
name: name.into(),
untracked_entries,
sub_directories: Vec::with_capacity(num_dirs.try_into().ok()?),
// the following are set later through their bitmaps
stat: None,
exclude_file_oid: None,
check_only: false,
});
for _ in 0..num_dirs {
let subdir_index = directories.len();
let rest = decode_directory_block(data, directories)?;
data = rest;
directories[index].sub_directories.push(subdir_index);
}
data.into()
}
fn decode_oid_stat(data: &[u8], hash_len: usize) -> Option<(OidStat, &[u8])> {
let (stat, data) = crate::decode::stat(data)?;
let (hash, data) = split_at_pos(data, hash_len)?;
Some((
OidStat {
stat,
id: ObjectId::from(hash),
},
data,
))
}
|
