( )⚙ D11461 rust: Make the fields of DirstateEntry private

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11461

rust: Make the fields of DirstateEntry private
ClosedPublic

Authored by SimonSapin on Sep 20 2021, 6:16 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private
Summary

This is a first step toward making its internal structure equivalent to
Python’s DirstateItem.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Sep 20 2021, 6:16 PM
Alphare accepted this revision.Sep 22 2021, 4:04 AM
This revision is now accepted and ready to land.Sep 22 2021, 4:04 AM
SimonSapin added a commit: rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private.Sep 22 2021, 4:54 AM
Closed by commit rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30335

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

let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
for item in dirstate { for item in dirstate {
let (filename, entry) = item?; let (filename, entry) = item?;
let filename = filename.as_ref(); let filename = filename.as_ref();
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if only_tracked { if only_tracked {
if entry.state != EntryState::Removed { if entry.state() != EntryState::Removed {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} else { } else {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} }
Ok(multiset) Ok(multiset)
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| { let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| {
Ok(( Ok((
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Normal, 0, 0, 0),
state: EntryState::Normal,
mode: 0,
mtime: 0,
size: 0,
},
)) ))
}); });
let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, false).unwrap(); let new = DirsMultiset::from_dirstate(input_map, false).unwrap();
("a/b", EntryState::Normal), ("a/b", EntryState::Normal),
("a/c", EntryState::Removed), ("a/c", EntryState::Removed),
("a/d", EntryState::Merged), ("a/d", EntryState::Merged),
] ]
.iter() .iter()
.map(|(f, state)| { .map(|(f, state)| {
Ok(( Ok((
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry::from_v1_data(*state, 0, 0, 0),
state: *state,
mode: 0,
mtime: 0,
size: 0,
},
)) ))
}); });
// "a" incremented with "a/c" and "a/d/" // "a" incremented with "a/c" and "a/d/"
let expected_inner = [("", 1), ("a", 3)] let expected_inner = [("", 1), ("a", 3)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, true).unwrap(); let new = DirsMultiset::from_dirstate(input_map, true).unwrap();
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/dirstate_map.rs

filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
// XXX once the dust settle this should probably become an enum // XXX once the dust settle this should probably become an enum
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let state;
let size;
let mtime;
if added { if added {
assert!(!merged);
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Added; state = EntryState::Added;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if merged { } else if merged {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Merged; state = EntryState::Merged;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else { } else {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = entry.size & V1_RANGEMASK; size = entry.size() & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; mtime = entry.mtime() & V1_RANGEMASK;
} }
let mode = entry.mode();
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
let old_state = match self.get(filename) { let old_state = match self.get(filename) {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
if old_state == EntryState::Unknown || old_state == EntryState::Removed if old_state == EntryState::Unknown || old_state == EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.add_path(filename)?; dirs.add_path(filename)?;
} }
} }
/// to be more explicit about what that state is. /// to be more explicit about what that state is.
pub fn remove_file( pub fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_entry_opt = self.get(filename); let old_entry_opt = self.get(filename);
let old_state = match old_entry_opt { let old_state = match old_entry_opt {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let mut size = 0; let mut size = 0;
if in_merge { if in_merge {
// XXX we should not be able to have 'm' state and 'FROM_P2' if not // XXX we should not be able to have 'm' state and 'FROM_P2' if not
// during a merge. So I (marmoute) am not sure we need the // during a merge. So I (marmoute) am not sure we need the
// conditionnal at all. Adding double checking this with assert // conditionnal at all. Adding double checking this with assert
// would be nice. // would be nice.
if let Some(old_entry) = old_entry_opt { if let Some(old_entry) = old_entry_opt {
// backup the previous state // backup the previous state
if old_entry.state == EntryState::Merged { if old_entry.state() == EntryState::Merged {
size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
} else if old_entry.state == EntryState::Normal } else if old_entry.state() == EntryState::Normal
&& old_entry.size == SIZE_FROM_OTHER_PARENT && old_entry.size() == SIZE_FROM_OTHER_PARENT
{ {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.1 .1
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
} }
} }
if old_state != EntryState::Unknown && old_state != EntryState::Removed if old_state != EntryState::Unknown && old_state != EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
if size == 0 { if size == 0 {
self.copy_map.remove(filename); self.copy_map.remove(filename);
} }
self.state_map.insert( self.state_map
filename.to_owned(), .insert(filename.to_owned(), DirstateEntry::new_removed(size));
DirstateEntry {
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
},
);
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
Ok(()) Ok(())
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_file( pub fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
let old_state = match self.get(filename) { let old_state = match self.get(filename) {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let exists = self.state_map.remove(filename).is_some(); let exists = self.state_map.remove(filename).is_some();
if exists { if exists {
if old_state != EntryState::Removed { if old_state != EntryState::Removed {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
#[test] #[test]
fn test_add_file() { fn test_add_file() {
let mut map = DirstateMap::new(); let mut map = DirstateMap::new();
assert_eq!(0, map.len()); assert_eq!(0, map.len());
map.add_file( map.add_file(
HgPath::new(b"meh"), HgPath::new(b"meh"),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Normal, 1337, 1337, 1337),
state: EntryState::Normal,
mode: 1337,
mtime: 1337,
size: 1337,
},
false, false,
false, false,
false, false,
false, false,
) )
.unwrap(); .unwrap();
assert_eq!(1, map.len()); assert_eq!(1, map.len());
(b"f9", (EntryState::Merged, 1337, -2, 1337)), (b"f9", (EntryState::Merged, 1337, -2, 1337)),
(b"fa", (EntryState::Added, 1337, -2, 1337)), (b"fa", (EntryState::Added, 1337, -2, 1337)),
(b"fb", (EntryState::Removed, 1337, -2, 1337)), (b"fb", (EntryState::Removed, 1337, -2, 1337)),
] ]
.iter() .iter()
.map(|(fname, (state, mode, size, mtime))| { .map(|(fname, (state, mode, size, mtime))| {
( (
HgPathBuf::from_bytes(fname.as_ref()), HgPathBuf::from_bytes(fname.as_ref()),
DirstateEntry { DirstateEntry::from_v1_data(*state, *mode, *size, *mtime),
state: *state,
mode: *mode,
size: *size,
mtime: *mtime,
},
) )
}) })
.collect(); .collect();
let mut non_normal = [ let mut non_normal = [
b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb", b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
] ]
.iter() .iter()

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

Unknown, Unknown,
} }
/// 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, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub state: EntryState, state: EntryState,
pub mode: i32, mode: i32,
pub mtime: i32, size: i32,
pub size: i32, mtime: i32,
} }
pub const V1_RANGEMASK: i32 = 0x7FFFFFFF; pub const V1_RANGEMASK: i32 = 0x7FFFFFFF;
pub const MTIME_UNSET: i32 = -1; pub const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
/// A special value used for internal representation of special case in /// A special value used for internal representation of special case in
/// dirstate v1 format. /// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1; pub const SIZE_NON_NORMAL: i32 = -1;
impl DirstateEntry { impl DirstateEntry {
pub fn from_v1_data(
state: EntryState,
mode: i32,
size: i32,
mtime: i32,
) -> Self {
Self {
state,
mode,
size,
mtime,
}
}
/// Creates a new entry in "removed" state.
///
/// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
/// `SIZE_FROM_OTHER_PARENT`
pub fn new_removed(size: i32) -> Self {
Self {
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
}
}
/// TODO: refactor `DirstateMap::add_file` to not take a `DirstateEntry`
/// parameter and remove this constructor
pub fn new_for_add_file(mode: i32, size: i32, mtime: i32) -> Self {
Self {
// XXX Arbitrary default value since the value is determined later
state: EntryState::Normal,
mode,
size,
mtime,
}
}
pub fn state(&self) -> EntryState {
self.state
}
pub fn mode(&self) -> i32 {
self.mode
}
pub fn size(&self) -> i32 {
self.size
}
pub fn mtime(&self) -> i32 {
self.mtime
}
/// Returns `(state, mode, size, mtime)` for the puprose of serialization
/// in the dirstate-v1 format.
///
/// This includes marker values such as `mtime == -1`. In the future we may
/// want to not represent these cases that way in memory, but serialization
/// will need to keep the same format.
pub fn v1_data(&self) -> (u8, i32, i32, i32) {
(self.state.into(), self.mode, self.size, self.mtime)
}
pub fn is_non_normal(&self) -> bool { pub fn is_non_normal(&self) -> bool {
self.state != EntryState::Normal || self.mtime == MTIME_UNSET self.state != EntryState::Normal || self.mtime == MTIME_UNSET
} }
pub fn is_from_other_parent(&self) -> bool { pub fn is_from_other_parent(&self) -> bool {
self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT
} }

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

entries.push((path, *entry)); entries.push((path, *entry));
Ok(()) Ok(())
})?; })?;
Ok((parents, entries, copies)) Ok((parents, entries, copies))
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
pub(super) struct RawEntry { struct RawEntry {
state: u8, state: u8,
mode: unaligned::I32Be, mode: unaligned::I32Be,
size: unaligned::I32Be, size: unaligned::I32Be,
mtime: unaligned::I32Be, mtime: unaligned::I32Be,
length: unaligned::I32Be, length: unaligned::I32Be,
} }
pub fn parse_dirstate_entries<'a>( pub fn parse_dirstate_entries<'a>(
mut contents: &'a [u8], mut contents: &'a [u8],
mut each_entry: impl FnMut( mut each_entry: impl FnMut(
&'a HgPath, &'a HgPath,
&DirstateEntry, &DirstateEntry,
Option<&'a HgPath>, Option<&'a HgPath>,
) -> Result<(), HgError>, ) -> Result<(), HgError>,
) -> Result<&'a DirstateParents, HgError> { ) -> Result<&'a DirstateParents, HgError> {
let (parents, rest) = DirstateParents::from_bytes(contents) let (parents, rest) = DirstateParents::from_bytes(contents)
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; .map_err(|_| HgError::corrupted("Too little data for dirstate."))?;
contents = rest; contents = rest;
while !contents.is_empty() { while !contents.is_empty() {
let (raw_entry, rest) = RawEntry::from_bytes(contents) let (raw_entry, rest) = RawEntry::from_bytes(contents)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
let entry = DirstateEntry { let entry = DirstateEntry::from_v1_data(
state: EntryState::try_from(raw_entry.state)?, EntryState::try_from(raw_entry.state)?,
mode: raw_entry.mode.get(), raw_entry.mode.get(),
mtime: raw_entry.mtime.get(), raw_entry.size.get(),
size: raw_entry.size.get(), raw_entry.mtime.get(),
}; );
let (paths, rest) = let (paths, rest) =
u8::slice_from_bytes(rest, raw_entry.length.get() as usize) u8::slice_from_bytes(rest, raw_entry.length.get() as usize)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
// `paths` is either a single path, or two paths separated by a NULL // `paths` is either a single path, or two paths separated by a NULL
// byte // byte
let mut iter = paths.splitn(2, |&byte| byte == b'\0'); let mut iter = paths.splitn(2, |&byte| byte == b'\0');
let path = HgPath::new( let path = HgPath::new(
pub fn pack_entry( pub fn pack_entry(
filename: &HgPath, filename: &HgPath,
entry: &DirstateEntry, entry: &DirstateEntry,
copy_source: Option<&HgPath>, copy_source: Option<&HgPath>,
packed: &mut Vec<u8>, packed: &mut Vec<u8>,
) { ) {
let length = packed_filename_and_copy_source_size(filename, copy_source); let length = packed_filename_and_copy_source_size(filename, copy_source);
let (state, mode, size, mtime) = entry.v1_data();
// Unwrapping because `impl std::io::Write for Vec<u8>` never errors // Unwrapping because `impl std::io::Write for Vec<u8>` never errors
packed.write_u8(entry.state.into()).unwrap(); packed.write_u8(state).unwrap();
packed.write_i32::<BigEndian>(entry.mode).unwrap(); packed.write_i32::<BigEndian>(mode).unwrap();
packed.write_i32::<BigEndian>(entry.size).unwrap(); packed.write_i32::<BigEndian>(size).unwrap();
packed.write_i32::<BigEndian>(entry.mtime).unwrap(); packed.write_i32::<BigEndian>(mtime).unwrap();
packed.write_i32::<BigEndian>(length as i32).unwrap(); packed.write_i32::<BigEndian>(length as i32).unwrap();
packed.extend(filename.as_bytes()); packed.extend(filename.as_bytes());
if let Some(source) = copy_source { if let Some(source) = copy_source {
packed.push(b'\0'); packed.push(b'\0');
packed.extend(source.as_bytes()); packed.extend(source.as_bytes());
} }
} }
); );
assert!(state_map.is_empty()) assert!(state_map.is_empty())
} }
#[test] #[test]
fn test_pack_dirstate_one_entry() { fn test_pack_dirstate_one_entry() {
let expected_state_map: StateMap = [( let expected_state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut state_map = expected_state_map.clone(); let mut state_map = expected_state_map.clone();
let copymap = FastHashMap::default(); let copymap = FastHashMap::default();
let parents = DirstateParents { let parents = DirstateParents {
); );
assert_eq!(expected_state_map, state_map); 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 expected_state_map: StateMap = [( let expected_state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut state_map = expected_state_map.clone(); let mut state_map = expected_state_map.clone();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
); );
assert_eq!(expected_state_map, state_map); 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 mut state_map: StateMap = [( let mut state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
) )
} }
#[test] #[test]
fn test_parse_pack_multiple_entries_with_copy() { fn test_parse_pack_multiple_entries_with_copy() {
let mut state_map: StateMap = [ let mut state_map: StateMap = [
( (
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f2"), HgPathBuf::from_bytes(b"f2"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Merged, EntryState::Merged,
mode: 0o777, 0o777,
size: 1000, 1000,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f3"), HgPathBuf::from_bytes(b"f3"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Removed, EntryState::Removed,
mode: 0o644, 0o644,
size: 234553, 234553,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f4\xF6"), HgPathBuf::from_bytes(b"f4\xF6"),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Added, 0o644, -1, -1),
state: EntryState::Added,
mode: 0o644,
size: -1,
mtime: -1,
},
), ),
] ]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
) )
} }
#[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 mut state_map: StateMap = [( let mut state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 15000000, 15000000,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
.map(|(path, copy)| (path.to_owned(), copy.to_owned())) .map(|(path, copy)| (path.to_owned(), copy.to_owned()))
.collect(); .collect();
assert_eq!( assert_eq!(
( (
&parents, &parents,
[( [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: -1 -1
} )
)] )]
.iter() .iter()
.cloned() .cloned()
.collect::<StateMap>(), .collect::<StateMap>(),
copymap, copymap,
), ),
(new_parents, new_state_map, new_copy_map) (new_parents, new_state_map, new_copy_map)
) )
} }
} }

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

