This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11421

dirstate: introduce a `set_clean` method on dirstate's map and items
ClosedPublic

Authored by marmoute on Sep 14 2021, 5:20 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG4e6f27230aee: dirstate: introduce a `set_clean` method on dirstate's map and items
Summary

This method is the "reverse" of "set possibly dirty", and can be used to more
accurately other call that the dirstate was making. It is currently heavily
influenced by its origin.

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

marmoute created this revision.Sep 14 2021, 5:20 PM
Alphare accepted this revision.Sep 15 2021, 4:22 AM
This revision is now accepted and ready to land.Sep 15 2021, 4:22 AM

Revision Contents
Changeset List

Diff 30259

mercurial/cext/parsers.c

to make sure it is correct. */ to make sure it is correct. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
if (self->flags |= dirstate_flag_possibly_dirty) { if (self->flags |= dirstate_flag_possibly_dirty) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
} }
/* See docstring of the python implementation for details */
static PyObject *dirstate_item_set_clean(dirstateItemObject *self,
PyObject *args)
{
int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL;
}
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
self->mode = mode;
self->size = size;
self->mtime = mtime;
Py_RETURN_NONE;
}
static PyObject *dirstate_item_set_untracked(dirstateItemObject *self) static PyObject *dirstate_item_set_untracked(dirstateItemObject *self)
{ {
self->flags &= ~dirstate_flag_wc_tracked; self->flags &= ~dirstate_flag_wc_tracked;
self->mode = 0; self->mode = 0;
self->mtime = 0; self->mtime = 0;
self->size = 0; self->size = 0;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
{"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty, {"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,
METH_NOARGS | METH_CLASS, METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"possibly_dirty\" item"}, "constructor to help legacy API to build a new \"possibly_dirty\" item"},
{"new_normal", (PyCFunction)dirstate_item_new_normal, {"new_normal", (PyCFunction)dirstate_item_new_normal,
METH_VARARGS | METH_CLASS, METH_VARARGS | METH_CLASS,
"constructor to help legacy API to build a new \"normal\" item"}, "constructor to help legacy API to build a new \"normal\" item"},
{"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty, {"set_possibly_dirty", (PyCFunction)dirstate_item_set_possibly_dirty,
METH_NOARGS, "mark a file as \"possibly dirty\""}, METH_NOARGS, "mark a file as \"possibly dirty\""},
{"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
"mark a file as \"clean\""},
{"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS, {"set_untracked", (PyCFunction)dirstate_item_set_untracked, METH_NOARGS,
"mark a file as \"untracked\""}, "mark a file as \"untracked\""},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstate_item_get_mode(dirstateItemObject *self) static PyObject *dirstate_item_get_mode(dirstateItemObject *self)
{ {
return PyInt_FromLong(dirstate_item_c_v1_mode(self)); return PyInt_FromLong(dirstate_item_c_v1_mode(self));

mercurial/dirstate.py

def set_clean(self, filename, parentfiledata=None): def set_clean(self, filename, parentfiledata=None):
"""record that the current state of the file on disk is known to be clean""" """record that the current state of the file on disk is known to be clean"""
self._dirty = True self._dirty = True
self._updatedfiles.add(filename) self._updatedfiles.add(filename)
if parentfiledata: if parentfiledata:
(mode, size, mtime) = parentfiledata (mode, size, mtime) = parentfiledata
else: else:
(mode, size, mtime) = self._get_filedata(filename) (mode, size, mtime) = self._get_filedata(filename)
self._addpath(filename, mode=mode, size=size, mtime=mtime) if not self._map[filename].tracked:
self._map.copymap.pop(filename, None) self._check_new_tracked_filename(filename)
if filename in self._map.nonnormalset: self._map.set_clean(filename, mode, size, mtime)
self._map.nonnormalset.remove(filename)
if mtime > self._lastnormaltime: if mtime > 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 = mtime self._lastnormaltime = mtime
@requires_no_parents_change @requires_no_parents_change
def set_possibly_dirty(self, filename): def set_possibly_dirty(self, filename):

mercurial/dirstatemap.py

if "filefoldmap" in self.__dict__: if "filefoldmap" in self.__dict__:
normed = util.normcase(filename) normed = util.normcase(filename)
self.filefoldmap.pop(normed, None) self.filefoldmap.pop(normed, None)
def set_possibly_dirty(self, filename): def set_possibly_dirty(self, filename):
"""record that the current state of the file on disk is unknown""" """record that the current state of the file on disk is unknown"""
self[filename].set_possibly_dirty() self[filename].set_possibly_dirty()
def set_clean(self, filename, mode, size, mtime):
"""mark a file as back to a clean state"""
entry = self[filename]
mtime = mtime & rangemask
size = size & rangemask
entry.set_clean(mode, size, mtime)
self.copymap.pop(filename, None)
self.nonnormalset.discard(filename)
def addfile( def addfile(
self, self,
f, f,
mode=0, mode=0,
size=None, size=None,
mtime=None, mtime=None,
added=False, added=False,
merged=False, merged=False,
return f return f
def set_possibly_dirty(self, filename): def set_possibly_dirty(self, filename):
"""record that the current state of the file on disk is unknown""" """record that the current state of the file on disk is unknown"""
entry = self[filename] entry = self[filename]
entry.set_possibly_dirty() entry.set_possibly_dirty()
self._rustmap.set_v1(filename, entry) self._rustmap.set_v1(filename, entry)
def set_clean(self, filename, mode, size, mtime):
"""mark a file as back to a clean state"""
entry = self[filename]
mtime = mtime & rangemask
size = size & rangemask
entry.set_clean(mode, size, mtime)
self._rustmap.set_v1(filename, entry)
self._rustmap.copymap().pop(filename, None)
def __setitem__(self, key, value): def __setitem__(self, key, value):
assert isinstance(value, DirstateItem) assert isinstance(value, DirstateItem)
self._rustmap.set_v1(key, value) self._rustmap.set_v1(key, value)

mercurial/pure/parsers.py

def set_possibly_dirty(self): def set_possibly_dirty(self):
"""Mark a file as "possibly dirty" """Mark a file as "possibly dirty"
This means the next status call will have to actually check its content This means the next status call will have to actually check its content
to make sure it is correct. to make sure it is correct.
""" """
self._possibly_dirty = True self._possibly_dirty = True
def set_clean(self, mode, size, mtime):
"""mark a file as "clean" cancelling potential "possibly dirty call"
Note: this function is a descendant of `dirstate.normal` and is
currently expected to be call on "normal" entry only. There are not
reason for this to not change in the future as long as the ccode is
updated to preserve the proper state of the non-normal files.
"""
self._wc_tracked = True
self._p1_tracked = True
self._p2_tracked = False # this might be wrong
self._merged = False
self._clean_p2 = False
self._possibly_dirty = False
self._mode = mode
self._size = size
self._mtime = mtime
def set_untracked(self): def set_untracked(self):
"""mark a file as untracked in the working copy """mark a file as untracked in the working copy
This will ultimately be called by command like `hg remove`. This will ultimately be called by command like `hg remove`.
""" """
# backup the previous state (useful for merge) # backup the previous state (useful for merge)
self._wc_tracked = False self._wc_tracked = False
self._mode = None self._mode = None

rust/Cargo.lock

# This file is automatically @generated by Cargo. # This file is automatically @generated by Cargo.
# It is not intended for manual editing. # It is not intended for manual editing.
version = 3
[[package]] [[package]]
name = "adler" name = "adler"
version = "0.2.3" version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e" checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
[[package]] [[package]]
name = "aho-corasick" name = "aho-corasick"
mercurial/pure/parsers.py