( )⚙ D11782 dirstate-item: allow mtime to be None in "parentdata"

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11782

dirstate-item: allow mtime to be None in "parentdata"
ClosedPublic

Authored by marmoute on Nov 24 2021, 6:11 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata"
Summary

This will be useful to filter out unreliable mtime.

Diff Detail

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

Event Timeline

marmoute created this revision.Nov 24 2021, 6:11 AM
Alphare accepted this revision.Nov 24 2021, 8:08 AM
This revision is now accepted and ready to land.Nov 24 2021, 8:08 AM
marmoute edited the summary of this revision. (Show Details)Nov 30 2021, 6:53 PM
marmoute added a commit: rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata".Dec 1 2021, 10:21 AM
Closed by commit rHG3d6eb119200d: dirstate-item: allow mtime to be None in "parentdata" (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31104

mercurial/cext/parsers.c

int p2_info; int p2_info;
int has_meaningful_data; int has_meaningful_data;
int has_meaningful_mtime; int has_meaningful_mtime;
int mode; int mode;
int size; int size;
int mtime_s; int mtime_s;
int mtime_ns; int mtime_ns;
PyObject *parentfiledata; PyObject *parentfiledata;
PyObject *mtime;
PyObject *fallback_exec; PyObject *fallback_exec;
PyObject *fallback_symlink; PyObject *fallback_symlink;
static char *keywords_name[] = { static char *keywords_name[] = {
"wc_tracked", "p1_tracked", "p2_info", "wc_tracked", "p1_tracked", "p2_info",
"has_meaningful_data", "has_meaningful_mtime", "parentfiledata", "has_meaningful_data", "has_meaningful_mtime", "parentfiledata",
"fallback_exec", "fallback_symlink", NULL, "fallback_exec", "fallback_symlink", NULL,
}; };
wc_tracked = 0; wc_tracked = 0;
if (fallback_symlink != Py_None) { if (fallback_symlink != Py_None) {
t->flags |= dirstate_flag_has_fallback_symlink; t->flags |= dirstate_flag_has_fallback_symlink;
if (PyObject_IsTrue(fallback_symlink)) { if (PyObject_IsTrue(fallback_symlink)) {
t->flags |= dirstate_flag_fallback_symlink; t->flags |= dirstate_flag_fallback_symlink;
} }
} }
if (parentfiledata != Py_None) { if (parentfiledata != Py_None) {
if (!PyArg_ParseTuple(parentfiledata, "ii(ii)", &mode, &size, if (!PyArg_ParseTuple(parentfiledata, "iiO", &mode, &size,
&mtime_s, &mtime_ns)) { &mtime)) {
return NULL; return NULL;
} }
if (mtime != Py_None) {
if (!PyArg_ParseTuple(mtime, "ii", &mtime_s,
&mtime_ns)) {
return NULL;
}
} else {
has_meaningful_mtime = 0;
}
} else { } else {
has_meaningful_data = 0; has_meaningful_data = 0;
has_meaningful_mtime = 0; has_meaningful_mtime = 0;
} }
if (has_meaningful_data) { if (has_meaningful_data) {
t->flags |= dirstate_flag_has_meaningful_data; t->flags |= dirstate_flag_has_meaningful_data;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* See docstring of the python implementation for details */ /* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self, static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args) PyObject *args)
{ {
int size, mode, mtime_s, mtime_ns; int size, mode, mtime_s, mtime_ns;
if (!PyArg_ParseTuple(args, "ii(ii)", &mode, &size, &mtime_s, PyObject *mtime;
&mtime_ns)) { mtime_s = 0;
mtime_ns = 0;
if (!PyArg_ParseTuple(args, "iiO", &mode, &size, &mtime)) {
return NULL;
}
if (mtime != Py_None) {
if (!PyArg_ParseTuple(mtime, "ii", &mtime_s, &mtime_ns)) {
return NULL; return NULL;
} }
} else {
self->flags &= ~dirstate_flag_has_mtime;
}
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked | self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked |
dirstate_flag_has_meaningful_data | dirstate_flag_has_meaningful_data |
dirstate_flag_has_mtime; dirstate_flag_has_mtime;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime_s = mtime_s; self->mtime_s = mtime_s;
self->mtime_ns = mtime_ns; self->mtime_ns = mtime_ns;
Py_RETURN_NONE; Py_RETURN_NONE;

mercurial/dirstate.py

wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info=p2_info, p2_info=p2_info,
has_meaningful_mtime=not possibly_dirty, has_meaningful_mtime=not possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
) )
if ( if (
parentfiledata is not None parentfiledata is not None
and parentfiledata[2] is not None
and parentfiledata[2] > self._lastnormaltime and parentfiledata[2] > self._lastnormaltime
): ):
# Remember the most recent modification timeslot for status(), # Remember the most recent modification timeslot for status(),
# to make sure we won't miss future size-preserving file content # to make sure we won't miss future size-preserving file content
# modifications that happen within the same timeslot. # modifications that happen within the same timeslot.
self._lastnormaltime = parentfiledata[2] self._lastnormaltime = parentfiledata[2]
def _check_new_tracked_filename(self, filename): def _check_new_tracked_filename(self, filename):

mercurial/pure/parsers.py

self._mode = None self._mode = None
self._size = None self._size = None
self._mtime_s = None self._mtime_s = None
self._mtime_ns = None self._mtime_ns = None
if parentfiledata is None: if parentfiledata is None:
has_meaningful_mtime = False has_meaningful_mtime = False
has_meaningful_data = False has_meaningful_data = False
elif parentfiledata[2] is None:
has_meaningful_mtime = False
if has_meaningful_data: if has_meaningful_data:
self._mode = parentfiledata[0] self._mode = parentfiledata[0]
self._size = parentfiledata[1] self._size = parentfiledata[1]
if has_meaningful_mtime: if has_meaningful_mtime:
self._mtime_s, self._mtime_ns = parentfiledata[2] self._mtime_s, self._mtime_ns = parentfiledata[2]
@classmethod @classmethod
def from_v2_data(cls, flags, size, mtime_s, mtime_ns): def from_v2_data(cls, flags, size, mtime_s, mtime_ns):

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

def __new__( def __new__(
_cls, _cls,
wc_tracked: bool = false, wc_tracked: bool = false,
p1_tracked: bool = false, p1_tracked: bool = false,
p2_info: bool = false, p2_info: bool = false,
has_meaningful_data: bool = true, has_meaningful_data: bool = true,
has_meaningful_mtime: bool = true, has_meaningful_mtime: bool = true,
parentfiledata: Option<(u32, u32, (u32, u32))> = None, parentfiledata: Option<(u32, u32, Option<(u32, u32)>)> = None,
fallback_exec: Option<bool> = None, fallback_exec: Option<bool> = None,
fallback_symlink: Option<bool> = None, fallback_symlink: Option<bool> = None,
) -> PyResult<DirstateItem> { ) -> PyResult<DirstateItem> {
let mut mode_size_opt = None; let mut mode_size_opt = None;
let mut mtime_opt = None; let mut mtime_opt = None;
if let Some((mode, size, mtime)) = parentfiledata { if let Some((mode, size, mtime)) = parentfiledata {
if has_meaningful_data { if has_meaningful_data {
mode_size_opt = Some((mode, size)) mode_size_opt = Some((mode, size))
} }
if has_meaningful_mtime { if has_meaningful_mtime {
mtime_opt = Some(timestamp(py, mtime)?) if let Some(m) = mtime {
mtime_opt = Some(timestamp(py, m)?);
}
} }
} }
let entry = DirstateEntry::from_v2_data( let entry = DirstateEntry::from_v2_data(
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size_opt, mode_size_opt,
mtime_opt, mtime_opt,