/// The file corresponding to the dirstate entry was found on the filesystem. /// The file corresponding to the dirstate entry was found on the filesystem.
fn dispatch_found( fn dispatch_found(
filename: impl AsRef<HgPath>, filename: impl AsRef<HgPath>,
entry: DirstateEntry, entry: DirstateEntry,
metadata: HgMetadata, metadata: HgMetadata,
copy_map: &CopyMap, copy_map: &CopyMap,
options: StatusOptions, options: StatusOptions,
) -> Dispatch { ) -> Dispatch {
let DirstateEntry { match entry.state() {
state, EntryState::Normal => {
mode, let mode = entry.mode();
mtime, let size = entry.size();
size, let mtime = entry.mtime();
} = entry;
let HgMetadata { let HgMetadata {
st_mode, st_mode,
st_size, st_size,
st_mtime, st_mtime,
.. ..
} = metadata; } = metadata;
match state {
EntryState::Normal => {
let size_changed = mod_compare(size, st_size as i32); let size_changed = mod_compare(size, st_size as i32);
let mode_changed = let mode_changed =
(mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec; (mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec;
let metadata_changed = size >= 0 && (size_changed || mode_changed); let metadata_changed = size >= 0 && (size_changed || mode_changed);
let other_parent = size == SIZE_FROM_OTHER_PARENT; let other_parent = size == SIZE_FROM_OTHER_PARENT;
if metadata_changed if metadata_changed
|| other_parent || other_parent
)), )),
)) ))
}; };
} }
Err(_) => { Err(_) => {
if let Some(entry) = in_dmap { if let Some(entry) = in_dmap {
return Some(( return Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)); ));
} }
} }
}; };
None None
}) })
.partition(|(_, dispatch)| match dispatch { .partition(|(_, dispatch)| match dispatch {
Dispatch::Directory { .. } => true, Dispatch::Directory { .. } => true,
} }
} }
} else if let Some(entry) = entry_option { } else if let Some(entry) = entry_option {
// Used to be a file or a folder, now something else. // Used to be a file or a folder, now something else.
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&filename) || self.matcher.matches(&filename)
{ {
files_sender files_sender
.send((filename.to_owned(), dispatch_missing(entry.state))) .send((
filename.to_owned(),
dispatch_missing(entry.state()),
))
.unwrap(); .unwrap();
} }
} }
Ok(()) Ok(())
} }
/// A directory was found in the filesystem and needs to be traversed /// A directory was found in the filesystem and needs to be traversed
if let Some(entry) = entry_option { if let Some(entry) = entry_option {
// Used to be a file, is now a folder // Used to be a file, is now a folder
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&directory) || self.matcher.matches(&directory)
{ {
files_sender files_sender
.send(( .send((
directory.to_owned(), directory.to_owned(),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)) ))
.unwrap(); .unwrap();
} }
} }
// Do we need to traverse it? // Do we need to traverse it?
if !self.is_ignored(&directory) || self.options.list_ignored { if !self.is_ignored(&directory) || self.options.list_ignored {
self.traverse_dir( self.traverse_dir(
files_sender, files_sender,
.symlink_metadata(); .symlink_metadata();
match meta { match meta {
Ok(m) Ok(m)
if !(m.file_type().is_file() if !(m.file_type().is_file()
|| m.file_type().is_symlink()) => || m.file_type().is_symlink()) =>
{ {
( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
) )
} }
Ok(m) => ( Ok(m) => (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_found( dispatch_found(
filename, filename,
*entry, *entry,
HgMetadata::from_metadata(m), HgMetadata::from_metadata(m),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
), ),
), ),
Err(e) Err(e)
if e.kind() == ErrorKind::NotFound if e.kind() == ErrorKind::NotFound
|| e.raw_os_error() == Some(20) => || e.raw_os_error() == Some(20) =>
{ {
// Rust does not yet have an `ErrorKind` for // Rust does not yet have an `ErrorKind` for
// `NotADirectory` (errno 20) // `NotADirectory` (errno 20)
// It happens if the dirstate contains `foo/bar` // It happens if the dirstate contains `foo/bar`
// and foo is not a // and foo is not a
// directory // directory
( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
) )
} }
Err(e) => { Err(e) => {
(Cow::Borrowed(filename), dispatch_os_error(&e)) (Cow::Borrowed(filename), dispatch_os_error(&e))
} }
} }
}), }),
); );
filename, filename,
*entry, *entry,
metadata, metadata,
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
) )
} }
// File doesn't exist // File doesn't exist
Err(_) => dispatch_missing(entry.state), Err(_) => dispatch_missing(entry.state()),
}, },
)) ))
} else { } else {
// It's either missing or under a symlink directory which // It's either missing or under a symlink directory which
// we, in this case, report as missing. // we, in this case, report as missing.
Some(( Some((
Cow::Owned(filename.to_owned()), Cow::Owned(filename.to_owned()),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)) ))
} }
}, },
); );
results.par_extend(new_results); results.par_extend(new_results);
} }
} }

