Show More
@@ -0,0 +1,299 b'' | |||
|
1 | use crate::revlog::{Revision, NULL_REVISION}; | |
|
2 | use byteorder::{BigEndian, ByteOrder}; | |
|
3 | ||
|
4 | pub const INDEX_ENTRY_SIZE: usize = 64; | |
|
5 | ||
|
6 | /// A Revlog index | |
|
7 | #[derive(Debug)] | |
|
8 | pub struct Index<'a> { | |
|
9 | bytes: &'a [u8], | |
|
10 | /// Offsets of starts of index blocks. | |
|
11 | /// Only needed when the index is interleaved with data. | |
|
12 | offsets: Option<Vec<usize>>, | |
|
13 | } | |
|
14 | ||
|
15 | impl<'a> Index<'a> { | |
|
16 | /// Create an index from bytes. | |
|
17 | /// Calculate the start of each entry when is_inline is true. | |
|
18 | pub fn new(bytes: &'a [u8], is_inline: bool) -> Self { | |
|
19 | if is_inline { | |
|
20 | let mut offset: usize = 0; | |
|
21 | let mut offsets = Vec::new(); | |
|
22 | ||
|
23 | while (bytes.len() - offset) >= INDEX_ENTRY_SIZE { | |
|
24 | offsets.push(offset); | |
|
25 | let end = offset + INDEX_ENTRY_SIZE; | |
|
26 | let entry = IndexEntry { | |
|
27 | bytes: &bytes[offset..end], | |
|
28 | offset_override: None, | |
|
29 | }; | |
|
30 | ||
|
31 | offset += INDEX_ENTRY_SIZE + entry.compressed_len(); | |
|
32 | } | |
|
33 | ||
|
34 | Self { | |
|
35 | bytes, | |
|
36 | offsets: Some(offsets), | |
|
37 | } | |
|
38 | } else { | |
|
39 | Self { | |
|
40 | bytes, | |
|
41 | offsets: None, | |
|
42 | } | |
|
43 | } | |
|
44 | } | |
|
45 | ||
|
46 | /// Return the index entry corresponding to the given revision if it | |
|
47 | /// exists. | |
|
48 | pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> { | |
|
49 | if rev == NULL_REVISION { | |
|
50 | return None; | |
|
51 | } | |
|
52 | if let Some(offsets) = &self.offsets { | |
|
53 | self.get_entry_inline(rev, offsets) | |
|
54 | } else { | |
|
55 | self.get_entry_separated(rev) | |
|
56 | } | |
|
57 | } | |
|
58 | ||
|
59 | fn get_entry_inline( | |
|
60 | &self, | |
|
61 | rev: Revision, | |
|
62 | offsets: &[usize], | |
|
63 | ) -> Option<IndexEntry> { | |
|
64 | let start = *offsets.get(rev as usize)?; | |
|
65 | let end = start.checked_add(INDEX_ENTRY_SIZE)?; | |
|
66 | let bytes = &self.bytes[start..end]; | |
|
67 | ||
|
68 | // See IndexEntry for an explanation of this override. | |
|
69 | let offset_override = Some(end); | |
|
70 | ||
|
71 | Some(IndexEntry { | |
|
72 | bytes, | |
|
73 | offset_override, | |
|
74 | }) | |
|
75 | } | |
|
76 | ||
|
77 | fn get_entry_separated(&self, rev: Revision) -> Option<IndexEntry> { | |
|
78 | let max_rev = self.bytes.len() / INDEX_ENTRY_SIZE; | |
|
79 | if rev as usize >= max_rev { | |
|
80 | return None; | |
|
81 | } | |
|
82 | let start = rev as usize * INDEX_ENTRY_SIZE; | |
|
83 | let end = start + INDEX_ENTRY_SIZE; | |
|
84 | let bytes = &self.bytes[start..end]; | |
|
85 | ||
|
86 | // See IndexEntry for an explanation of this override. | |
|
87 | let offset_override = match rev { | |
|
88 | 0 => Some(0), | |
|
89 | _ => None, | |
|
90 | }; | |
|
91 | ||
|
92 | Some(IndexEntry { | |
|
93 | bytes, | |
|
94 | offset_override, | |
|
95 | }) | |
|
96 | } | |
|
97 | } | |
|
98 | ||
|
99 | #[derive(Debug)] | |
|
100 | pub struct IndexEntry<'a> { | |
|
101 | bytes: &'a [u8], | |
|
102 | /// Allows to override the offset value of the entry. | |
|
103 | /// | |
|
104 | /// For interleaved index and data, the offset stored in the index | |
|
105 | /// corresponds to the separated data offset. | |
|
106 | /// It has to be overridden with the actual offset in the interleaved | |
|
107 | /// index which is just after the index block. | |
|
108 | /// | |
|
109 | /// For separated index and data, the offset stored in the first index | |
|
110 | /// entry is mixed with the index headers. | |
|
111 | /// It has to be overridden with 0. | |
|
112 | offset_override: Option<usize>, | |
|
113 | } | |
|
114 | ||
|
115 | impl<'a> IndexEntry<'a> { | |
|
116 | /// Return the offset of the data if not overridden by offset_override. | |
|
117 | pub fn offset(&self) -> usize { | |
|
118 | if let Some(offset_override) = self.offset_override { | |
|
119 | offset_override | |
|
120 | } else { | |
|
121 | let mut bytes = [0; 8]; | |
|
122 | bytes[2..8].copy_from_slice(&self.bytes[0..=5]); | |
|
123 | BigEndian::read_u64(&bytes[..]) as usize | |
|
124 | } | |
|
125 | } | |
|
126 | ||
|
127 | /// Return the compressed length of the data. | |
|
128 | pub fn compressed_len(&self) -> usize { | |
|
129 | BigEndian::read_u32(&self.bytes[8..=11]) as usize | |
|
130 | } | |
|
131 | ||
|
132 | /// Return the uncompressed length of the data. | |
|
133 | pub fn uncompressed_len(&self) -> usize { | |
|
134 | BigEndian::read_u32(&self.bytes[12..=15]) as usize | |
|
135 | } | |
|
136 | ||
|
137 | /// Return the revision upon which the data has been derived. | |
|
138 | pub fn base_revision(&self) -> Revision { | |
|
139 | // TODO Maybe return an Option when base_revision == rev? | |
|
140 | // Requires to add rev to IndexEntry | |
|
141 | ||
|
142 | BigEndian::read_i32(&self.bytes[16..]) | |
|
143 | } | |
|
144 | } | |
|
145 | ||
|
146 | #[cfg(test)] | |
|
147 | mod tests { | |
|
148 | use super::*; | |
|
149 | ||
|
150 | #[cfg(test)] | |
|
151 | #[derive(Debug, Copy, Clone)] | |
|
152 | pub struct IndexEntryBuilder { | |
|
153 | is_first: bool, | |
|
154 | is_inline: bool, | |
|
155 | is_general_delta: bool, | |
|
156 | version: u16, | |
|
157 | offset: usize, | |
|
158 | compressed_len: usize, | |
|
159 | uncompressed_len: usize, | |
|
160 | base_revision: Revision, | |
|
161 | } | |
|
162 | ||
|
163 | #[cfg(test)] | |
|
164 | impl IndexEntryBuilder { | |
|
165 | pub fn new() -> Self { | |
|
166 | Self { | |
|
167 | is_first: false, | |
|
168 | is_inline: false, | |
|
169 | is_general_delta: true, | |
|
170 | version: 2, | |
|
171 | offset: 0, | |
|
172 | compressed_len: 0, | |
|
173 | uncompressed_len: 0, | |
|
174 | base_revision: 0, | |
|
175 | } | |
|
176 | } | |
|
177 | ||
|
178 | pub fn is_first(&mut self, value: bool) -> &mut Self { | |
|
179 | self.is_first = value; | |
|
180 | self | |
|
181 | } | |
|
182 | ||
|
183 | pub fn with_inline(&mut self, value: bool) -> &mut Self { | |
|
184 | self.is_inline = value; | |
|
185 | self | |
|
186 | } | |
|
187 | ||
|
188 | pub fn with_general_delta(&mut self, value: bool) -> &mut Self { | |
|
189 | self.is_general_delta = value; | |
|
190 | self | |
|
191 | } | |
|
192 | ||
|
193 | pub fn with_version(&mut self, value: u16) -> &mut Self { | |
|
194 | self.version = value; | |
|
195 | self | |
|
196 | } | |
|
197 | ||
|
198 | pub fn with_offset(&mut self, value: usize) -> &mut Self { | |
|
199 | self.offset = value; | |
|
200 | self | |
|
201 | } | |
|
202 | ||
|
203 | pub fn with_compressed_len(&mut self, value: usize) -> &mut Self { | |
|
204 | self.compressed_len = value; | |
|
205 | self | |
|
206 | } | |
|
207 | ||
|
208 | pub fn with_uncompressed_len(&mut self, value: usize) -> &mut Self { | |
|
209 | self.uncompressed_len = value; | |
|
210 | self | |
|
211 | } | |
|
212 | ||
|
213 | pub fn with_base_revision(&mut self, value: Revision) -> &mut Self { | |
|
214 | self.base_revision = value; | |
|
215 | self | |
|
216 | } | |
|
217 | ||
|
218 | pub fn build(&self) -> Vec<u8> { | |
|
219 | let mut bytes = Vec::with_capacity(INDEX_ENTRY_SIZE); | |
|
220 | if self.is_first { | |
|
221 | bytes.extend(&match (self.is_general_delta, self.is_inline) { | |
|
222 | (false, false) => [0u8, 0], | |
|
223 | (false, true) => [0u8, 1], | |
|
224 | (true, false) => [0u8, 2], | |
|
225 | (true, true) => [0u8, 3], | |
|
226 | }); | |
|
227 | bytes.extend(&self.version.to_be_bytes()); | |
|
228 | // Remaining offset bytes. | |
|
229 | bytes.extend(&[0u8; 2]); | |
|
230 | } else { | |
|
231 | // Offset is only 6 bytes will usize is 8. | |
|
232 | bytes.extend(&self.offset.to_be_bytes()[2..]); | |
|
233 | } | |
|
234 | bytes.extend(&[0u8; 2]); // Revision flags. | |
|
235 | bytes.extend(&self.compressed_len.to_be_bytes()[4..]); | |
|
236 | bytes.extend(&self.uncompressed_len.to_be_bytes()[4..]); | |
|
237 | bytes.extend(&self.base_revision.to_be_bytes()); | |
|
238 | bytes | |
|
239 | } | |
|
240 | } | |
|
241 | ||
|
242 | #[test] | |
|
243 | fn test_offset() { | |
|
244 | let bytes = IndexEntryBuilder::new().with_offset(1).build(); | |
|
245 | let entry = IndexEntry { | |
|
246 | bytes: &bytes, | |
|
247 | offset_override: None, | |
|
248 | }; | |
|
249 | ||
|
250 | assert_eq!(entry.offset(), 1) | |
|
251 | } | |
|
252 | ||
|
253 | #[test] | |
|
254 | fn test_with_overridden_offset() { | |
|
255 | let bytes = IndexEntryBuilder::new().with_offset(1).build(); | |
|
256 | let entry = IndexEntry { | |
|
257 | bytes: &bytes, | |
|
258 | offset_override: Some(2), | |
|
259 | }; | |
|
260 | ||
|
261 | assert_eq!(entry.offset(), 2) | |
|
262 | } | |
|
263 | ||
|
264 | #[test] | |
|
265 | fn test_compressed_len() { | |
|
266 | let bytes = IndexEntryBuilder::new().with_compressed_len(1).build(); | |
|
267 | let entry = IndexEntry { | |
|
268 | bytes: &bytes, | |
|
269 | offset_override: None, | |
|
270 | }; | |
|
271 | ||
|
272 | assert_eq!(entry.compressed_len(), 1) | |
|
273 | } | |
|
274 | ||
|
275 | #[test] | |
|
276 | fn test_uncompressed_len() { | |
|
277 | let bytes = IndexEntryBuilder::new().with_uncompressed_len(1).build(); | |
|
278 | let entry = IndexEntry { | |
|
279 | bytes: &bytes, | |
|
280 | offset_override: None, | |
|
281 | }; | |
|
282 | ||
|
283 | assert_eq!(entry.uncompressed_len(), 1) | |
|
284 | } | |
|
285 | ||
|
286 | #[test] | |
|
287 | fn test_base_revision() { | |
|
288 | let bytes = IndexEntryBuilder::new().with_base_revision(1).build(); | |
|
289 | let entry = IndexEntry { | |
|
290 | bytes: &bytes, | |
|
291 | offset_override: None, | |
|
292 | }; | |
|
293 | ||
|
294 | assert_eq!(entry.base_revision(), 1) | |
|
295 | } | |
|
296 | } | |
|
297 | ||
|
298 | #[cfg(test)] | |
|
299 | pub use tests::IndexEntryBuilder; |
@@ -0,0 +1,367 b'' | |||
|
1 | use byteorder::{BigEndian, ByteOrder}; | |
|
2 | ||
|
3 | /// A chunk of data to insert, delete or replace in a patch | |
|
4 | /// | |
|
5 | /// A chunk is: | |
|
6 | /// - an insertion when `!data.is_empty() && start == end` | |
|
7 | /// - an deletion when `data.is_empty() && start < end` | |
|
8 | /// - a replacement when `!data.is_empty() && start < end` | |
|
9 | /// - not doing anything when `data.is_empty() && start == end` | |
|
10 | #[derive(Debug, Clone)] | |
|
11 | struct PatchFrag<'a> { | |
|
12 | /// The start position of the chunk of data to replace | |
|
13 | start: i32, | |
|
14 | /// The end position of the chunk of data to replace (open end interval) | |
|
15 | end: i32, | |
|
16 | /// The data replacing the chunk | |
|
17 | data: &'a [u8], | |
|
18 | } | |
|
19 | ||
|
20 | impl<'a> PatchFrag<'a> { | |
|
21 | /// Adjusted start of the chunk to replace. | |
|
22 | /// | |
|
23 | /// Offset allow to take into account the growth/shrinkage of data | |
|
24 | /// induced by previously applied chunks. | |
|
25 | fn start_offseted_by(&self, offset: i32) -> i32 { | |
|
26 | self.start + offset | |
|
27 | } | |
|
28 | ||
|
29 | /// Adjusted end of the chunk to replace. | |
|
30 | /// | |
|
31 | /// Offset allow to take into account the growth/shrinkage of data | |
|
32 | /// induced by previously applied chunks. | |
|
33 | fn end_offseted_by(&self, offset: i32) -> i32 { | |
|
34 | self.start_offseted_by(offset) + (self.data.len() as i32) | |
|
35 | } | |
|
36 | ||
|
37 | /// Length of the replaced chunk. | |
|
38 | fn replaced_len(&self) -> i32 { | |
|
39 | self.end - self.start | |
|
40 | } | |
|
41 | ||
|
42 | /// Length difference between the replacing data and the replaced data. | |
|
43 | fn len_diff(&self) -> i32 { | |
|
44 | (self.data.len() as i32) - self.replaced_len() | |
|
45 | } | |
|
46 | } | |
|
47 | ||
|
48 | /// The delta between two revisions data. | |
|
49 | #[derive(Debug, Clone)] | |
|
50 | pub struct PatchList<'a> { | |
|
51 | /// A collection of chunks to apply. | |
|
52 | /// | |
|
53 | /// Those chunks are: | |
|
54 | /// - ordered from the left-most replacement to the right-most replacement | |
|
55 | /// - non-overlapping, meaning that two chucks can not change the same | |
|
56 | /// chunk of the patched data | |
|
57 | frags: Vec<PatchFrag<'a>>, | |
|
58 | } | |
|
59 | ||
|
60 | impl<'a> PatchList<'a> { | |
|
61 | /// Create a `PatchList` from bytes. | |
|
62 | pub fn new(data: &'a [u8]) -> Self { | |
|
63 | let mut frags = vec![]; | |
|
64 | let mut data = data; | |
|
65 | while !data.is_empty() { | |
|
66 | let start = BigEndian::read_i32(&data[0..]); | |
|
67 | let end = BigEndian::read_i32(&data[4..]); | |
|
68 | let len = BigEndian::read_i32(&data[8..]); | |
|
69 | assert!(0 <= start && start <= end && len >= 0); | |
|
70 | frags.push(PatchFrag { | |
|
71 | start, | |
|
72 | end, | |
|
73 | data: &data[12..12 + (len as usize)], | |
|
74 | }); | |
|
75 | data = &data[12 + (len as usize)..]; | |
|
76 | } | |
|
77 | PatchList { frags } | |
|
78 | } | |
|
79 | ||
|
80 | /// Return the final length of data after patching | |
|
81 | /// given its initial length . | |
|
82 | fn size(&self, initial_size: i32) -> i32 { | |
|
83 | self.frags | |
|
84 | .iter() | |
|
85 | .fold(initial_size, |acc, frag| acc + frag.len_diff()) | |
|
86 | } | |
|
87 | ||
|
88 | /// Apply the patch to some data. | |
|
89 | pub fn apply(&self, initial: &[u8]) -> Vec<u8> { | |
|
90 | let mut last: usize = 0; | |
|
91 | let mut vec = | |
|
92 | Vec::with_capacity(self.size(initial.len() as i32) as usize); | |
|
93 | for PatchFrag { start, end, data } in self.frags.iter() { | |
|
94 | vec.extend(&initial[last..(*start as usize)]); | |
|
95 | vec.extend(data.iter()); | |
|
96 | last = *end as usize; | |
|
97 | } | |
|
98 | vec.extend(&initial[last..]); | |
|
99 | vec | |
|
100 | } | |
|
101 | ||
|
102 | /// Combine two patch lists into a single patch list. | |
|
103 | /// | |
|
104 | /// Applying consecutive patches can lead to waste of time and memory | |
|
105 | /// as the changes introduced by one patch can be overridden by the next. | |
|
106 | /// Combining patches optimizes the whole patching sequence. | |
|
107 | fn combine(&mut self, other: &mut Self) -> Self { | |
|
108 | let mut frags = vec![]; | |
|
109 | ||
|
110 | // Keep track of each growth/shrinkage resulting from applying a chunk | |
|
111 | // in order to adjust the start/end of subsequent chunks. | |
|
112 | let mut offset = 0i32; | |
|
113 | ||
|
114 | // Keep track of the chunk of self.chunks to process. | |
|
115 | let mut pos = 0; | |
|
116 | ||
|
117 | // For each chunk of `other`, chunks of `self` are processed | |
|
118 | // until they start after the end of the current chunk. | |
|
119 | for PatchFrag { start, end, data } in other.frags.iter() { | |
|
120 | // Add chunks of `self` that start before this chunk of `other` | |
|
121 | // without overlap. | |
|
122 | while pos < self.frags.len() | |
|
123 | && self.frags[pos].end_offseted_by(offset) <= *start | |
|
124 | { | |
|
125 | let first = self.frags[pos].clone(); | |
|
126 | offset += first.len_diff(); | |
|
127 | frags.push(first); | |
|
128 | pos += 1; | |
|
129 | } | |
|
130 | ||
|
131 | // The current chunk of `self` starts before this chunk of `other` | |
|
132 | // with overlap. | |
|
133 | // The left-most part of data is added as an insertion chunk. | |
|
134 | // The right-most part data is kept in the chunk. | |
|
135 | if pos < self.frags.len() | |
|
136 | && self.frags[pos].start_offseted_by(offset) < *start | |
|
137 | { | |
|
138 | let first = &mut self.frags[pos]; | |
|
139 | ||
|
140 | let (data_left, data_right) = first.data.split_at( | |
|
141 | (*start - first.start_offseted_by(offset)) as usize, | |
|
142 | ); | |
|
143 | let left = PatchFrag { | |
|
144 | start: first.start, | |
|
145 | end: first.start, | |
|
146 | data: data_left, | |
|
147 | }; | |
|
148 | ||
|
149 | first.data = data_right; | |
|
150 | ||
|
151 | offset += left.len_diff(); | |
|
152 | ||
|
153 | frags.push(left); | |
|
154 | ||
|
155 | // There is no index incrementation because the right-most part | |
|
156 | // needs further examination. | |
|
157 | } | |
|
158 | ||
|
159 | // At this point remaining chunks of `self` starts after | |
|
160 | // the current chunk of `other`. | |
|
161 | ||
|
162 | // `start_offset` will be used to adjust the start of the current | |
|
163 | // chunk of `other`. | |
|
164 | // Offset tracking continues with `end_offset` to adjust the end | |
|
165 | // of the current chunk of `other`. | |
|
166 | let mut next_offset = offset; | |
|
167 | ||
|
168 | // Discard the chunks of `self` that are totally overridden | |
|
169 | // by the current chunk of `other` | |
|
170 | while pos < self.frags.len() | |
|
171 | && self.frags[pos].end_offseted_by(next_offset) <= *end | |
|
172 | { | |
|
173 | let first = &self.frags[pos]; | |
|
174 | next_offset += first.len_diff(); | |
|
175 | pos += 1; | |
|
176 | } | |
|
177 | ||
|
178 | // Truncate the left-most part of chunk of `self` that overlaps | |
|
179 | // the current chunk of `other`. | |
|
180 | if pos < self.frags.len() | |
|
181 | && self.frags[pos].start_offseted_by(next_offset) < *end | |
|
182 | { | |
|
183 | let first = &mut self.frags[pos]; | |
|
184 | ||
|
185 | let how_much_to_discard = | |
|
186 | *end - first.start_offseted_by(next_offset); | |
|
187 | ||
|
188 | first.data = &first.data[(how_much_to_discard as usize)..]; | |
|
189 | ||
|
190 | next_offset += how_much_to_discard; | |
|
191 | } | |
|
192 | ||
|
193 | // Add the chunk of `other` with adjusted position. | |
|
194 | frags.push(PatchFrag { | |
|
195 | start: *start - offset, | |
|
196 | end: *end - next_offset, | |
|
197 | data, | |
|
198 | }); | |
|
199 | ||
|
200 | // Go back to normal offset tracking for the next `o` chunk | |
|
201 | offset = next_offset; | |
|
202 | } | |
|
203 | ||
|
204 | // Add remaining chunks of `self`. | |
|
205 | for elt in &self.frags[pos..] { | |
|
206 | frags.push(elt.clone()); | |
|
207 | } | |
|
208 | PatchList { frags } | |
|
209 | } | |
|
210 | } | |
|
211 | ||
|
212 | /// Combine a list of patch list into a single patch optimized patch list. | |
|
213 | pub fn fold_patch_lists<'a>(lists: &[PatchList<'a>]) -> PatchList<'a> { | |
|
214 | if lists.len() <= 1 { | |
|
215 | if lists.is_empty() { | |
|
216 | PatchList { frags: vec![] } | |
|
217 | } else { | |
|
218 | lists[0].clone() | |
|
219 | } | |
|
220 | } else { | |
|
221 | let (left, right) = lists.split_at(lists.len() / 2); | |
|
222 | let mut left_res = fold_patch_lists(left); | |
|
223 | let mut right_res = fold_patch_lists(right); | |
|
224 | left_res.combine(&mut right_res) | |
|
225 | } | |
|
226 | } | |
|
227 | ||
|
228 | #[cfg(test)] | |
|
229 | mod tests { | |
|
230 | use super::*; | |
|
231 | ||
|
232 | struct PatchDataBuilder { | |
|
233 | data: Vec<u8>, | |
|
234 | } | |
|
235 | ||
|
236 | impl PatchDataBuilder { | |
|
237 | pub fn new() -> Self { | |
|
238 | Self { data: vec![] } | |
|
239 | } | |
|
240 | ||
|
241 | pub fn replace( | |
|
242 | &mut self, | |
|
243 | start: usize, | |
|
244 | end: usize, | |
|
245 | data: &[u8], | |
|
246 | ) -> &mut Self { | |
|
247 | assert!(start <= end); | |
|
248 | self.data.extend(&(start as i32).to_be_bytes()); | |
|
249 | self.data.extend(&(end as i32).to_be_bytes()); | |
|
250 | self.data.extend(&(data.len() as i32).to_be_bytes()); | |
|
251 | self.data.extend(data.iter()); | |
|
252 | self | |
|
253 | } | |
|
254 | ||
|
255 | pub fn get(&mut self) -> &[u8] { | |
|
256 | &self.data[..] | |
|
257 | } | |
|
258 | } | |
|
259 | ||
|
260 | #[test] | |
|
261 | fn test_ends_before() { | |
|
262 | let data = vec![0u8, 0u8, 0u8]; | |
|
263 | let mut patch1_data = PatchDataBuilder::new(); | |
|
264 | patch1_data.replace(0, 1, &[1, 2]); | |
|
265 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
266 | ||
|
267 | let mut patch2_data = PatchDataBuilder::new(); | |
|
268 | patch2_data.replace(2, 4, &[3, 4]); | |
|
269 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
270 | ||
|
271 | let patch = patch1.combine(&mut patch2); | |
|
272 | ||
|
273 | let result = patch.apply(&data); | |
|
274 | ||
|
275 | assert_eq!(result, vec![1u8, 2, 3, 4]); | |
|
276 | } | |
|
277 | ||
|
278 | #[test] | |
|
279 | fn test_starts_after() { | |
|
280 | let data = vec![0u8, 0u8, 0u8]; | |
|
281 | let mut patch1_data = PatchDataBuilder::new(); | |
|
282 | patch1_data.replace(2, 3, &[3]); | |
|
283 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
284 | ||
|
285 | let mut patch2_data = PatchDataBuilder::new(); | |
|
286 | patch2_data.replace(1, 2, &[1, 2]); | |
|
287 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
288 | ||
|
289 | let patch = patch1.combine(&mut patch2); | |
|
290 | ||
|
291 | let result = patch.apply(&data); | |
|
292 | ||
|
293 | assert_eq!(result, vec![0u8, 1, 2, 3]); | |
|
294 | } | |
|
295 | ||
|
296 | #[test] | |
|
297 | fn test_overridden() { | |
|
298 | let data = vec![0u8, 0, 0]; | |
|
299 | let mut patch1_data = PatchDataBuilder::new(); | |
|
300 | patch1_data.replace(1, 2, &[3, 4]); | |
|
301 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
302 | ||
|
303 | let mut patch2_data = PatchDataBuilder::new(); | |
|
304 | patch2_data.replace(1, 4, &[1, 2, 3]); | |
|
305 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
306 | ||
|
307 | let patch = patch1.combine(&mut patch2); | |
|
308 | ||
|
309 | let result = patch.apply(&data); | |
|
310 | ||
|
311 | assert_eq!(result, vec![0u8, 1, 2, 3]); | |
|
312 | } | |
|
313 | ||
|
314 | #[test] | |
|
315 | fn test_right_most_part_is_overridden() { | |
|
316 | let data = vec![0u8, 0, 0]; | |
|
317 | let mut patch1_data = PatchDataBuilder::new(); | |
|
318 | patch1_data.replace(0, 1, &[1, 3]); | |
|
319 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
320 | ||
|
321 | let mut patch2_data = PatchDataBuilder::new(); | |
|
322 | patch2_data.replace(1, 4, &[2, 3, 4]); | |
|
323 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
324 | ||
|
325 | let patch = patch1.combine(&mut patch2); | |
|
326 | ||
|
327 | let result = patch.apply(&data); | |
|
328 | ||
|
329 | assert_eq!(result, vec![1u8, 2, 3, 4]); | |
|
330 | } | |
|
331 | ||
|
332 | #[test] | |
|
333 | fn test_left_most_part_is_overridden() { | |
|
334 | let data = vec![0u8, 0, 0]; | |
|
335 | let mut patch1_data = PatchDataBuilder::new(); | |
|
336 | patch1_data.replace(1, 3, &[1, 3, 4]); | |
|
337 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
338 | ||
|
339 | let mut patch2_data = PatchDataBuilder::new(); | |
|
340 | patch2_data.replace(0, 2, &[1, 2]); | |
|
341 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
342 | ||
|
343 | let patch = patch1.combine(&mut patch2); | |
|
344 | ||
|
345 | let result = patch.apply(&data); | |
|
346 | ||
|
347 | assert_eq!(result, vec![1u8, 2, 3, 4]); | |
|
348 | } | |
|
349 | ||
|
350 | #[test] | |
|
351 | fn test_mid_is_overridden() { | |
|
352 | let data = vec![0u8, 0, 0]; | |
|
353 | let mut patch1_data = PatchDataBuilder::new(); | |
|
354 | patch1_data.replace(0, 3, &[1, 3, 3, 4]); | |
|
355 | let mut patch1 = PatchList::new(patch1_data.get()); | |
|
356 | ||
|
357 | let mut patch2_data = PatchDataBuilder::new(); | |
|
358 | patch2_data.replace(1, 3, &[2, 3]); | |
|
359 | let mut patch2 = PatchList::new(patch2_data.get()); | |
|
360 | ||
|
361 | let patch = patch1.combine(&mut patch2); | |
|
362 | ||
|
363 | let result = patch.apply(&data); | |
|
364 | ||
|
365 | assert_eq!(result, vec![1u8, 2, 3, 4]); | |
|
366 | } | |
|
367 | } |
@@ -0,0 +1,353 b'' | |||
|
1 | use std::borrow::Cow; | |
|
2 | use std::fs::File; | |
|
3 | use std::io::Read; | |
|
4 | use std::ops::Deref; | |
|
5 | use std::path::Path; | |
|
6 | ||
|
7 | use byteorder::{BigEndian, ByteOrder}; | |
|
8 | use flate2::read::ZlibDecoder; | |
|
9 | use memmap::{Mmap, MmapOptions}; | |
|
10 | use micro_timer::timed; | |
|
11 | use zstd; | |
|
12 | ||
|
13 | use super::index::Index; | |
|
14 | use super::patch; | |
|
15 | use crate::revlog::Revision; | |
|
16 | ||
|
17 | pub enum RevlogError { | |
|
18 | IoError(std::io::Error), | |
|
19 | UnsuportedVersion(u16), | |
|
20 | InvalidRevision, | |
|
21 | Corrupted, | |
|
22 | UnknowDataFormat(u8), | |
|
23 | } | |
|
24 | ||
|
25 | fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> { | |
|
26 | let file = File::open(path)?; | |
|
27 | let mmap = unsafe { MmapOptions::new().map(&file) }?; | |
|
28 | Ok(mmap) | |
|
29 | } | |
|
30 | ||
|
31 | /// Read only implementation of revlog. | |
|
32 | pub struct Revlog { | |
|
33 | /// When index and data are not interleaved: bytes of the revlog index. | |
|
34 | /// When index and data are interleaved: bytes of the revlog index and | |
|
35 | /// data. | |
|
36 | index_bytes: Box<dyn Deref<Target = [u8]> + Send>, | |
|
37 | /// When index and data are not interleaved: bytes of the revlog data | |
|
38 | data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>, | |
|
39 | } | |
|
40 | ||
|
41 | impl Revlog { | |
|
42 | /// Open a revlog index file. | |
|
43 | /// | |
|
44 | /// It will also open the associated data file if index and data are not | |
|
45 | /// interleaved. | |
|
46 | #[timed] | |
|
47 | pub fn open(index_path: &Path) -> Result<Self, RevlogError> { | |
|
48 | let index_mmap = | |
|
49 | mmap_open(&index_path).map_err(RevlogError::IoError)?; | |
|
50 | ||
|
51 | let version = get_version(&index_mmap); | |
|
52 | if version != 1 { | |
|
53 | return Err(RevlogError::UnsuportedVersion(version)); | |
|
54 | } | |
|
55 | ||
|
56 | let is_inline = is_inline(&index_mmap); | |
|
57 | ||
|
58 | let index_bytes = Box::new(index_mmap); | |
|
59 | ||
|
60 | // TODO load data only when needed // | |
|
61 | // type annotation required | |
|
62 | // won't recognize Mmap as Deref<Target = [u8]> | |
|
63 | let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> = | |
|
64 | if is_inline { | |
|
65 | None | |
|
66 | } else { | |
|
67 | let data_path = index_path.with_extension("d"); | |
|
68 | let data_mmap = | |
|
69 | mmap_open(&data_path).map_err(RevlogError::IoError)?; | |
|
70 | Some(Box::new(data_mmap)) | |
|
71 | }; | |
|
72 | ||
|
73 | Ok(Revlog { | |
|
74 | index_bytes, | |
|
75 | data_bytes, | |
|
76 | }) | |
|
77 | } | |
|
78 | ||
|
79 | /// Return the full data associated to a revision. | |
|
80 | /// | |
|
81 | /// All entries required to build the final data out of deltas will be | |
|
82 | /// retrieved as needed, and the deltas will be applied to the inital | |
|
83 | /// snapshot to rebuild the final data. | |
|
84 | #[timed] | |
|
85 | pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> { | |
|
86 | // Todo return -> Cow | |
|
87 | let mut entry = self.get_entry(rev)?; | |
|
88 | let mut delta_chain = vec![]; | |
|
89 | while let Some(base_rev) = entry.base_rev { | |
|
90 | delta_chain.push(entry); | |
|
91 | entry = self | |
|
92 | .get_entry(base_rev) | |
|
93 | .map_err(|_| RevlogError::Corrupted)?; | |
|
94 | } | |
|
95 | ||
|
96 | if delta_chain.is_empty() { | |
|
97 | Ok(entry.data()?.into()) | |
|
98 | } else { | |
|
99 | Revlog::build_data_from_deltas(entry, &delta_chain) | |
|
100 | } | |
|
101 | } | |
|
102 | ||
|
103 | /// Build the full data of a revision out its snapshot | |
|
104 | /// and its deltas. | |
|
105 | #[timed] | |
|
106 | fn build_data_from_deltas( | |
|
107 | snapshot: RevlogEntry, | |
|
108 | deltas: &[RevlogEntry], | |
|
109 | ) -> Result<Vec<u8>, RevlogError> { | |
|
110 | let snapshot = snapshot.data()?; | |
|
111 | let deltas = deltas | |
|
112 | .iter() | |
|
113 | .rev() | |
|
114 | .map(RevlogEntry::data) | |
|
115 | .collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?; | |
|
116 | let patches: Vec<_> = | |
|
117 | deltas.iter().map(|d| patch::PatchList::new(d)).collect(); | |
|
118 | let patch = patch::fold_patch_lists(&patches); | |
|
119 | Ok(patch.apply(&snapshot)) | |
|
120 | } | |
|
121 | ||
|
122 | /// Return the revlog index. | |
|
123 | fn index(&self) -> Index { | |
|
124 | let is_inline = self.data_bytes.is_none(); | |
|
125 | Index::new(&self.index_bytes, is_inline) | |
|
126 | } | |
|
127 | ||
|
128 | /// Return the revlog data. | |
|
129 | fn data(&self) -> &[u8] { | |
|
130 | match self.data_bytes { | |
|
131 | Some(ref data_bytes) => &data_bytes, | |
|
132 | None => &self.index_bytes, | |
|
133 | } | |
|
134 | } | |
|
135 | ||
|
136 | /// Get an entry of the revlog. | |
|
137 | fn get_entry(&self, rev: Revision) -> Result<RevlogEntry, RevlogError> { | |
|
138 | let index = self.index(); | |
|
139 | let index_entry = | |
|
140 | index.get_entry(rev).ok_or(RevlogError::InvalidRevision)?; | |
|
141 | let start = index_entry.offset(); | |
|
142 | let end = start + index_entry.compressed_len(); | |
|
143 | let entry = RevlogEntry { | |
|
144 | rev, | |
|
145 | bytes: &self.data()[start..end], | |
|
146 | compressed_len: index_entry.compressed_len(), | |
|
147 | uncompressed_len: index_entry.uncompressed_len(), | |
|
148 | base_rev: if index_entry.base_revision() == rev { | |
|
149 | None | |
|
150 | } else { | |
|
151 | Some(index_entry.base_revision()) | |
|
152 | }, | |
|
153 | }; | |
|
154 | Ok(entry) | |
|
155 | } | |
|
156 | } | |
|
157 | ||
|
158 | /// The revlog entry's bytes and the necessary informations to extract | |
|
159 | /// the entry's data. | |
|
160 | #[derive(Debug)] | |
|
161 | pub struct RevlogEntry<'a> { | |
|
162 | rev: Revision, | |
|
163 | bytes: &'a [u8], | |
|
164 | compressed_len: usize, | |
|
165 | uncompressed_len: usize, | |
|
166 | base_rev: Option<Revision>, | |
|
167 | } | |
|
168 | ||
|
169 | impl<'a> RevlogEntry<'a> { | |
|
170 | /// Extract the data contained in the entry. | |
|
171 | pub fn data(&self) -> Result<Cow<'_, [u8]>, RevlogError> { | |
|
172 | if self.bytes.is_empty() { | |
|
173 | return Ok(Cow::Borrowed(&[])); | |
|
174 | } | |
|
175 | match self.bytes[0] { | |
|
176 | // Revision data is the entirety of the entry, including this | |
|
177 | // header. | |
|
178 | b'\0' => Ok(Cow::Borrowed(self.bytes)), | |
|
179 | // Raw revision data follows. | |
|
180 | b'u' => Ok(Cow::Borrowed(&self.bytes[1..])), | |
|
181 | // zlib (RFC 1950) data. | |
|
182 | b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data())), | |
|
183 | // zstd data. | |
|
184 | b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data())), | |
|
185 | format_type => Err(RevlogError::UnknowDataFormat(format_type)), | |
|
186 | } | |
|
187 | } | |
|
188 | ||
|
189 | fn uncompressed_zlib_data(&self) -> Vec<u8> { | |
|
190 | let mut decoder = ZlibDecoder::new(self.bytes); | |
|
191 | if self.is_delta() { | |
|
192 | let mut buf = Vec::with_capacity(self.compressed_len); | |
|
193 | decoder.read_to_end(&mut buf).expect("corrupted zlib data"); | |
|
194 | buf | |
|
195 | } else { | |
|
196 | let mut buf = vec![0; self.uncompressed_len]; | |
|
197 | decoder.read_exact(&mut buf).expect("corrupted zlib data"); | |
|
198 | buf | |
|
199 | } | |
|
200 | } | |
|
201 | ||
|
202 | fn uncompressed_zstd_data(&self) -> Vec<u8> { | |
|
203 | if self.is_delta() { | |
|
204 | let mut buf = Vec::with_capacity(self.compressed_len); | |
|
205 | zstd::stream::copy_decode(self.bytes, &mut buf) | |
|
206 | .expect("corrupted zstd data"); | |
|
207 | buf | |
|
208 | } else { | |
|
209 | let mut buf = vec![0; self.uncompressed_len]; | |
|
210 | let len = zstd::block::decompress_to_buffer(self.bytes, &mut buf) | |
|
211 | .expect("corrupted zstd data"); | |
|
212 | assert_eq!(len, self.uncompressed_len, "corrupted zstd data"); | |
|
213 | buf | |
|
214 | } | |
|
215 | } | |
|
216 | ||
|
217 | /// Tell if the entry is a snapshot or a delta | |
|
218 | /// (influences on decompression). | |
|
219 | fn is_delta(&self) -> bool { | |
|
220 | self.base_rev.is_some() | |
|
221 | } | |
|
222 | } | |
|
223 | ||
|
224 | /// Value of the inline flag. | |
|
225 | pub fn is_inline(index_bytes: &[u8]) -> bool { | |
|
226 | match &index_bytes[0..=1] { | |
|
227 | [0, 0] | [0, 2] => false, | |
|
228 | _ => true, | |
|
229 | } | |
|
230 | } | |
|
231 | ||
|
232 | /// Format version of the revlog. | |
|
233 | pub fn get_version(index_bytes: &[u8]) -> u16 { | |
|
234 | BigEndian::read_u16(&index_bytes[2..=3]) | |
|
235 | } | |
|
236 | ||
|
237 | #[cfg(test)] | |
|
238 | mod tests { | |
|
239 | use super::*; | |
|
240 | ||
|
241 | use super::super::index::IndexEntryBuilder; | |
|
242 | ||
|
243 | #[cfg(test)] | |
|
244 | pub struct RevlogBuilder { | |
|
245 | version: u16, | |
|
246 | is_general_delta: bool, | |
|
247 | is_inline: bool, | |
|
248 | offset: usize, | |
|
249 | index: Vec<Vec<u8>>, | |
|
250 | data: Vec<Vec<u8>>, | |
|
251 | } | |
|
252 | ||
|
253 | #[cfg(test)] | |
|
254 | impl RevlogBuilder { | |
|
255 | pub fn new() -> Self { | |
|
256 | Self { | |
|
257 | version: 2, | |
|
258 | is_inline: false, | |
|
259 | is_general_delta: true, | |
|
260 | offset: 0, | |
|
261 | index: vec![], | |
|
262 | data: vec![], | |
|
263 | } | |
|
264 | } | |
|
265 | ||
|
266 | pub fn with_inline(&mut self, value: bool) -> &mut Self { | |
|
267 | self.is_inline = value; | |
|
268 | self | |
|
269 | } | |
|
270 | ||
|
271 | pub fn with_general_delta(&mut self, value: bool) -> &mut Self { | |
|
272 | self.is_general_delta = value; | |
|
273 | self | |
|
274 | } | |
|
275 | ||
|
276 | pub fn with_version(&mut self, value: u16) -> &mut Self { | |
|
277 | self.version = value; | |
|
278 | self | |
|
279 | } | |
|
280 | ||
|
281 | pub fn push( | |
|
282 | &mut self, | |
|
283 | mut index: IndexEntryBuilder, | |
|
284 | data: Vec<u8>, | |
|
285 | ) -> &mut Self { | |
|
286 | if self.index.is_empty() { | |
|
287 | index.is_first(true); | |
|
288 | index.with_general_delta(self.is_general_delta); | |
|
289 | index.with_inline(self.is_inline); | |
|
290 | index.with_version(self.version); | |
|
291 | } else { | |
|
292 | index.with_offset(self.offset); | |
|
293 | } | |
|
294 | self.index.push(index.build()); | |
|
295 | self.offset += data.len(); | |
|
296 | self.data.push(data); | |
|
297 | self | |
|
298 | } | |
|
299 | ||
|
300 | pub fn build_inline(&self) -> Vec<u8> { | |
|
301 | let mut bytes = | |
|
302 | Vec::with_capacity(self.index.len() + self.data.len()); | |
|
303 | for (index, data) in self.index.iter().zip(self.data.iter()) { | |
|
304 | bytes.extend(index); | |
|
305 | bytes.extend(data); | |
|
306 | } | |
|
307 | bytes | |
|
308 | } | |
|
309 | } | |
|
310 | ||
|
311 | #[test] | |
|
312 | fn is_not_inline_when_no_inline_flag_test() { | |
|
313 | let bytes = RevlogBuilder::new() | |
|
314 | .with_general_delta(false) | |
|
315 | .with_inline(false) | |
|
316 | .push(IndexEntryBuilder::new(), vec![]) | |
|
317 | .build_inline(); | |
|
318 | ||
|
319 | assert_eq!(is_inline(&bytes), false) | |
|
320 | } | |
|
321 | ||
|
322 | #[test] | |
|
323 | fn is_inline_when_inline_flag_test() { | |
|
324 | let bytes = RevlogBuilder::new() | |
|
325 | .with_general_delta(false) | |
|
326 | .with_inline(true) | |
|
327 | .push(IndexEntryBuilder::new(), vec![]) | |
|
328 | .build_inline(); | |
|
329 | ||
|
330 | assert_eq!(is_inline(&bytes), true) | |
|
331 | } | |
|
332 | ||
|
333 | #[test] | |
|
334 | fn is_inline_when_inline_and_generaldelta_flags_test() { | |
|
335 | let bytes = RevlogBuilder::new() | |
|
336 | .with_general_delta(true) | |
|
337 | .with_inline(true) | |
|
338 | .push(IndexEntryBuilder::new(), vec![]) | |
|
339 | .build_inline(); | |
|
340 | ||
|
341 | assert_eq!(is_inline(&bytes), true) | |
|
342 | } | |
|
343 | ||
|
344 | #[test] | |
|
345 | fn version_test() { | |
|
346 | let bytes = RevlogBuilder::new() | |
|
347 | .with_version(1) | |
|
348 | .push(IndexEntryBuilder::new(), vec![]) | |
|
349 | .build_inline(); | |
|
350 | ||
|
351 | assert_eq!(get_version(&bytes), 1) | |
|
352 | } | |
|
353 | } |
@@ -1,8 +1,13 b'' | |||
|
1 | 1 | # This file is automatically @generated by Cargo. |
|
2 | 2 | # It is not intended for manual editing. |
|
3 | 3 | [[package]] |
|
4 | name = "adler" | |
|
5 | version = "0.2.3" | |
|
6 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
7 | ||
|
8 | [[package]] | |
|
4 | 9 | name = "aho-corasick" |
|
5 |
version = "0.7.1 |
|
|
10 | version = "0.7.13" | |
|
6 | 11 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
7 | 12 | dependencies = [ |
|
8 | 13 | "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -13,7 +18,7 b' name = "ansi_term"' | |||
|
13 | 18 | version = "0.11.0" |
|
14 | 19 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
15 | 20 | dependencies = [ |
|
16 |
"winapi 0.3. |
|
|
21 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
17 | 22 | ] |
|
18 | 23 | |
|
19 | 24 | [[package]] |
@@ -21,14 +26,14 b' name = "atty"' | |||
|
21 | 26 | version = "0.2.14" |
|
22 | 27 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
23 | 28 | dependencies = [ |
|
24 |
"hermit-abi 0.1. |
|
|
25 |
"libc 0.2. |
|
|
26 |
"winapi 0.3. |
|
|
29 | "hermit-abi 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
30 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
31 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
27 | 32 | ] |
|
28 | 33 | |
|
29 | 34 | [[package]] |
|
30 | 35 | name = "autocfg" |
|
31 |
version = "1.0. |
|
|
36 | version = "1.0.1" | |
|
32 | 37 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
33 | 38 | |
|
34 | 39 | [[package]] |
@@ -42,13 +47,21 b' version = "1.3.4"' | |||
|
42 | 47 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
43 | 48 | |
|
44 | 49 | [[package]] |
|
50 | name = "cc" | |
|
51 | version = "1.0.60" | |
|
52 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
53 | dependencies = [ | |
|
54 | "jobserver 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
55 | ] | |
|
56 | ||
|
57 | [[package]] | |
|
45 | 58 | name = "cfg-if" |
|
46 | 59 | version = "0.1.10" |
|
47 | 60 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
48 | 61 | |
|
49 | 62 | [[package]] |
|
50 | 63 | name = "clap" |
|
51 |
version = "2.33. |
|
|
64 | version = "2.33.3" | |
|
52 | 65 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
53 | 66 | dependencies = [ |
|
54 | 67 | "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -56,8 +69,8 b' dependencies = [' | |||
|
56 | 69 | "bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
57 | 70 | "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
58 | 71 | "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
59 |
"unicode-width 0.1. |
|
|
60 |
"vec_map 0.8. |
|
|
72 | "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
73 | "vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
61 | 74 | ] |
|
62 | 75 | |
|
63 | 76 | [[package]] |
@@ -65,28 +78,36 b' name = "cpython"' | |||
|
65 | 78 | version = "0.4.1" |
|
66 | 79 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
67 | 80 | dependencies = [ |
|
68 |
"libc 0.2. |
|
|
69 |
"num-traits 0.2.1 |
|
|
81 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
82 | "num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
70 | 83 | "python27-sys 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
71 | 84 | "python3-sys 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
72 | 85 | ] |
|
73 | 86 | |
|
74 | 87 | [[package]] |
|
88 | name = "crc32fast" | |
|
89 | version = "1.2.0" | |
|
90 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
91 | dependencies = [ | |
|
92 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
93 | ] | |
|
94 | ||
|
95 | [[package]] | |
|
75 | 96 | name = "crossbeam" |
|
76 | 97 | version = "0.7.3" |
|
77 | 98 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
78 | 99 | dependencies = [ |
|
79 | 100 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
80 |
"crossbeam-channel 0.4. |
|
|
101 | "crossbeam-channel 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
81 | 102 | "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
82 | 103 | "crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
83 |
"crossbeam-queue 0.2. |
|
|
104 | "crossbeam-queue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
84 | 105 | "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
85 | 106 | ] |
|
86 | 107 | |
|
87 | 108 | [[package]] |
|
88 | 109 | name = "crossbeam-channel" |
|
89 |
version = "0.4. |
|
|
110 | version = "0.4.4" | |
|
90 | 111 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
91 | 112 | dependencies = [ |
|
92 | 113 | "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -108,22 +129,23 b' name = "crossbeam-epoch"' | |||
|
108 | 129 | version = "0.8.2" |
|
109 | 130 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
110 | 131 | dependencies = [ |
|
111 |
"autocfg 1.0. |
|
|
132 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
112 | 133 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
113 | 134 | "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
114 | 135 | "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
115 | 136 | "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
116 |
"memoffset 0.5. |
|
|
137 | "memoffset 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
117 | 138 | "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
118 | 139 | ] |
|
119 | 140 | |
|
120 | 141 | [[package]] |
|
121 | 142 | name = "crossbeam-queue" |
|
122 |
version = "0.2. |
|
|
143 | version = "0.2.3" | |
|
123 | 144 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
124 | 145 | dependencies = [ |
|
125 | 146 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
126 | 147 | "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
148 | "maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
127 | 149 | ] |
|
128 | 150 | |
|
129 | 151 | [[package]] |
@@ -131,18 +153,18 b' name = "crossbeam-utils"' | |||
|
131 | 153 | version = "0.7.2" |
|
132 | 154 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
133 | 155 | dependencies = [ |
|
134 |
"autocfg 1.0. |
|
|
156 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
135 | 157 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
136 | 158 | "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
137 | 159 | ] |
|
138 | 160 | |
|
139 | 161 | [[package]] |
|
140 | 162 | name = "ctor" |
|
141 |
version = "0.1.1 |
|
|
163 | version = "0.1.16" | |
|
142 | 164 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
143 | 165 | dependencies = [ |
|
144 |
"quote 1.0. |
|
|
145 |
"syn 1.0.1 |
|
|
166 | "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
167 | "syn 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
146 | 168 | ] |
|
147 | 169 | |
|
148 | 170 | [[package]] |
@@ -152,7 +174,7 b' source = "registry+https://github.com/ru' | |||
|
152 | 174 | |
|
153 | 175 | [[package]] |
|
154 | 176 | name = "either" |
|
155 |
version = "1. |
|
|
177 | version = "1.6.1" | |
|
156 | 178 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
157 | 179 | |
|
158 | 180 | [[package]] |
@@ -162,27 +184,44 b' source = "registry+https://github.com/ru' | |||
|
162 | 184 | dependencies = [ |
|
163 | 185 | "atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)", |
|
164 | 186 | "humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
165 |
"log 0.4. |
|
|
187 | "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
166 | 188 | "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)", |
|
167 | 189 | "termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
168 | 190 | ] |
|
169 | 191 | |
|
170 | 192 | [[package]] |
|
171 |
name = " |
|
|
172 |
version = " |
|
|
193 | name = "flate2" | |
|
194 | version = "1.0.17" | |
|
173 | 195 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
174 | 196 | dependencies = [ |
|
175 | 197 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
176 |
" |
|
|
198 | "crc32fast 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
199 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
200 | "libz-sys 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
201 | "miniz_oxide 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
202 | ] | |
|
203 | ||
|
204 | [[package]] | |
|
205 | name = "getrandom" | |
|
206 | version = "0.1.15" | |
|
207 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
208 | dependencies = [ | |
|
209 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
210 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
177 | 211 | "wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
178 | 212 | ] |
|
179 | 213 | |
|
180 | 214 | [[package]] |
|
215 | name = "glob" | |
|
216 | version = "0.3.0" | |
|
217 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
218 | ||
|
219 | [[package]] | |
|
181 | 220 | name = "hermit-abi" |
|
182 |
version = "0.1. |
|
|
221 | version = "0.1.16" | |
|
183 | 222 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
184 | 223 | dependencies = [ |
|
185 |
"libc 0.2. |
|
|
224 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
186 | 225 | ] |
|
187 | 226 | |
|
188 | 227 | [[package]] |
@@ -195,23 +234,25 b' name = "hg-core"' | |||
|
195 | 234 | version = "0.1.0" |
|
196 | 235 | dependencies = [ |
|
197 | 236 | "byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)", |
|
198 |
"clap 2.33. |
|
|
237 | "clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
199 | 238 | "crossbeam 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
239 | "flate2 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
200 | 240 | "hex 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
201 | 241 | "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
202 |
"log 0.4. |
|
|
242 | "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
203 | 243 | "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
204 | 244 | "memmap 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
205 |
"micro-timer 0.3. |
|
|
245 | "micro-timer 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
206 | 246 | "pretty_assertions 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
207 | 247 | "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
208 | 248 | "rand_distr 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
209 | 249 | "rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
210 |
"rayon 1. |
|
|
250 | "rayon 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
211 | 251 | "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)", |
|
212 | 252 | "same-file 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)", |
|
213 | 253 | "tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
214 | 254 | "twox-hash 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
255 | "zstd 0.5.3+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
215 | 256 | ] |
|
216 | 257 | |
|
217 | 258 | [[package]] |
@@ -221,8 +262,8 b' dependencies = [' | |||
|
221 | 262 | "cpython 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
222 | 263 | "env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
223 | 264 | "hg-core 0.1.0", |
|
224 |
"libc 0.2. |
|
|
225 |
"log 0.4. |
|
|
265 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
266 | "log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
226 | 267 | ] |
|
227 | 268 | |
|
228 | 269 | [[package]] |
@@ -234,18 +275,44 b' dependencies = [' | |||
|
234 | 275 | ] |
|
235 | 276 | |
|
236 | 277 | [[package]] |
|
278 | name = "itertools" | |
|
279 | version = "0.9.0" | |
|
280 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
281 | dependencies = [ | |
|
282 | "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
283 | ] | |
|
284 | ||
|
285 | [[package]] | |
|
286 | name = "jobserver" | |
|
287 | version = "0.1.21" | |
|
288 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
289 | dependencies = [ | |
|
290 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
291 | ] | |
|
292 | ||
|
293 | [[package]] | |
|
237 | 294 | name = "lazy_static" |
|
238 | 295 | version = "1.4.0" |
|
239 | 296 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
240 | 297 | |
|
241 | 298 | [[package]] |
|
242 | 299 | name = "libc" |
|
243 |
version = "0.2. |
|
|
300 | version = "0.2.77" | |
|
244 | 301 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
245 | 302 | |
|
246 | 303 | [[package]] |
|
304 | name = "libz-sys" | |
|
305 | version = "1.1.2" | |
|
306 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
307 | dependencies = [ | |
|
308 | "cc 1.0.60 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
309 | "pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
310 | "vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
311 | ] | |
|
312 | ||
|
313 | [[package]] | |
|
247 | 314 | name = "log" |
|
248 |
version = "0.4. |
|
|
315 | version = "0.4.11" | |
|
249 | 316 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
250 | 317 | dependencies = [ |
|
251 | 318 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -266,53 +333,62 b' name = "memmap"' | |||
|
266 | 333 | version = "0.7.0" |
|
267 | 334 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
268 | 335 | dependencies = [ |
|
269 |
"libc 0.2. |
|
|
270 |
"winapi 0.3. |
|
|
336 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
337 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
271 | 338 | ] |
|
272 | 339 | |
|
273 | 340 | [[package]] |
|
274 | 341 | name = "memoffset" |
|
275 |
version = "0.5. |
|
|
342 | version = "0.5.6" | |
|
276 | 343 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
277 | 344 | dependencies = [ |
|
278 |
" |
|
|
345 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
279 | 346 | ] |
|
280 | 347 | |
|
281 | 348 | [[package]] |
|
282 | 349 | name = "micro-timer" |
|
283 |
version = "0.3. |
|
|
350 | version = "0.3.1" | |
|
284 | 351 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
285 | 352 | dependencies = [ |
|
286 |
"micro-timer-macros 0.3. |
|
|
353 | "micro-timer-macros 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
287 | 354 | "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
288 | 355 | ] |
|
289 | 356 | |
|
290 | 357 | [[package]] |
|
291 | 358 | name = "micro-timer-macros" |
|
292 |
version = "0.3. |
|
|
359 | version = "0.3.1" | |
|
293 | 360 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
294 | 361 | dependencies = [ |
|
295 |
"proc-macro2 1.0. |
|
|
296 |
"quote 1.0. |
|
|
362 | "proc-macro2 1.0.21 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
363 | "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
297 | 364 | "scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
298 |
"syn 1.0.1 |
|
|
365 | "syn 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
366 | ] | |
|
367 | ||
|
368 | [[package]] | |
|
369 | name = "miniz_oxide" | |
|
370 | version = "0.4.2" | |
|
371 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
372 | dependencies = [ | |
|
373 | "adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
374 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
299 | 375 | ] |
|
300 | 376 | |
|
301 | 377 | [[package]] |
|
302 | 378 | name = "num-traits" |
|
303 |
version = "0.2.1 |
|
|
379 | version = "0.2.12" | |
|
304 | 380 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
305 | 381 | dependencies = [ |
|
306 |
"autocfg 1.0. |
|
|
382 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
307 | 383 | ] |
|
308 | 384 | |
|
309 | 385 | [[package]] |
|
310 | 386 | name = "num_cpus" |
|
311 |
version = "1.1 |
|
|
387 | version = "1.13.0" | |
|
312 | 388 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
313 | 389 | dependencies = [ |
|
314 |
"hermit-abi 0.1. |
|
|
315 |
"libc 0.2. |
|
|
390 | "hermit-abi 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
391 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
316 | 392 | ] |
|
317 | 393 | |
|
318 | 394 | [[package]] |
@@ -320,12 +396,17 b' name = "output_vt100"' | |||
|
320 | 396 | version = "0.1.2" |
|
321 | 397 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
322 | 398 | dependencies = [ |
|
323 |
"winapi 0.3. |
|
|
399 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
324 | 400 | ] |
|
325 | 401 | |
|
326 | 402 | [[package]] |
|
403 | name = "pkg-config" | |
|
404 | version = "0.3.18" | |
|
405 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
406 | ||
|
407 | [[package]] | |
|
327 | 408 | name = "ppv-lite86" |
|
328 |
version = "0.2. |
|
|
409 | version = "0.2.9" | |
|
329 | 410 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
330 | 411 | |
|
331 | 412 | [[package]] |
@@ -334,17 +415,17 b' version = "0.6.1"' | |||
|
334 | 415 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
335 | 416 | dependencies = [ |
|
336 | 417 | "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
337 |
"ctor 0.1.1 |
|
|
418 | "ctor 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
338 | 419 | "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
339 | 420 | "output_vt100 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
340 | 421 | ] |
|
341 | 422 | |
|
342 | 423 | [[package]] |
|
343 | 424 | name = "proc-macro2" |
|
344 |
version = "1.0. |
|
|
425 | version = "1.0.21" | |
|
345 | 426 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
346 | 427 | dependencies = [ |
|
347 |
"unicode-xid 0.2. |
|
|
428 | "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
348 | 429 | ] |
|
349 | 430 | |
|
350 | 431 | [[package]] |
@@ -352,7 +433,7 b' name = "python27-sys"' | |||
|
352 | 433 | version = "0.4.1" |
|
353 | 434 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
354 | 435 | dependencies = [ |
|
355 |
"libc 0.2. |
|
|
436 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
356 | 437 | "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)", |
|
357 | 438 | ] |
|
358 | 439 | |
@@ -361,7 +442,7 b' name = "python3-sys"' | |||
|
361 | 442 | version = "0.4.1" |
|
362 | 443 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
363 | 444 | dependencies = [ |
|
364 |
"libc 0.2. |
|
|
445 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
365 | 446 | "regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)", |
|
366 | 447 | ] |
|
367 | 448 | |
@@ -372,10 +453,10 b' source = "registry+https://github.com/ru' | |||
|
372 | 453 | |
|
373 | 454 | [[package]] |
|
374 | 455 | name = "quote" |
|
375 |
version = "1.0. |
|
|
456 | version = "1.0.7" | |
|
376 | 457 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
377 | 458 | dependencies = [ |
|
378 |
"proc-macro2 1.0. |
|
|
459 | "proc-macro2 1.0.21 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
379 | 460 | ] |
|
380 | 461 | |
|
381 | 462 | [[package]] |
@@ -383,8 +464,8 b' name = "rand"' | |||
|
383 | 464 | version = "0.7.3" |
|
384 | 465 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
385 | 466 | dependencies = [ |
|
386 |
"getrandom 0.1.1 |
|
|
387 |
"libc 0.2. |
|
|
467 | "getrandom 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
468 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
388 | 469 | "rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
389 | 470 | "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
390 | 471 | "rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -395,7 +476,7 b' name = "rand_chacha"' | |||
|
395 | 476 | version = "0.2.2" |
|
396 | 477 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
397 | 478 | dependencies = [ |
|
398 |
"ppv-lite86 0.2. |
|
|
479 | "ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
399 | 480 | "rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", |
|
400 | 481 | ] |
|
401 | 482 | |
@@ -404,7 +485,7 b' name = "rand_core"' | |||
|
404 | 485 | version = "0.5.1" |
|
405 | 486 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
406 | 487 | dependencies = [ |
|
407 |
"getrandom 0.1.1 |
|
|
488 | "getrandom 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
408 | 489 | ] |
|
409 | 490 | |
|
410 | 491 | [[package]] |
@@ -433,29 +514,30 b' dependencies = [' | |||
|
433 | 514 | |
|
434 | 515 | [[package]] |
|
435 | 516 | name = "rayon" |
|
436 |
version = "1. |
|
|
517 | version = "1.4.0" | |
|
437 | 518 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
438 | 519 | dependencies = [ |
|
520 | "autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
439 | 521 | "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
440 |
"either 1. |
|
|
441 |
"rayon-core 1. |
|
|
522 | "either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
523 | "rayon-core 1.8.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
442 | 524 | ] |
|
443 | 525 | |
|
444 | 526 | [[package]] |
|
445 | 527 | name = "rayon-core" |
|
446 |
version = "1. |
|
|
528 | version = "1.8.1" | |
|
447 | 529 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
448 | 530 | dependencies = [ |
|
531 | "crossbeam-channel 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
449 | 532 | "crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
450 | "crossbeam-queue 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
451 | 533 | "crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)", |
|
452 | 534 | "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", |
|
453 |
"num_cpus 1.1 |
|
|
535 | "num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
454 | 536 | ] |
|
455 | 537 | |
|
456 | 538 | [[package]] |
|
457 | 539 | name = "redox_syscall" |
|
458 |
version = "0.1.5 |
|
|
540 | version = "0.1.57" | |
|
459 | 541 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
460 | 542 | |
|
461 | 543 | [[package]] |
@@ -463,7 +545,7 b' name = "regex"' | |||
|
463 | 545 | version = "1.3.9" |
|
464 | 546 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
465 | 547 | dependencies = [ |
|
466 |
"aho-corasick 0.7.1 |
|
|
548 | "aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
467 | 549 | "memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
468 | 550 | "regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)", |
|
469 | 551 | "thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -476,34 +558,26 b' source = "registry+https://github.com/ru' | |||
|
476 | 558 | |
|
477 | 559 | [[package]] |
|
478 | 560 | name = "remove_dir_all" |
|
479 |
version = "0.5. |
|
|
561 | version = "0.5.3" | |
|
480 | 562 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
481 | 563 | dependencies = [ |
|
482 |
"winapi 0.3. |
|
|
564 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
483 | 565 | ] |
|
484 | 566 | |
|
485 | 567 | [[package]] |
|
486 | 568 | name = "rhg" |
|
487 | 569 | version = "0.1.0" |
|
488 | 570 | dependencies = [ |
|
489 |
"clap 2.33. |
|
|
571 | "clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
490 | 572 | "hg-core 0.1.0", |
|
491 | 573 | ] |
|
492 | 574 | |
|
493 | 575 | [[package]] |
|
494 | name = "rustc_version" | |
|
495 | version = "0.2.3" | |
|
496 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
497 | dependencies = [ | |
|
498 | "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
499 | ] | |
|
500 | ||
|
501 | [[package]] | |
|
502 | 576 | name = "same-file" |
|
503 | 577 | version = "1.0.6" |
|
504 | 578 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
505 | 579 | dependencies = [ |
|
506 |
"winapi-util 0.1. |
|
|
580 | "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
507 | 581 | ] |
|
508 | 582 | |
|
509 | 583 | [[package]] |
@@ -512,31 +586,18 b' version = "1.1.0"' | |||
|
512 | 586 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
513 | 587 | |
|
514 | 588 | [[package]] |
|
515 | name = "semver" | |
|
516 | version = "0.9.0" | |
|
517 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
518 | dependencies = [ | |
|
519 | "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
520 | ] | |
|
521 | ||
|
522 | [[package]] | |
|
523 | name = "semver-parser" | |
|
524 | version = "0.7.0" | |
|
525 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
526 | ||
|
527 | [[package]] | |
|
528 | 589 | name = "strsim" |
|
529 | 590 | version = "0.8.0" |
|
530 | 591 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
531 | 592 | |
|
532 | 593 | [[package]] |
|
533 | 594 | name = "syn" |
|
534 |
version = "1.0.1 |
|
|
595 | version = "1.0.41" | |
|
535 | 596 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
536 | 597 | dependencies = [ |
|
537 |
"proc-macro2 1.0. |
|
|
538 |
"quote 1.0. |
|
|
539 |
"unicode-xid 0.2. |
|
|
598 | "proc-macro2 1.0.21 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
599 | "quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
600 | "unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
540 | 601 | ] |
|
541 | 602 | |
|
542 | 603 | [[package]] |
@@ -545,11 +606,11 b' version = "3.1.0"' | |||
|
545 | 606 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
546 | 607 | dependencies = [ |
|
547 | 608 | "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", |
|
548 |
"libc 0.2. |
|
|
609 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
549 | 610 | "rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", |
|
550 |
"redox_syscall 0.1.5 |
|
|
551 |
"remove_dir_all 0.5. |
|
|
552 |
"winapi 0.3. |
|
|
611 | "redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
612 | "remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
613 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
553 | 614 | ] |
|
554 | 615 | |
|
555 | 616 | [[package]] |
@@ -557,7 +618,7 b' name = "termcolor"' | |||
|
557 | 618 | version = "1.1.0" |
|
558 | 619 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
559 | 620 | dependencies = [ |
|
560 |
"winapi-util 0.1. |
|
|
621 | "winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
561 | 622 | ] |
|
562 | 623 | |
|
563 | 624 | [[package]] |
@@ -565,7 +626,7 b' name = "textwrap"' | |||
|
565 | 626 | version = "0.11.0" |
|
566 | 627 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
567 | 628 | dependencies = [ |
|
568 |
"unicode-width 0.1. |
|
|
629 | "unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
569 | 630 | ] |
|
570 | 631 | |
|
571 | 632 | [[package]] |
@@ -586,17 +647,22 b' dependencies = [' | |||
|
586 | 647 | |
|
587 | 648 | [[package]] |
|
588 | 649 | name = "unicode-width" |
|
589 |
version = "0.1. |
|
|
650 | version = "0.1.8" | |
|
590 | 651 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
591 | 652 | |
|
592 | 653 | [[package]] |
|
593 | 654 | name = "unicode-xid" |
|
594 |
version = "0.2. |
|
|
655 | version = "0.2.1" | |
|
656 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
657 | ||
|
658 | [[package]] | |
|
659 | name = "vcpkg" | |
|
660 | version = "0.2.10" | |
|
595 | 661 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
596 | 662 | |
|
597 | 663 | [[package]] |
|
598 | 664 | name = "vec_map" |
|
599 |
version = "0.8. |
|
|
665 | version = "0.8.2" | |
|
600 | 666 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
601 | 667 | |
|
602 | 668 | [[package]] |
@@ -606,7 +672,7 b' source = "registry+https://github.com/ru' | |||
|
606 | 672 | |
|
607 | 673 | [[package]] |
|
608 | 674 | name = "winapi" |
|
609 |
version = "0.3. |
|
|
675 | version = "0.3.9" | |
|
610 | 676 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
611 | 677 | dependencies = [ |
|
612 | 678 | "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", |
@@ -620,10 +686,10 b' source = "registry+https://github.com/ru' | |||
|
620 | 686 | |
|
621 | 687 | [[package]] |
|
622 | 688 | name = "winapi-util" |
|
623 |
version = "0.1. |
|
|
689 | version = "0.1.5" | |
|
624 | 690 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
625 | 691 | dependencies = [ |
|
626 |
"winapi 0.3. |
|
|
692 | "winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
627 | 693 | ] |
|
628 | 694 | |
|
629 | 695 | [[package]] |
@@ -631,78 +697,117 b' name = "winapi-x86_64-pc-windows-gnu"' | |||
|
631 | 697 | version = "0.4.0" |
|
632 | 698 | source = "registry+https://github.com/rust-lang/crates.io-index" |
|
633 | 699 | |
|
700 | [[package]] | |
|
701 | name = "zstd" | |
|
702 | version = "0.5.3+zstd.1.4.5" | |
|
703 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
704 | dependencies = [ | |
|
705 | "zstd-safe 2.0.5+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
706 | ] | |
|
707 | ||
|
708 | [[package]] | |
|
709 | name = "zstd-safe" | |
|
710 | version = "2.0.5+zstd.1.4.5" | |
|
711 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
712 | dependencies = [ | |
|
713 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
714 | "zstd-sys 1.4.17+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
715 | ] | |
|
716 | ||
|
717 | [[package]] | |
|
718 | name = "zstd-sys" | |
|
719 | version = "1.4.17+zstd.1.4.5" | |
|
720 | source = "registry+https://github.com/rust-lang/crates.io-index" | |
|
721 | dependencies = [ | |
|
722 | "cc 1.0.60 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
723 | "glob 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
724 | "itertools 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
725 | "libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)", | |
|
726 | ] | |
|
727 | ||
|
634 | 728 | [metadata] |
|
635 | "checksum aho-corasick 0.7.10 (registry+https://github.com/rust-lang/crates.io-index)" = "8716408b8bc624ed7f65d223ddb9ac2d044c0547b6fa4b0d554f3a9540496ada" | |
|
729 | "checksum adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e" | |
|
730 | "checksum aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)" = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86" | |
|
636 | 731 | "checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b" |
|
637 | 732 | "checksum atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" |
|
638 | "checksum autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" | |
|
733 | "checksum autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" | |
|
639 | 734 | "checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" |
|
640 | 735 | "checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" |
|
736 | "checksum cc 1.0.60 (registry+https://github.com/rust-lang/crates.io-index)" = "ef611cc68ff783f18535d77ddd080185275713d852c4f5cbb6122c462a7a825c" | |
|
641 | 737 | "checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" |
|
642 |
"checksum clap 2.33. |
|
|
738 | "checksum clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)" = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002" | |
|
643 | 739 | "checksum cpython 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bfaf3847ab963e40c4f6dd8d6be279bdf74007ae2413786a0dcbb28c52139a95" |
|
740 | "checksum crc32fast 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1" | |
|
644 | 741 | "checksum crossbeam 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "69323bff1fb41c635347b8ead484a5ca6c3f11914d784170b158d8449ab07f8e" |
|
645 |
"checksum crossbeam-channel 0.4. |
|
|
742 | "checksum crossbeam-channel 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b153fe7cbef478c567df0f972e02e6d736db11affe43dfc9c56a9374d1adfb87" | |
|
646 | 743 | "checksum crossbeam-deque 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285" |
|
647 | 744 | "checksum crossbeam-epoch 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace" |
|
648 |
"checksum crossbeam-queue 0.2. |
|
|
745 | "checksum crossbeam-queue 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570" | |
|
649 | 746 | "checksum crossbeam-utils 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" |
|
650 |
"checksum ctor 0.1.1 |
|
|
747 | "checksum ctor 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "7fbaabec2c953050352311293be5c6aba8e141ba19d6811862b232d6fd020484" | |
|
651 | 748 | "checksum difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" |
|
652 |
"checksum either 1. |
|
|
749 | "checksum either 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" | |
|
653 | 750 | "checksum env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36" |
|
654 | "checksum getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb" | |
|
655 |
"checksum |
|
|
751 | "checksum flate2 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)" = "766d0e77a2c1502169d4a93ff3b8c15a71fd946cd0126309752104e5f3c46d94" | |
|
752 | "checksum getrandom 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" | |
|
753 | "checksum glob 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" | |
|
754 | "checksum hermit-abi 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c30f6d0bc6b00693347368a67d41b58f2fb851215ff1da49e90fe2c5c667151" | |
|
656 | 755 | "checksum hex 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "644f9158b2f133fd50f5fb3242878846d9eb792e445c893805ff0e3824006e35" |
|
657 | 756 | "checksum humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f" |
|
757 | "checksum itertools 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b" | |
|
758 | "checksum jobserver 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)" = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2" | |
|
658 | 759 | "checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" |
|
659 |
"checksum libc 0.2. |
|
|
660 | "checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" | |
|
760 | "checksum libc 0.2.77 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f96b10ec2560088a8e76961b00d47107b3a625fecb76dedb29ee7ccbf98235" | |
|
761 | "checksum libz-sys 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "602113192b08db8f38796c4e85c39e960c145965140e918018bcde1952429655" | |
|
762 | "checksum log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b" | |
|
661 | 763 | "checksum maybe-uninit 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" |
|
662 | 764 | "checksum memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" |
|
663 | 765 | "checksum memmap 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b" |
|
664 |
"checksum memoffset 0.5. |
|
|
665 |
"checksum micro-timer 0.3. |
|
|
666 |
"checksum micro-timer-macros 0.3. |
|
|
667 | "checksum num-traits 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "c62be47e61d1842b9170f0fdeec8eba98e60e90e5446449a0545e5152acd7096" | |
|
668 |
"checksum num |
|
|
766 | "checksum memoffset 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa" | |
|
767 | "checksum micro-timer 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2620153e1d903d26b72b89f0e9c48d8c4756cba941c185461dddc234980c298c" | |
|
768 | "checksum micro-timer-macros 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e28a3473e6abd6e9aab36aaeef32ad22ae0bd34e79f376643594c2b152ec1c5d" | |
|
769 | "checksum miniz_oxide 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c60c0dfe32c10b43a144bad8fc83538c52f58302c92300ea7ec7bf7b38d5a7b9" | |
|
770 | "checksum num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611" | |
|
771 | "checksum num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" | |
|
669 | 772 | "checksum output_vt100 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9" |
|
670 | "checksum ppv-lite86 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b" | |
|
773 | "checksum pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)" = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33" | |
|
774 | "checksum ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20" | |
|
671 | 775 | "checksum pretty_assertions 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3f81e1644e1b54f5a68959a29aa86cde704219254669da328ecfdf6a1f09d427" |
|
672 |
"checksum proc-macro2 1.0. |
|
|
776 | "checksum proc-macro2 1.0.21 (registry+https://github.com/rust-lang/crates.io-index)" = "36e28516df94f3dd551a587da5357459d9b36d945a7c37c3557928c1c2ff2a2c" | |
|
673 | 777 | "checksum python27-sys 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "67cb041de8615111bf224dd75667af5f25c6e032118251426fed7f1b70ce4c8c" |
|
674 | 778 | "checksum python3-sys 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90af11779515a1e530af60782d273b59ac79d33b0e253c071a728563957c76d4" |
|
675 | 779 | "checksum quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" |
|
676 | "checksum quote 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f" | |
|
780 | "checksum quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37" | |
|
677 | 781 | "checksum rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" |
|
678 | 782 | "checksum rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" |
|
679 | 783 | "checksum rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" |
|
680 | 784 | "checksum rand_distr 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "96977acbdd3a6576fb1d27391900035bf3863d4a16422973a409b488cf29ffb2" |
|
681 | 785 | "checksum rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" |
|
682 | 786 | "checksum rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429" |
|
683 |
"checksum rayon 1. |
|
|
684 | "checksum rayon-core 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "08a89b46efaf957e52b18062fb2f4660f8b8a4dde1807ca002690868ef2c85a9" | |
|
685 |
"checksum redox_syscall 0.1.5 |
|
|
787 | "checksum rayon 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cfd016f0c045ad38b5251be2c9c0ab806917f82da4d36b2a327e5166adad9270" | |
|
788 | "checksum rayon-core 1.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e8c4fec834fb6e6d2dd5eece3c7b432a52f0ba887cf40e595190c4107edc08bf" | |
|
789 | "checksum redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)" = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce" | |
|
686 | 790 | "checksum regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6" |
|
687 | 791 | "checksum regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)" = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8" |
|
688 |
"checksum remove_dir_all 0.5. |
|
|
689 | "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a" | |
|
792 | "checksum remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" | |
|
690 | 793 | "checksum same-file 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" |
|
691 | 794 | "checksum scopeguard 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" |
|
692 | "checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" | |
|
693 | "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" | |
|
694 | 795 | "checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a" |
|
695 |
"checksum syn 1.0.1 |
|
|
796 | "checksum syn 1.0.41 (registry+https://github.com/rust-lang/crates.io-index)" = "6690e3e9f692504b941dc6c3b188fd28df054f7fb8469ab40680df52fdcc842b" | |
|
696 | 797 | "checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9" |
|
697 | 798 | "checksum termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f" |
|
698 | 799 | "checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" |
|
699 | 800 | "checksum thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14" |
|
700 | 801 | "checksum twox-hash 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3bfd5b7557925ce778ff9b9ef90e3ade34c524b5ff10e239c69a42d546d2af56" |
|
701 |
"checksum unicode-width 0.1. |
|
|
702 |
"checksum unicode-xid 0.2. |
|
|
703 | "checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a" | |
|
802 | "checksum unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3" | |
|
803 | "checksum unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" | |
|
804 | "checksum vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c" | |
|
805 | "checksum vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" | |
|
704 | 806 | "checksum wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)" = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" |
|
705 |
"checksum winapi 0.3. |
|
|
807 | "checksum winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" | |
|
706 | 808 | "checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" |
|
707 |
"checksum winapi-util 0.1. |
|
|
809 | "checksum winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" | |
|
708 | 810 | "checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" |
|
811 | "checksum zstd 0.5.3+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "01b32eaf771efa709e8308605bbf9319bf485dc1503179ec0469b611937c0cd8" | |
|
812 | "checksum zstd-safe 2.0.5+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "1cfb642e0d27f64729a639c52db457e0ae906e7bc6f5fe8f5c453230400f1055" | |
|
813 | "checksum zstd-sys 1.4.17+zstd.1.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "b89249644df056b522696b1bb9e7c18c87e8ffa3e2f0dc3b0155875d6498f01b" |
@@ -23,9 +23,19 b' same-file = "1.0.6"' | |||
|
23 | 23 | crossbeam = "0.7.3" |
|
24 | 24 | micro-timer = "0.3.0" |
|
25 | 25 | log = "0.4.8" |
|
26 | memmap = "0.7.0" | |
|
27 | zstd = "0.5.3" | |
|
28 | ||
|
29 | # We don't use the `miniz-oxide` backend because its minimum Rust version is | |
|
30 | # `1.36`. However, this PR (https://github.com/Frommi/miniz_oxide/pull/84/files) | |
|
31 | # introduces a flag `no_extern_crate_alloc` to bring the requirement back down | |
|
32 | # to `1.34`. | |
|
33 | [dependencies.flate2] | |
|
34 | version = "1.0.16" | |
|
35 | features = ["zlib"] | |
|
36 | default-features = false | |
|
26 | 37 | |
|
27 | 38 | [dev-dependencies] |
|
28 | 39 | clap = "*" |
|
29 | memmap = "0.7.0" | |
|
30 | 40 | pretty_assertions = "0.6.1" |
|
31 | 41 | tempfile = "3.1.0" |
General Comments 0
You need to be logged in to leave comments.
Login now