( )⚙ D11699 dirstate: align Rust function name to `need_delay`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11699

dirstate: align Rust function name to `need_delay`
ClosedPublic

Authored by marmoute on Oct 19 2021, 6:02 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc591944f42c1: dirstate: align Rust function name to `need_delay`
Summary

The rest of the code use this name. It is not a great name, but it is better to
stay consistent.

Diff Detail

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

Event Timeline

marmoute created this revision.Oct 19 2021, 6:02 PM
Alphare accepted this revision.Oct 20 2021, 4:33 AM
Alphare added a subscriber: Alphare.

I think a docstring would be good for this function. If this ends up being the only nit in the series it can be done in a follow-up.

This revision is now accepted and ready to land.Oct 20 2021, 4:33 AM
marmoute updated this revision to Diff 30929.Oct 20 2021, 5:12 AM
marmoute added a commit: rHGc591944f42c1: dirstate: align Rust function name to `need_delay`.Oct 20 2021, 5:30 AM
Closed by commit rHGc591944f42c1: dirstate: align Rust function name to `need_delay` (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30929

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

} }
/// Returns a `(state, mode, size, mtime)` tuple as for /// Returns a `(state, mode, size, mtime)` tuple as for
/// `DirstateMapMethods::debug_iter`. /// `DirstateMapMethods::debug_iter`.
pub fn debug_tuple(&self) -> (u8, i32, i32, i32) { pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
(self.state().into(), self.mode(), self.size(), self.mtime()) (self.state().into(), self.mode(), self.size(), self.mtime())
} }
pub fn mtime_is_ambiguous(&self, now: i32) -> bool { /// True if the stored mtime would be ambiguous with the current time
pub fn need_delay(&self, now: i32) -> bool {
self.state() == EntryState::Normal && self.mtime() == now self.state() == EntryState::Normal && self.mtime() == now
} }
pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool { pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool {
let ambiguous = self.mtime_is_ambiguous(now); let ambiguous = self.need_delay(now);
if ambiguous { if ambiguous {
// 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

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

let mut size = parents.as_bytes().len(); let mut size = parents.as_bytes().len();
for node in map.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
size += packed_entry_size( size += packed_entry_size(
node.full_path(map.on_disk)?, node.full_path(map.on_disk)?,
node.copy_source(map.on_disk)?, node.copy_source(map.on_disk)?,
); );
if entry.mtime_is_ambiguous(now) { if entry.need_delay(now) {
ambiguous_mtimes.push( ambiguous_mtimes.push(
node.full_path_borrowed(map.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; map.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?;
) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> { ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
let map = self.get_map_mut(); let map = self.get_map_mut();
// TODO:!how do we want to handle this in 2038? // TODO:!how do we want to handle this in 2038?
let now: i32 = now.0.try_into().expect("time overflow"); let now: i32 = now.0.try_into().expect("time overflow");
let mut paths = Vec::new(); let mut paths = Vec::new();
for node in map.iter_nodes() { for node in map.iter_nodes() {
let node = node?; let node = node?;
if let Some(entry) = node.entry()? { if let Some(entry) = node.entry()? {
if entry.mtime_is_ambiguous(now) { if entry.need_delay(now) {
paths.push( paths.push(
node.full_path_borrowed(map.on_disk)? node.full_path_borrowed(map.on_disk)?
.detach_from_tree(), .detach_from_tree(),
) )
} }
} }
} }
// Borrow of `self` ends here since we collect cloned paths // Borrow of `self` ends here since we collect cloned paths

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

} }
def v1_mtime(&self) -> PyResult<i32> { def v1_mtime(&self) -> PyResult<i32> {
let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data(); let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
Ok(mtime) Ok(mtime)
} }
def need_delay(&self, now: i32) -> PyResult<bool> { def need_delay(&self, now: i32) -> PyResult<bool> {
Ok(self.entry(py).get().mtime_is_ambiguous(now)) Ok(self.entry(py).get().need_delay(now))
} }
@classmethod @classmethod
def from_v1_data( def from_v1_data(
_cls, _cls,
state: PyBytes, state: PyBytes,
mode: i32, mode: i32,
size: i32, size: i32,