This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6628

rust-parsers: switch to parse/pack_dirstate to mutate-on-loop
ClosedPublic

Authored by Alphare on Jul 10 2019, 7:46 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHG7cae6bc29ff9: rust-parsers: switch to parse/pack_dirstate to mutate-on-loop
rHGc36bdb4e884d: rust-parsers: switch to parse/pack_dirstate to mutate-on-loop
Summary

Both parse_dirstate and pack_dirstate can operate directly on the data
they're passed, which prevents the creation of intermediate data structures,
simplifies the function signatures and reduces boilerplate. They are exposed
directly to the Python for now, but a later patch will make use of them inside
hg-core.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Jul 10 2019, 7:46 AM
Alphare updated this revision to Diff 15897.Jul 12 2019, 5:22 AM
kevincox accepted this revision.Jul 15 2019, 12:24 PM
kevincox added inline comments.
rust/hg-core/src/dirstate/mod.rs
16 ↗(On Diff #15897)

If these are always 20 bytes long you are best to use [u8; 20]. That way there will be no indirection. And since Vec is 3 words it will have a bigger immediate size on 64bit platforms.

rust/hg-core/src/dirstate/parsers.rs
85–86

The "proper" solution is SystemTime however I will admit that it is a bit more awkward to use. However if you are going to use Duration please document that it is the Duration since the Unix Epoch.

91

Would it be best to panic on overflow? now.as_secs().try_into::<i32>().expect("time overflow").

Alphare marked 3 inline comments as done.Jul 17 2019, 6:30 AM
Alphare updated this revision to Diff 16046.Jul 24 2019, 11:22 AM
Alphare added a commit: rHGc36bdb4e884d: rust-parsers: switch to parse/pack_dirstate to mutate-on-loop.Aug 14 2019, 4:38 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGc36bdb4e884d: rust-parsers: switch to parse/pack_dirstate to mutate-on-loop (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 16197

rust/hg-core/src/dirstate.rs

// dirstate module
//
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use std::collections::HashMap;
pub mod dirs_multiset; pub mod dirs_multiset;
pub mod parsers; pub mod parsers;
#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Clone)]
pub struct DirstateParents<'a> { pub struct DirstateParents {
pub p1: &'a [u8], pub p1: [u8; 20],
pub p2: &'a [u8], pub p2: [u8; 20],
} }
/// The C implementation uses all signed types. This will be an issue /// The C implementation uses all signed types. This will be an issue
/// either when 4GB+ source files are commonplace or in 2038, whichever /// either when 4GB+ source files are commonplace or in 2038, whichever
/// comes first. /// comes first.
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub state: i8, pub state: i8,
pub mode: i32, pub mode: i32,
pub mtime: i32, pub mtime: i32,
pub size: i32, pub size: i32,
} }
pub type DirstateVec = Vec<(Vec<u8>, DirstateEntry)>; pub type StateMap = HashMap<Vec<u8>, DirstateEntry>;
pub type CopyMap = HashMap<Vec<u8>, Vec<u8>>;
#[derive(Debug, PartialEq)]
pub struct CopyVecEntry<'a> {
pub path: &'a [u8],
pub copy_path: &'a [u8],
}
pub type CopyVec<'a> = Vec<CopyVecEntry<'a>>;
/// The Python implementation passes either a mapping (dirstate) or a flat /// The Python implementation passes either a mapping (dirstate) or a flat
/// iterable (manifest) /// iterable (manifest)
pub enum DirsIterable { pub enum DirsIterable<'a> {
Dirstate(DirstateVec), Dirstate(&'a HashMap<Vec<u8>, DirstateEntry>),
Manifest(Vec<Vec<u8>>), Manifest(&'a Vec<Vec<u8>>),
} }

rust/hg-core/src/dirstate/dirs_multiset.rs

/// If `skip_state` is provided, skips dirstate entries with equal state. /// If `skip_state` is provided, skips dirstate entries with equal state.
pub fn new(iterable: DirsIterable, skip_state: Option<i8>) -> Self { pub fn new(iterable: DirsIterable, skip_state: Option<i8>) -> Self {
let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: HashMap::new(), inner: HashMap::new(),
}; };
match iterable { match iterable {
DirsIterable::Dirstate(vec) => { DirsIterable::Dirstate(vec) => {
for (ref filename, DirstateEntry { state, .. }) in vec { for (filename, DirstateEntry { state, .. }) in vec {
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if let Some(skip) = skip_state { if let Some(skip) = skip_state {
if skip != state { if skip != *state {
multiset.add_path(filename); multiset.add_path(filename);
} }
} else { } else {
multiset.add_path(filename); multiset.add_path(filename);
} }
} }
} }
DirsIterable::Manifest(vec) => { DirsIterable::Manifest(vec) => {
for ref filename in vec { for filename in vec {
multiset.add_path(filename); multiset.add_path(filename);
} }
} }
} }
multiset multiset
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.inner.len() self.inner.len()
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use std::collections::HashMap;
#[test] #[test]
fn test_delete_path_path_not_found() { fn test_delete_path_path_not_found() {
let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None); let mut map = DirsMultiset::new(DirsIterable::Manifest(&vec![]), None);
let path = b"doesnotexist/"; let path = b"doesnotexist/";
assert_eq!( assert_eq!(
Err(DirstateMapError::PathNotFound(path.to_vec())), Err(DirstateMapError::PathNotFound(path.to_vec())),
map.delete_path(path) map.delete_path(path)
); );
} }
#[test] #[test]
fn test_delete_path_empty_path() { fn test_delete_path_empty_path() {
let mut map = let mut map =
DirsMultiset::new(DirsIterable::Manifest(vec![vec![]]), None); DirsMultiset::new(DirsIterable::Manifest(&vec![vec![]]), None);
let path = b""; let path = b"";
assert_eq!(Ok(()), map.delete_path(path)); assert_eq!(Ok(()), map.delete_path(path));
assert_eq!( assert_eq!(
Err(DirstateMapError::PathNotFound(path.to_vec())), Err(DirstateMapError::PathNotFound(path.to_vec())),
map.delete_path(path) map.delete_path(path)
); );
} }
assert_eq!( assert_eq!(
Err(DirstateMapError::PathNotFound(b"a/c/".to_vec())), Err(DirstateMapError::PathNotFound(b"a/c/".to_vec())),
map.delete_path(b"a/c/") map.delete_path(b"a/c/")
); );
} }
#[test] #[test]
fn test_add_path_empty_path() { fn test_add_path_empty_path() {
let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None); let mut map = DirsMultiset::new(DirsIterable::Manifest(&vec![]), None);
let path = b""; let path = b"";
map.add_path(path); map.add_path(path);
assert_eq!(1, map.len()); assert_eq!(1, map.len());
} }
#[test] #[test]
fn test_add_path_successful() { fn test_add_path_successful() {
let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None); let mut map = DirsMultiset::new(DirsIterable::Manifest(&vec![]), None);
map.add_path(b"a/"); map.add_path(b"a/");
assert_eq!(1, *map.inner.get(&b"a".to_vec()).unwrap()); assert_eq!(1, *map.inner.get(&b"a".to_vec()).unwrap());
assert_eq!(1, *map.inner.get(&Vec::new()).unwrap()); assert_eq!(1, *map.inner.get(&Vec::new()).unwrap());
assert_eq!(2, map.len()); assert_eq!(2, map.len());
// Non directory should be ignored // Non directory should be ignored
map.add_path(b"a"); map.add_path(b"a");
}; };
assert_eq!(map, expected); assert_eq!(map, expected);
} }
#[test] #[test]
fn test_dirsmultiset_new_empty() { fn test_dirsmultiset_new_empty() {
use DirsIterable::{Dirstate, Manifest}; use DirsIterable::{Dirstate, Manifest};
let new = DirsMultiset::new(Manifest(vec![]), None); let new = DirsMultiset::new(Manifest(&vec![]), None);
let expected = DirsMultiset { let expected = DirsMultiset {
inner: HashMap::new(), inner: HashMap::new(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let new = DirsMultiset::new(Dirstate(vec![]), None); let new = DirsMultiset::new(Dirstate(&HashMap::new()), None);
let expected = DirsMultiset { let expected = DirsMultiset {
inner: HashMap::new(), inner: HashMap::new(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
#[test] #[test]
fn test_dirsmultiset_new_no_skip() { fn test_dirsmultiset_new_no_skip() {
use DirsIterable::{Dirstate, Manifest}; use DirsIterable::{Dirstate, Manifest};
let input_vec = ["a/", "b/", "a/c", "a/d/"] let input_vec = ["a/", "b/", "a/c", "a/d/"]
.iter() .iter()
.map(|e| e.as_bytes().to_vec()) .map(|e| e.as_bytes().to_vec())
.collect(); .collect();
let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (k.as_bytes().to_vec(), *v)) .map(|(k, v)| (k.as_bytes().to_vec(), *v))
.collect(); .collect();
let new = DirsMultiset::new(Manifest(input_vec), None); let new = DirsMultiset::new(Manifest(&input_vec), None);
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let input_map = ["a/", "b/", "a/c", "a/d/"] let input_map = ["a/", "b/", "a/c", "a/d/"]
.iter() .iter()
.map(|f| { .map(|f| {
( (
f.as_bytes().to_vec(), f.as_bytes().to_vec(),
DirstateEntry { DirstateEntry {
state: 0, state: 0,
mode: 0, mode: 0,
mtime: 0, mtime: 0,
size: 0, size: 0,
}, },
) )
}) })
.collect(); .collect();
let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (k.as_bytes().to_vec(), *v)) .map(|(k, v)| (k.as_bytes().to_vec(), *v))
.collect(); .collect();
let new = DirsMultiset::new(Dirstate(input_map), None); let new = DirsMultiset::new(Dirstate(&input_map), None);
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
#[test] #[test]
fn test_dirsmultiset_new_skip() { fn test_dirsmultiset_new_skip() {
use DirsIterable::{Dirstate, Manifest}; use DirsIterable::{Dirstate, Manifest};
let input_vec = ["a/", "b/", "a/c", "a/d/"] let input_vec = ["a/", "b/", "a/c", "a/d/"]
.iter() .iter()
.map(|e| e.as_bytes().to_vec()) .map(|e| e.as_bytes().to_vec())
.collect(); .collect();
let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (k.as_bytes().to_vec(), *v)) .map(|(k, v)| (k.as_bytes().to_vec(), *v))
.collect(); .collect();
let new = DirsMultiset::new(Manifest(input_vec), Some('n' as i8)); let new = DirsMultiset::new(Manifest(&input_vec), Some('n' as i8));
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
// Skip does not affect a manifest // Skip does not affect a manifest
assert_eq!(expected, new); assert_eq!(expected, new);
let input_map = let input_map =
[("a/", 'n'), ("a/b/", 'n'), ("a/c", 'r'), ("a/d/", 'm')] [("a/", 'n'), ("a/b/", 'n'), ("a/c", 'r'), ("a/d/", 'm')]
.collect(); .collect();
// "a" incremented with "a/c" and "a/d/" // "a" incremented with "a/c" and "a/d/"
let expected_inner = [("", 1), ("a", 2), ("a/d", 1)] let expected_inner = [("", 1), ("a", 2), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (k.as_bytes().to_vec(), *v)) .map(|(k, v)| (k.as_bytes().to_vec(), *v))
.collect(); .collect();
let new = DirsMultiset::new(Dirstate(input_map), Some('n' as i8)); let new = DirsMultiset::new(Dirstate(&input_map), Some('n' as i8));
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
} }

rust/hg-core/src/dirstate/parsers.rs

// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::{ use crate::{
CopyVec, CopyVecEntry, DirstateEntry, DirstatePackError, DirstateParents, dirstate::{CopyMap, StateMap},
DirstateParseError, DirstateVec, utils::copy_into_array,
DirstateEntry, DirstatePackError, DirstateParents, DirstateParseError,
}; };
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use std::collections::HashMap; use std::convert::TryInto;
use std::io::Cursor; use std::io::Cursor;
use std::time::Duration;
/// Parents are stored in the dirstate as byte hashes. /// Parents are stored in the dirstate as byte hashes.
const PARENT_SIZE: usize = 20; pub const PARENT_SIZE: usize = 20;
/// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits. /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits.
const MIN_ENTRY_SIZE: usize = 17; const MIN_ENTRY_SIZE: usize = 17;
// TODO parse/pack: is mutate-on-loop better for performance?
pub fn parse_dirstate( pub fn parse_dirstate(
state_map: &mut StateMap,
copy_map: &mut CopyMap,
contents: &[u8], contents: &[u8],
) -> Result<(DirstateParents, DirstateVec, CopyVec), DirstateParseError> { ) -> Result<DirstateParents, DirstateParseError> {
if contents.len() < PARENT_SIZE * 2 { if contents.len() < PARENT_SIZE * 2 {
return Err(DirstateParseError::TooLittleData); return Err(DirstateParseError::TooLittleData);
} }
let mut dirstate_vec = vec![];
let mut copies = vec![];
let mut curr_pos = PARENT_SIZE * 2; let mut curr_pos = PARENT_SIZE * 2;
let parents = DirstateParents { let parents = DirstateParents {
p1: &contents[..PARENT_SIZE], p1: copy_into_array(&contents[..PARENT_SIZE]),
p2: &contents[PARENT_SIZE..curr_pos], p2: copy_into_array(&contents[PARENT_SIZE..curr_pos]),
}; };
while curr_pos < contents.len() { while curr_pos < contents.len() {
if curr_pos + MIN_ENTRY_SIZE > contents.len() { if curr_pos + MIN_ENTRY_SIZE > contents.len() {
return Err(DirstateParseError::Overflow); return Err(DirstateParseError::Overflow);
} }
let entry_bytes = &contents[curr_pos..]; let entry_bytes = &contents[curr_pos..];
let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)]; let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)];
let (path, copy) = match memchr::memchr(0, path) { let (path, copy) = match memchr::memchr(0, path) {
None => (path, None), None => (path, None),
Some(i) => (&path[..i], Some(&path[(i + 1)..])), Some(i) => (&path[..i], Some(&path[(i + 1)..])),
}; };
if let Some(copy_path) = copy { if let Some(copy_path) = copy {
copies.push(CopyVecEntry { path, copy_path }); copy_map.insert(path.to_owned(), copy_path.to_owned());
}; };
dirstate_vec.push(( state_map.insert(
path.to_owned(), path.to_owned(),
DirstateEntry { DirstateEntry {
state, state,
mode, mode,
size, size,
mtime, mtime,
}, },
)); );
curr_pos = curr_pos + MIN_ENTRY_SIZE + (path_len); curr_pos = curr_pos + MIN_ENTRY_SIZE + (path_len);
} }
Ok((parents, dirstate_vec, copies)) Ok(parents)
} }
/// `now` is the duration in seconds since the Unix epoch
pub fn pack_dirstate( pub fn pack_dirstate(
dirstate_vec: &DirstateVec, state_map: &mut StateMap,
copymap: &HashMap<Vec<u8>, Vec<u8>>, copy_map: &CopyMap,
parents: DirstateParents, parents: DirstateParents,
now: i32, now: Duration,
kevincoxUnsubmitted
Done

The "proper" solution is SystemTime however I will admit that it is a bit more awkward to use. However if you are going to use Duration please document that it is the Duration since the Unix Epoch.

kevincox: The "proper" solution is [SystemTime](https://doc.rust-lang.org/std/time/struct.SystemTime.
) -> Result<(Vec<u8>, DirstateVec), DirstatePackError> { ) -> Result<Vec<u8>, DirstatePackError> {
if parents.p1.len() != PARENT_SIZE || parents.p2.len() != PARENT_SIZE { // TODO move away from i32 before 2038.
return Err(DirstatePackError::CorruptedParent); let now: i32 = now.as_secs().try_into().expect("time overflow");
}
let expected_size: usize = dirstate_vec let expected_size: usize = state_map
kevincoxUnsubmitted
Done

Would it be best to panic on overflow? now.as_secs().try_into::<i32>().expect("time overflow").

kevincox: Would it be best to panic on overflow? `now.as_secs().try_into::<i32>().expect("time…
.iter() .iter()
.map(|(ref filename, _)| { .map(|(filename, _)| {
let mut length = MIN_ENTRY_SIZE + filename.len(); let mut length = MIN_ENTRY_SIZE + filename.len();
if let Some(ref copy) = copymap.get(filename) { if let Some(ref copy) = copy_map.get(filename) {
length += copy.len() + 1; length += copy.len() + 1;
} }
length length
}) })
.sum(); .sum();
let expected_size = expected_size + PARENT_SIZE * 2; let expected_size = expected_size + PARENT_SIZE * 2;
let mut packed = Vec::with_capacity(expected_size); let mut packed = Vec::with_capacity(expected_size);
let mut new_dirstate_vec = vec![]; let mut new_state_map = vec![];
packed.extend(parents.p1); packed.extend(&parents.p1);
packed.extend(parents.p2); packed.extend(&parents.p2);
for (ref filename, entry) in dirstate_vec { for (ref filename, entry) in state_map.iter() {
let mut new_filename: Vec<u8> = filename.to_owned(); let mut new_filename: Vec<u8> = filename.to_vec();
let mut new_mtime: i32 = entry.mtime; let mut new_mtime: i32 = entry.mtime;
if entry.state == 'n' as i8 && entry.mtime == now.into() { if entry.state == 'n' as i8 && entry.mtime == now.into() {
// The file was last modified "simultaneously" with the current // The file was last modified "simultaneously" with the current
// write to dirstate (i.e. within the same second for file- // write to dirstate (i.e. within the same second for file-
// systems with a granularity of 1 sec). This commonly happens // systems with a granularity of 1 sec). This commonly happens
// for at least a couple of files on 'update'. // for at least a couple of files on 'update'.
// The user could change the file without changing its size // The user could change the file without changing its size
// within the same second. Invalidate the file's mtime in // within the same second. Invalidate the file's mtime in
// dirstate, forcing future 'status' calls to compare the // dirstate, forcing future 'status' calls to compare the
// contents of the file if the size is the same. This prevents // contents of the file if the size is the same. This prevents
// mistakenly treating such files as clean. // mistakenly treating such files as clean.
new_mtime = -1; new_mtime = -1;
new_dirstate_vec.push(( new_state_map.push((
filename.to_owned(), filename.to_owned().to_vec(),
DirstateEntry { DirstateEntry {
mtime: new_mtime, mtime: new_mtime,
..*entry ..*entry
}, },
)); ));
} }
if let Some(copy) = copymap.get(filename) { if let Some(copy) = copy_map.get(*filename) {
new_filename.push('\0' as u8); new_filename.push('\0' as u8);
new_filename.extend(copy); new_filename.extend(copy);
} }
packed.write_i8(entry.state)?; packed.write_i8(entry.state)?;
packed.write_i32::<BigEndian>(entry.mode)?; packed.write_i32::<BigEndian>(entry.mode)?;
packed.write_i32::<BigEndian>(entry.size)?; packed.write_i32::<BigEndian>(entry.size)?;
packed.write_i32::<BigEndian>(new_mtime)?; packed.write_i32::<BigEndian>(new_mtime)?;
packed.write_i32::<BigEndian>(new_filename.len() as i32)?; packed.write_i32::<BigEndian>(new_filename.len() as i32)?;
packed.extend(new_filename) packed.extend(new_filename)
} }
if packed.len() != expected_size { if packed.len() != expected_size {
return Err(DirstatePackError::BadSize(expected_size, packed.len())); return Err(DirstatePackError::BadSize(expected_size, packed.len()));
} }
Ok((packed, new_dirstate_vec)) state_map.extend(new_state_map);
}
Ok(packed)
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use std::collections::HashMap;
#[test] #[test]
fn test_pack_dirstate_empty() { fn test_pack_dirstate_empty() {
let dirstate_vec: DirstateVec = vec![]; let mut state_map: StateMap = HashMap::new();
let copymap = HashMap::new(); let copymap = HashMap::new();
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let expected = let expected = b"1234567891011121314100000000000000000000".to_vec();
(b"1234567891011121314100000000000000000000".to_vec(), vec![]);
assert_eq!( assert_eq!(
expected, expected,
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap() pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
); );
assert!(state_map.is_empty())
} }
#[test] #[test]
fn test_pack_dirstate_one_entry() { fn test_pack_dirstate_one_entry() {
let dirstate_vec: DirstateVec = vec![( let expected_state_map: StateMap = [(
vec!['f' as u8, '1' as u8], b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: 791231220, mtime: 791231220,
}, },
)]; )]
.iter()
.cloned()
.collect();
let mut state_map = expected_state_map.clone();
let copymap = HashMap::new(); let copymap = HashMap::new();
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let expected = ( let expected = [
[ 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
49, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 41, 58, 244, 0, 0, 0, 2, 102, 49,
0, 0, 0, 47, 41, 58, 244, 0, 0, 0, 2, 102, 49,
] ]
.to_vec(), .to_vec();
vec![],
);
assert_eq!( assert_eq!(
expected, expected,
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap() pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
); );
assert_eq!(expected_state_map, state_map);
} }
#[test] #[test]
fn test_pack_dirstate_one_entry_with_copy() { fn test_pack_dirstate_one_entry_with_copy() {
let dirstate_vec: DirstateVec = vec![( let expected_state_map: StateMap = [(
b"f1".to_vec(), b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: 791231220, mtime: 791231220,
}, },
)]; )]
.iter()
.cloned()
.collect();
let mut state_map = expected_state_map.clone();
let mut copymap = HashMap::new(); let mut copymap = HashMap::new();
copymap.insert(b"f1".to_vec(), b"copyname".to_vec()); copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let expected = ( let expected = [
[ 49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
49, 51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 112, 121, 110, 97,
0, 0, 0, 47, 41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 109, 101,
112, 121, 110, 97, 109, 101,
] ]
.to_vec(), .to_vec();
vec![],
);
assert_eq!( assert_eq!(
expected, expected,
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap() pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
); );
assert_eq!(expected_state_map, state_map);
} }
#[test] #[test]
fn test_parse_pack_one_entry_with_copy() { fn test_parse_pack_one_entry_with_copy() {
let dirstate_vec: DirstateVec = vec![( let mut state_map: StateMap = [(
b"f1".to_vec(), b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: 791231220, mtime: 791231220,
}, },
)]; )]
.iter()
.cloned()
.collect();
let mut copymap = HashMap::new(); let mut copymap = HashMap::new();
copymap.insert(b"f1".to_vec(), b"copyname".to_vec()); copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let result = let result =
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap(); pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap();
let mut new_state_map: StateMap = HashMap::new();
let mut new_copy_map: CopyMap = HashMap::new();
let new_parents = parse_dirstate(
&mut new_state_map,
&mut new_copy_map,
result.as_slice(),
)
.unwrap();
assert_eq!( assert_eq!(
( (parents, state_map, copymap),
parents, (new_parents, new_state_map, new_copy_map)
dirstate_vec,
copymap
.iter()
.map(|(k, v)| CopyVecEntry {
path: k.as_slice(),
copy_path: v.as_slice()
})
.collect()
),
parse_dirstate(result.0.as_slice()).unwrap()
) )
} }
#[test] #[test]
fn test_parse_pack_multiple_entries_with_copy() { fn test_parse_pack_multiple_entries_with_copy() {
let dirstate_vec: DirstateVec = vec![ let mut state_map: StateMap = [
( (
b"f1".to_vec(), b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: 791231220, mtime: 791231220,
}, },
b"f4\xF6".to_vec(), b"f4\xF6".to_vec(),
DirstateEntry { DirstateEntry {
state: 'a' as i8, state: 'a' as i8,
mode: 0o644, mode: 0o644,
size: -1, size: -1,
mtime: -1, mtime: -1,
}, },
), ),
]; ]
.iter()
.cloned()
.collect();
let mut copymap = HashMap::new(); let mut copymap = HashMap::new();
copymap.insert(b"f1".to_vec(), b"copyname".to_vec()); copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
copymap.insert(b"f4\xF6".to_vec(), b"copyname2".to_vec()); copymap.insert(b"f4\xF6".to_vec(), b"copyname2".to_vec());
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let result = let result =
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap(); pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap();
let mut new_state_map: StateMap = HashMap::new();
let mut new_copy_map: CopyMap = HashMap::new();
let new_parents = parse_dirstate(
&mut new_state_map,
&mut new_copy_map,
result.as_slice(),
)
.unwrap();
assert_eq!( assert_eq!(
(parents, dirstate_vec, copymap), (parents, state_map, copymap),
parse_dirstate(result.0.as_slice()) (new_parents, new_state_map, new_copy_map)
.and_then(|(p, dvec, cvec)| Ok((
p,
dvec,
cvec.iter()
.map(|entry| (
entry.path.to_vec(),
entry.copy_path.to_vec()
))
.collect()
)))
.unwrap()
) )
} }
#[test] #[test]
/// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4 /// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4
fn test_parse_pack_one_entry_with_copy_and_time_conflict() { fn test_parse_pack_one_entry_with_copy_and_time_conflict() {
let dirstate_vec: DirstateVec = vec![( let mut state_map: StateMap = [(
b"f1".to_vec(), b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: 15000000, mtime: 15000000,
}, },
)]; )]
.iter()
.cloned()
.collect();
let mut copymap = HashMap::new(); let mut copymap = HashMap::new();
copymap.insert(b"f1".to_vec(), b"copyname".to_vec()); copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
let parents = DirstateParents { let parents = DirstateParents {
p1: b"12345678910111213141", p1: *b"12345678910111213141",
p2: b"00000000000000000000", p2: *b"00000000000000000000",
}; };
let now: i32 = 15000000; let now = Duration::new(15000000, 0);
let result = let result =
pack_dirstate(&dirstate_vec, &copymap, parents, now).unwrap(); pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
.unwrap();
let mut new_state_map: StateMap = HashMap::new();
let mut new_copy_map: CopyMap = HashMap::new();
let new_parents = parse_dirstate(
&mut new_state_map,
&mut new_copy_map,
result.as_slice(),
)
.unwrap();
assert_eq!( assert_eq!(
( (
parents, parents,
vec![( [(
b"f1".to_vec(), b"f1".to_vec(),
DirstateEntry { DirstateEntry {
state: 'n' as i8, state: 'n' as i8,
mode: 0o644, mode: 0o644,
size: 0, size: 0,
mtime: -1 mtime: -1
} }
)], )]
copymap
.iter() .iter()
.map(|(k, v)| CopyVecEntry { .cloned()
path: k.as_slice(), .collect::<StateMap>(),
copy_path: v.as_slice() copymap,
})
.collect()
), ),
parse_dirstate(result.0.as_slice()).unwrap() (new_parents, new_state_map, new_copy_map)
) )
} }
} }

rust/hg-core/src/lib.rs

// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
mod ancestors; mod ancestors;
pub mod dagops; pub mod dagops;
pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors}; pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
mod dirstate; mod dirstate;
pub mod discovery; pub mod discovery;
pub mod testing; // unconditionally built, for use from integration tests pub mod testing; // unconditionally built, for use from integration tests
pub use dirstate::{ pub use dirstate::{
dirs_multiset::DirsMultiset, dirs_multiset::DirsMultiset,
parsers::{pack_dirstate, parse_dirstate}, parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
CopyVec, CopyVecEntry, DirsIterable, DirstateEntry, DirstateParents, CopyMap, DirsIterable, DirstateEntry, DirstateParents, StateMap,
DirstateVec,
}; };
mod filepatterns; mod filepatterns;
pub mod utils; pub mod utils;
pub use filepatterns::{ pub use filepatterns::{
build_single_regex, read_pattern_file, PatternSyntax, PatternTuple, build_single_regex, read_pattern_file, PatternSyntax, PatternTuple,
}; };
WorkingDirectoryUnsupported, WorkingDirectoryUnsupported,
} }
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum DirstateParseError { pub enum DirstateParseError {
TooLittleData, TooLittleData,
Overflow, Overflow,
CorruptedEntry(String), CorruptedEntry(String),
Damaged,
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum DirstatePackError { pub enum DirstatePackError {
CorruptedEntry(String), CorruptedEntry(String),
CorruptedParent, CorruptedParent,
BadSize(usize, usize), BadSize(usize, usize),
} }

rust/hg-core/src/utils.rs

pub mod files; pub mod files;
use std::convert::AsMut;
/// Takes a slice and copies it into an array.
///
/// # Panics
///
/// Will panic if the slice and target array don't have the same length.
pub fn copy_into_array<A, T>(slice: &[T]) -> A
where
A: Sized + Default + AsMut<[T]>,
T: Copy,
{
let mut a = Default::default();
<A as AsMut<[T]>>::as_mut(&mut a).copy_from_slice(slice);
a
}
/// Replaces the `from` slice with the `to` slice inside the `buf` slice. /// Replaces the `from` slice with the `to` slice inside the `buf` slice.
/// ///
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// use crate::hg::utils::replace_slice; /// use crate::hg::utils::replace_slice;
/// let mut line = b"I hate writing tests!".to_vec(); /// let mut line = b"I hate writing tests!".to_vec();
/// replace_slice(&mut line, b"hate", b"love"); /// replace_slice(&mut line, b"hate", b"love");

rust/hg-cpython/src/dirstate.rs

// dirstate.rs // dirstate.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate` module provided by the //! Bindings for the `hg::dirstate` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dirstate` //! From Python, this will be seen as `mercurial.rustext.dirstate`
mod dirs_multiset; mod dirs_multiset;
use crate::dirstate::dirs_multiset::Dirs; use crate::dirstate::dirs_multiset::Dirs;
use cpython::{ use cpython::{
PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence, Python, PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence, Python,
}; };
use hg::{DirstateEntry, DirstateVec}; use hg::{DirstateEntry, StateMap};
use libc::{c_char, c_int}; use libc::{c_char, c_int};
#[cfg(feature = "python27")] #[cfg(feature = "python27")]
use python27_sys::PyCapsule_Import; use python27_sys::PyCapsule_Import;
#[cfg(feature = "python3")] #[cfg(feature = "python3")]
use python3_sys::PyCapsule_Import; use python3_sys::PyCapsule_Import;
use std::ffi::CStr; use std::ffi::CStr;
use std::mem::transmute; use std::mem::transmute;
let from_caps = PyCapsule_Import(caps_name.as_ptr(), 0); let from_caps = PyCapsule_Import(caps_name.as_ptr(), 0);
if from_caps.is_null() { if from_caps.is_null() {
return Err(PyErr::fetch(py)); return Err(PyErr::fetch(py));
} }
Ok(transmute(from_caps)) Ok(transmute(from_caps))
} }
} }
pub fn extract_dirstate_vec( pub fn extract_dirstate(py: Python, dmap: &PyDict) -> Result<StateMap, PyErr> {
py: Python,
dmap: &PyDict,
) -> Result<DirstateVec, PyErr> {
dmap.items(py) dmap.items(py)
.iter() .iter()
.map(|(filename, stats)| { .map(|(filename, stats)| {
let stats = stats.extract::<PySequence>(py)?; let stats = stats.extract::<PySequence>(py)?;
let state = stats.get_item(py, 0)?.extract::<PyBytes>(py)?; let state = stats.get_item(py, 0)?.extract::<PyBytes>(py)?;
let state = state.data(py)[0] as i8; let state = state.data(py)[0] as i8;
let mode = stats.get_item(py, 1)?.extract(py)?; let mode = stats.get_item(py, 1)?.extract(py)?;
let size = stats.get_item(py, 2)?.extract(py)?; let size = stats.get_item(py, 2)?.extract(py)?;

rust/hg-cpython/src/dirstate/dirs_multiset.rs

use std::cell::RefCell; use std::cell::RefCell;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyObject, PyResult, exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyObject, PyResult,
ToPyObject, ToPyObject,
}; };
use crate::dirstate::extract_dirstate_vec; use crate::dirstate::extract_dirstate;
use hg::{DirsIterable, DirsMultiset, DirstateMapError}; use hg::{DirsIterable, DirsMultiset, DirstateMapError};
py_class!(pub class Dirs |py| { py_class!(pub class Dirs |py| {
data dirs_map: RefCell<DirsMultiset>; data dirs_map: RefCell<DirsMultiset>;
// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
// a `list`) // a `list`)
def __new__( def __new__(
_cls, _cls,
map: PyObject, map: PyObject,
skip: Option<PyObject> = None skip: Option<PyObject> = None
) -> PyResult<Self> { ) -> PyResult<Self> {
let mut skip_state: Option<i8> = None; let mut skip_state: Option<i8> = None;
if let Some(skip) = skip { if let Some(skip) = skip {
skip_state = Some(skip.extract::<PyBytes>(py)?.data(py)[0] as i8); skip_state = Some(skip.extract::<PyBytes>(py)?.data(py)[0] as i8);
} }
let dirs_map; let inner = if let Ok(map) = map.cast_as::<PyDict>(py) {
let dirstate = extract_dirstate(py, &map)?;
if let Ok(map) = map.cast_as::<PyDict>(py) { DirsMultiset::new(
let dirstate_vec = extract_dirstate_vec(py, &map)?; DirsIterable::Dirstate(&dirstate),
dirs_map = DirsMultiset::new(
DirsIterable::Dirstate(dirstate_vec),
skip_state, skip_state,
) )
} else { } else {
let map: Result<Vec<Vec<u8>>, PyErr> = map let map: Result<Vec<Vec<u8>>, PyErr> = map
.iter(py)? .iter(py)?
.map(|o| Ok(o?.extract::<PyBytes>(py)?.data(py).to_owned())) .map(|o| Ok(o?.extract::<PyBytes>(py)?.data(py).to_owned()))
.collect(); .collect();
dirs_map = DirsMultiset::new( DirsMultiset::new(
DirsIterable::Manifest(map?), DirsIterable::Manifest(&map?),
skip_state, skip_state,
) )
} };
Self::create_instance(py, RefCell::new(dirs_map)) Self::create_instance(py, RefCell::new(inner))
} }
def addpath(&self, path: PyObject) -> PyResult<PyObject> { def addpath(&self, path: PyObject) -> PyResult<PyObject> {
self.dirs_map(py).borrow_mut().add_path( self.dirs_map(py).borrow_mut().add_path(
path.extract::<PyBytes>(py)?.data(py), path.extract::<PyBytes>(py)?.data(py),
); );
Ok(py.None()) Ok(py.None())
} }

rust/hg-cpython/src/parsers.rs

// parsers.rs // parsers.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::parsers` module provided by the //! Bindings for the `hg::dirstate::parsers` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.parsers` //! From Python, this will be seen as `mercurial.rustext.parsers`
//! //!
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python, exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
PythonObject, ToPyObject, ToPyObject,
}; };
use hg::{ use hg::{
pack_dirstate, parse_dirstate, CopyVecEntry, DirstateEntry, pack_dirstate, parse_dirstate, utils::copy_into_array, DirstateEntry,
DirstatePackError, DirstateParents, DirstateParseError, DirstatePackError, DirstateParents, DirstateParseError, PARENT_SIZE,
}; };
use std::collections::HashMap; use std::collections::HashMap;
use libc::c_char; use libc::c_char;
use crate::dirstate::{decapsule_make_dirstate_tuple, extract_dirstate_vec}; use crate::dirstate::{decapsule_make_dirstate_tuple, extract_dirstate};
use std::time::Duration;
fn parse_dirstate_wrapper( fn parse_dirstate_wrapper(
py: Python, py: Python,
dmap: PyDict, dmap: PyDict,
copymap: PyDict, copymap: PyDict,
st: PyBytes, st: PyBytes,
) -> PyResult<PyTuple> { ) -> PyResult<PyTuple> {
match parse_dirstate(st.data(py)) { let mut dirstate_map = HashMap::new();
Ok((parents, dirstate_vec, copies)) => { let mut copies = HashMap::new();
for (filename, entry) in dirstate_vec {
match parse_dirstate(&mut dirstate_map, &mut copies, st.data(py)) {
Ok(parents) => {
for (filename, entry) in dirstate_map {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, &filename[..]), PyBytes::new(py, &filename),
decapsule_make_dirstate_tuple(py)?( decapsule_make_dirstate_tuple(py)?(
entry.state as c_char, entry.state as c_char,
entry.mode, entry.mode,
entry.size, entry.size,
entry.mtime, entry.mtime,
), ),
)?; )?;
} }
for CopyVecEntry { path, copy_path } in copies { for (path, copy_path) in copies {
copymap.set_item( copymap.set_item(
py, py,
PyBytes::new(py, path), PyBytes::new(py, &path),
PyBytes::new(py, copy_path), PyBytes::new(py, &copy_path),
)?; )?;
} }
Ok((PyBytes::new(py, parents.p1), PyBytes::new(py, parents.p2)) Ok(
.to_py_object(py)) (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
.to_py_object(py),
)
} }
Err(e) => Err(PyErr::new::<exc::ValueError, _>( Err(e) => Err(PyErr::new::<exc::ValueError, _>(
py, py,
match e { match e {
DirstateParseError::TooLittleData => { DirstateParseError::TooLittleData => {
"too little data for parents".to_string() "too little data for parents".to_string()
} }
DirstateParseError::Overflow => { DirstateParseError::Overflow => {
"overflow in dirstate".to_string() "overflow in dirstate".to_string()
} }
DirstateParseError::CorruptedEntry(e) => e, DirstateParseError::CorruptedEntry(e) => e,
DirstateParseError::Damaged => {
"dirstate appears to be damaged".to_string()
}
}, },
)), )),
} }
} }
fn pack_dirstate_wrapper( fn pack_dirstate_wrapper(
py: Python, py: Python,
dmap: PyDict, dmap: PyDict,
copymap: PyDict, copymap: PyDict,
pl: PyTuple, pl: PyTuple,
now: PyInt, now: PyInt,
) -> PyResult<PyBytes> { ) -> PyResult<PyBytes> {
let p1 = pl.get_item(py, 0).extract::<PyBytes>(py)?; let p1 = pl.get_item(py, 0).extract::<PyBytes>(py)?;
let p1: &[u8] = p1.data(py); let p1: &[u8] = p1.data(py);
let p2 = pl.get_item(py, 1).extract::<PyBytes>(py)?; let p2 = pl.get_item(py, 1).extract::<PyBytes>(py)?;
let p2: &[u8] = p2.data(py); let p2: &[u8] = p2.data(py);
let dirstate_vec = extract_dirstate_vec(py, &dmap)?; let mut dirstate_map = extract_dirstate(py, &dmap)?;
let copies: Result<HashMap<Vec<u8>, Vec<u8>>, PyErr> = copymap let copies: Result<HashMap<Vec<u8>, Vec<u8>>, PyErr> = copymap
.items(py) .items(py)
.iter() .iter()
.map(|(key, value)| { .map(|(key, value)| {
Ok(( Ok((
key.extract::<PyBytes>(py)?.data(py).to_owned(), key.extract::<PyBytes>(py)?.data(py).to_owned(),
value.extract::<PyBytes>(py)?.data(py).to_owned(), value.extract::<PyBytes>(py)?.data(py).to_owned(),
)) ))
}) })
.collect(); .collect();
if p1.len() != PARENT_SIZE || p2.len() != PARENT_SIZE {
return Err(PyErr::new::<exc::ValueError, _>(
py,
"expected a 20-byte hash".to_string(),
));
}
match pack_dirstate( match pack_dirstate(
&dirstate_vec, &mut dirstate_map,
&copies?, &copies?,
DirstateParents { p1, p2 }, DirstateParents {
now.as_object().extract::<i32>(py)?, p1: copy_into_array(&p1),
p2: copy_into_array(&p2),
},
Duration::from_secs(now.value(py) as u64),
) { ) {
Ok((packed, new_dirstate_vec)) => { Ok(packed) => {
for ( for (
filename, filename,
DirstateEntry { DirstateEntry {
state, state,
mode, mode,
size, size,
mtime, mtime,
}, },
) in new_dirstate_vec ) in dirstate_map
{ {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, &filename[..]), PyBytes::new(py, &filename[..]),
decapsule_make_dirstate_tuple(py)?( decapsule_make_dirstate_tuple(py)?(
state as c_char, state as c_char,
mode, mode,
size, size,