rust/hg-core/src/dirstate_tree/dirstate_map.rs

} }
} }
pub(super) fn state( pub(super) fn state(
&self, &self,
) -> Result<Option<EntryState>, DirstateV2ParseError> { ) -> Result<Option<EntryState>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
Ok(node.data.as_entry().map(|entry| entry.state)) Ok(node.data.as_entry().map(|entry| entry.state()))
} }
NodeRef::OnDisk(node) => node.state(), NodeRef::OnDisk(node) => node.state(),
} }
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Option<&'tree on_disk::Timestamp> { ) -> Option<&'tree on_disk::Timestamp> {
let mut map = Self::empty(on_disk); let mut map = Self::empty(on_disk);
if map.on_disk.is_empty() { if map.on_disk.is_empty() {
return Ok((map, None)); return Ok((map, None));
} }
let parents = parse_dirstate_entries( let parents = parse_dirstate_entries(
map.on_disk, map.on_disk,
|path, entry, copy_source| { |path, entry, copy_source| {
let tracked = entry.state.is_tracked(); let tracked = entry.state().is_tracked();
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
map.on_disk, map.on_disk,
&mut map.unreachable_bytes, &mut map.unreachable_bytes,
&mut map.root, &mut map.root,
path, path,
WithBasename::to_cow_borrowed, WithBasename::to_cow_borrowed,
|ancestor| { |ancestor| {
if tracked { if tracked {
fn add_or_remove_file( fn add_or_remove_file(
&mut self, &mut self,
path: &HgPath, path: &HgPath,
old_state: EntryState, old_state: EntryState,
new_entry: DirstateEntry, new_entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let had_entry = old_state != EntryState::Unknown; let had_entry = old_state != EntryState::Unknown;
let tracked_count_increment = let tracked_count_increment =
match (old_state.is_tracked(), new_entry.state.is_tracked()) { match (old_state.is_tracked(), new_entry.state().is_tracked()) {
(false, true) => 1, (false, true) => 1,
(true, false) => -1, (true, false) => -1,
_ => 0, _ => 0,
}; };
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
self.on_disk, self.on_disk,
&mut self.unreachable_bytes, &mut self.unreachable_bytes,
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let state;
let size;
let mtime;
if added { if added {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Added; state = EntryState::Added;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if merged { } else if merged {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Merged; state = EntryState::Merged;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else { } else {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = entry.size & V1_RANGEMASK; size = entry.size() & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; mtime = entry.mtime() & V1_RANGEMASK;
} }
let mode = entry.mode();
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
let old_state = match self.get(filename)? { let old_state = match self.get(filename)? {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(self.add_or_remove_file(filename, old_state, entry)?)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_entry_opt = self.get(filename)?; let old_entry_opt = self.get(filename)?;
let old_state = match old_entry_opt { let old_state = match old_entry_opt {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let mut size = 0; let mut size = 0;
if in_merge { if in_merge {
// XXX we should not be able to have 'm' state and 'FROM_P2' if not // XXX we should not be able to have 'm' state and 'FROM_P2' if not
// during a merge. So I (marmoute) am not sure we need the // during a merge. So I (marmoute) am not sure we need the
// conditionnal at all. Adding double checking this with assert // conditionnal at all. Adding double checking this with assert
// would be nice. // would be nice.
if let Some(old_entry) = old_entry_opt { if let Some(old_entry) = old_entry_opt {
// backup the previous state // backup the previous state
if old_entry.state == EntryState::Merged { if old_entry.state() == EntryState::Merged {
size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
} else if old_entry.state == EntryState::Normal } else if old_entry.state() == EntryState::Normal
&& old_entry.size == SIZE_FROM_OTHER_PARENT && old_entry.size() == SIZE_FROM_OTHER_PARENT
{ {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
} }
} }
} }
if size == 0 { if size == 0 {
self.copy_map_remove(filename)?; self.copy_map_remove(filename)?;
} }
let entry = DirstateEntry { let entry = DirstateEntry::new_removed(size);
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
};
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(self.add_or_remove_file(filename, old_state, entry)?)
} }
fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> { fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
let old_state = match self.get(filename)? { let old_state = match self.get(filename)? {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
struct Dropped { struct Dropped {
was_tracked: bool, was_tracked: bool,
had_entry: bool, had_entry: bool,
had_copy_source: bool, had_copy_source: bool,
} }
} }
if let Some(source) = &node.copy_source { if let Some(source) = &node.copy_source {
DirstateMap::count_dropped_path(unreachable_bytes, source) DirstateMap::count_dropped_path(unreachable_bytes, source)
} }
dropped = Dropped { dropped = Dropped {
was_tracked: node was_tracked: node
.data .data
.as_entry() .as_entry()
.map_or(false, |entry| entry.state.is_tracked()), .map_or(false, |entry| entry.state().is_tracked()),
had_entry, had_entry,
had_copy_source: node.copy_source.take().is_some(), had_copy_source: node.copy_source.take().is_some(),
}; };
} }
// After recursion, for both leaf (rest_of_path is None) nodes and // After recursion, for both leaf (rest_of_path is None) nodes and
// parent nodes, remove a node if it just became empty. // parent nodes, remove a node if it just became empty.
let remove = !node.data.has_entry() let remove = !node.data.has_entry()
&& node.copy_source.is_none() && node.copy_source.is_none()

rust/hg-core/src/dirstate_tree/on_disk.rs

b'a' => Ok(Some(EntryState::Added)), b'a' => Ok(Some(EntryState::Added)),
b'r' => Ok(Some(EntryState::Removed)), b'r' => Ok(Some(EntryState::Removed)),
b'm' => Ok(Some(EntryState::Merged)), b'm' => Ok(Some(EntryState::Merged)),
_ => Err(DirstateV2ParseError), _ => Err(DirstateV2ParseError),
} }
} }
fn entry_with_given_state(&self, state: EntryState) -> DirstateEntry { fn entry_with_given_state(&self, state: EntryState) -> DirstateEntry {
DirstateEntry { // For now, the on-disk representation of DirstateEntry in dirstate-v2
// format is equivalent to that of dirstate-v1. When that changes, add
// a new constructor.
DirstateEntry::from_v1_data(
state, state,
mode: self.data.mode.get(), self.data.mode.get(),
mtime: self.data.mtime.get(), self.data.size.get(),
size: self.data.size.get(), self.data.mtime.get(),
} )
} }
pub(super) fn entry( pub(super) fn entry(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok(self Ok(self
.state()? .state()?
.map(|state| self.entry_with_given_state(state))) .map(|state| self.entry_with_given_state(state)))
start: 0.into(), start: 0.into(),
len: 0.into(), len: 0.into(),
} }
}; };
on_disk_nodes.push(match node { on_disk_nodes.push(match node {
NodeRef::InMemory(path, node) => { NodeRef::InMemory(path, node) => {
let (state, data) = match &node.data { let (state, data) = match &node.data {
dirstate_map::NodeData::Entry(entry) => ( dirstate_map::NodeData::Entry(entry) => (
entry.state.into(), entry.state().into(),
Entry { Entry {
mode: entry.mode.into(), mode: entry.mode().into(),
mtime: entry.mtime.into(), mtime: entry.mtime().into(),
size: entry.size.into(), size: entry.size().into(),
}, },
), ),
dirstate_map::NodeData::CachedDirectory { mtime } => { dirstate_map::NodeData::CachedDirectory { mtime } => {
(b'd', Entry::from_timestamp(*mtime)) (b'd', Entry::from_timestamp(*mtime))
} }
dirstate_map::NodeData::None => ( dirstate_map::NodeData::None => (
b'\0', b'\0',
Entry { Entry {

rust/hg-core/src/dirstate_tree/status.rs

} }
let entry = dirstate_node let entry = dirstate_node
.entry()? .entry()?
.expect("handle_normal_file called with entry-less node"); .expect("handle_normal_file called with entry-less node");
let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?; let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
let mode_changed = let mode_changed =
|| self.options.check_exec && entry.mode_changed(fs_metadata); || self.options.check_exec && entry.mode_changed(fs_metadata);
let size_changed = entry.size != truncate_u64(fs_metadata.len()); let size = entry.size();
if entry.size >= 0 let size_changed = size != truncate_u64(fs_metadata.len());
&& size_changed if size >= 0 && size_changed && fs_metadata.file_type().is_symlink() {
&& fs_metadata.file_type().is_symlink()
{
// issue6456: Size returned may be longer due to encryption // issue6456: Size returned may be longer due to encryption
// on EXT-4 fscrypt. TODO maybe only do it on EXT4? // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.unsure .unsure
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else if dirstate_node.has_copy_source() } else if dirstate_node.has_copy_source()
|| entry.is_from_other_parent() || entry.is_from_other_parent()
|| (entry.size >= 0 && (size_changed || mode_changed())) || (size >= 0 && (size_changed || mode_changed()))
{ {
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.modified .modified
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else { } else {
let mtime = mtime_seconds(fs_metadata); let mtime = mtime_seconds(fs_metadata);
if truncate_i64(mtime) != entry.mtime if truncate_i64(mtime) != entry.mtime()
|| mtime == self.options.last_normal_time || mtime == self.options.last_normal_time
{ {
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.unsure .unsure
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else if self.options.list_clean { } else if self.options.list_clean {

rust/hg-core/src/operations/list_tracked_files.rs

if let Some(meta) = &self.v2_metadata { if let Some(meta) = &self.v2_metadata {
for_each_tracked_path(&self.content, meta, |path| { for_each_tracked_path(&self.content, meta, |path| {
files.push(path) files.push(path)
})? })?
} else { } else {
let _parents = parse_dirstate_entries( let _parents = parse_dirstate_entries(
&self.content, &self.content,
|path, entry, _copy_source| { |path, entry, _copy_source| {
if entry.state.is_tracked() { if entry.state().is_tracked() {
files.push(path) files.push(path)
} }
Ok(()) Ok(())
}, },
)?; )?;
} }
} }
files.par_sort_unstable(); files.par_sort_unstable();

rust/hg-cpython/src/dirstate.rs

mtime: c_int, mtime: c_int,
) -> *mut RawPyObject ) -> *mut RawPyObject
); );
pub fn make_dirstate_item( pub fn make_dirstate_item(
py: Python, py: Python,
entry: &DirstateEntry, entry: &DirstateEntry,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let &DirstateEntry {
state,
mode,
size,
mtime,
} = entry;
// Explicitly go through u8 first, then cast to platform-specific `c_char` // Explicitly go through u8 first, then cast to platform-specific `c_char`
// because Into<u8> has a specific implementation while `as c_char` would // because Into<u8> has a specific implementation while `as c_char` would
// just do a naive enum cast. // just do a naive enum cast.
let state_code: u8 = state.into(); let state_code: u8 = entry.state().into();
make_dirstate_item_raw(py, state_code, mode, size, mtime) make_dirstate_item_raw(
py,
state_code,
entry.mode(),
entry.size(),
entry.mtime(),
)
} }
pub fn make_dirstate_item_raw( pub fn make_dirstate_item_raw(
py: Python, py: Python,
state: u8, state: u8,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,

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

} }
} }
def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> { def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> {
let f = path.extract::<PyBytes>(py)?; let f = path.extract::<PyBytes>(py)?;
let filename = HgPath::new(f.data(py)); let filename = HgPath::new(f.data(py));
let state = item.getattr(py, "state")?.extract::<PyBytes>(py)?; let state = item.getattr(py, "state")?.extract::<PyBytes>(py)?;
let state = state.data(py)[0]; let state = state.data(py)[0];
let entry = DirstateEntry { let entry = DirstateEntry::from_v1_data(
state: state.try_into().expect("state is always valid"), state.try_into().expect("state is always valid"),
mtime: item.getattr(py, "mtime")?.extract(py)?, item.getattr(py, "mode")?.extract(py)?,
size: item.getattr(py, "size")?.extract(py)?, item.getattr(py, "size")?.extract(py)?,
mode: item.getattr(py, "mode")?.extract(py)?, item.getattr(py, "mtime")?.extract(py)?,
}; );
self.inner(py).borrow_mut().set_v1(filename, entry); self.inner(py).borrow_mut().set_v1(filename, entry);
Ok(py.None()) Ok(py.None())
} }
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
mode: PyObject, mode: PyObject,
size.extract(py)? size.extract(py)?
}; };
let mtime = if mtime.is_none(py) { let mtime = if mtime.is_none(py) {
// fallback default value // fallback default value
MTIME_UNSET MTIME_UNSET
} else { } else {
mtime.extract(py)? mtime.extract(py)?
}; };
let entry = DirstateEntry { let entry = DirstateEntry::new_for_add_file(mode, size, mtime);
// XXX Arbitrary default value since the value is determined later
state: EntryState::Normal,
mode: mode,
size: size,
mtime: mtime,
};
let added = added.extract::<PyBool>(py)?.is_true(); let added = added.extract::<PyBool>(py)?.is_true();
let merged = merged.extract::<PyBool>(py)?.is_true(); let merged = merged.extract::<PyBool>(py)?.is_true();
let from_p2 = from_p2.extract::<PyBool>(py)?.is_true(); let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();
let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true(); let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();
self.inner(py).borrow_mut().add_file( self.inner(py).borrow_mut().add_file(
filename, filename,
entry, entry,
added, added,
)), )),
} }
} }
def filefoldmapasdict(&self) -> PyResult<PyDict> { def filefoldmapasdict(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for item in self.inner(py).borrow_mut().iter() { for item in self.inner(py).borrow_mut().iter() {
let (path, entry) = item.map_err(|e| v2_error(py, e))?; let (path, entry) = item.map_err(|e| v2_error(py, e))?;
if entry.state != EntryState::Removed { if entry.state() != EntryState::Removed {
let key = normalize_case(path); let key = normalize_case(path);
let value = path; let value = path;
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_bytes()).into_object(), PyBytes::new(py, key.as_bytes()).into_object(),
PyBytes::new(py, value.as_bytes()).into_object(), PyBytes::new(py, value.as_bytes()).into_object(),
)?; )?;
} }