( )⚙ D11430 dirstate: introduce a set_tracked method on "map" and "item"

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11430

dirstate: introduce a set_tracked method on "map" and "item"
ClosedPublic

Authored by marmoute on Sep 16 2021, 10:43 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG0d2a404f1932: dirstate: introduce a set_tracked method on "map" and "item"
Summary

This move more implementation details withing the DirstateItem itself, which is
what we have been doing for a while.

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.

Revision Contents
Changeset List

Diff 30312

mercurial/cext/parsers.c

} }
self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked; self->flags = dirstate_flag_wc_tracked | dirstate_flag_p1_tracked;
self->mode = mode; self->mode = mode;
self->size = size; self->size = size;
self->mtime = mtime; self->mtime = mtime;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
static PyObject *dirstate_item_set_tracked(dirstateItemObject *self)
{
self->flags |= dirstate_flag_wc_tracked;
self->flags |= dirstate_flag_possibly_dirty;
/* size = None on the python size turn into size = NON_NORMAL when
* accessed. So the next line is currently required, but a some future
* clean up would be welcome. */
self->size = dirstate_v1_nonnormal;
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;
} }
"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, {"set_clean", (PyCFunction)dirstate_item_set_clean, METH_VARARGS,
"mark a file as \"clean\""}, "mark a file as \"clean\""},
{"set_tracked", (PyCFunction)dirstate_item_set_tracked, METH_NOARGS,
"mark a file as \"tracked\""},
{"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

This function is to be called outside of "update/merge" case. For This function is to be called outside of "update/merge" case. For
example by a command like `hg add X`. example by a command like `hg add X`.
return True the file was previously untracked, False otherwise. return True the file was previously untracked, False otherwise.
""" """
self._dirty = True self._dirty = True
self._updatedfiles.add(filename) self._updatedfiles.add(filename)
entry = self._map.get(filename) entry = self._map.get(filename)
if entry is None: if entry is None or not entry.tracked:
self._check_new_tracked_filename(filename) self._check_new_tracked_filename(filename)
self._map.addfile(filename, added=True) return self._map.set_tracked(filename)
return True
elif not entry.tracked:
self._normallookup(filename)
return True
# XXX This is probably overkill for more case, but we need this to
# fully replace the `normallookup` call with `set_tracked` one.
# Consider smoothing this in the future.
self.set_possibly_dirty(filename)
return False
@requires_no_parents_change @requires_no_parents_change
def set_untracked(self, filename): def set_untracked(self, filename):
"""a "public" method for generic code to mark a file as untracked """a "public" method for generic code to mark a file as untracked
This function is to be called outside of "update/merge" case. For This function is to be called outside of "update/merge" case. For
example by a command like `hg remove X`. example by a command like `hg remove X`.

mercurial/dirstatemap.py

else: else:
self.nonnormalset.discard(filename) self.nonnormalset.discard(filename)
if entry.dm_otherparent: if entry.dm_otherparent:
self.otherparentset.add(filename) self.otherparentset.add(filename)
else: else:
self.otherparentset.discard(filename) self.otherparentset.discard(filename)
self._map[filename] = entry self._map[filename] = entry
def set_tracked(self, filename):
new = False
entry = self.get(filename)
if entry is None:
self._dirs_incr(filename)
entry = DirstateItem(
p1_tracked=False,
p2_tracked=False,
wc_tracked=True,
merged=False,
clean_p1=False,
clean_p2=False,
possibly_dirty=False,
parentfiledata=None,
)
self._map[filename] = entry
if entry.dm_nonnormal:
self.nonnormalset.add(filename)
new = True
elif not entry.tracked:
self._dirs_incr(filename, entry)
entry.set_tracked()
new = True
else:
# XXX This is probably overkill for more case, but we need this to
# fully replace the `normallookup` call with `set_tracked` one.
# Consider smoothing this in the future.
self.set_possibly_dirty(filename)
return new
def set_untracked(self, f): def set_untracked(self, f):
"""Mark a file as no longer tracked in the dirstate map""" """Mark a file as no longer tracked in the dirstate map"""
entry = self.get(f) entry = self.get(f)
if entry is None: if entry is None:
return False return False
else: else:
self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added) self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)
if not entry.merged: if not entry.merged:
msg %= filename msg %= filename
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
mode, size, mtime = parentfiledata mode, size, mtime = parentfiledata
self.addfile(filename, mode=mode, size=size, mtime=mtime) self.addfile(filename, mode=mode, size=size, mtime=mtime)
self.nonnormalset.discard(filename) self.nonnormalset.discard(filename)
else: else:
assert False, 'unreachable' assert False, 'unreachable'
def set_tracked(self, filename):
new = False
entry = self.get(filename)
if entry is None:
self.addfile(filename, added=True)
new = True
elif not entry.tracked:
entry.set_tracked()
self._rustmap.set_v1(filename, entry)
new = True
else:
# XXX This is probably overkill for more case, but we need this to
# fully replace the `normallookup` call with `set_tracked` one.
# Consider smoothing this in the future.
self.set_possibly_dirty(filename)
return new
def set_untracked(self, f): def set_untracked(self, f):
"""Mark a file as no longer tracked in the dirstate map""" """Mark a file as no longer tracked in the dirstate map"""
# in merge is only trigger more logic, so it "fine" to pass it. # in merge is only trigger more logic, so it "fine" to pass it.
# #
# the inner rust dirstate map code need to be adjusted once the API # the inner rust dirstate map code need to be adjusted once the API
# for dirstate/dirstatemap/DirstateItem is a bit more settled # for dirstate/dirstatemap/DirstateItem is a bit more settled
entry = self.get(f) entry = self.get(f)
if entry is None: if entry is None:

mercurial/pure/parsers.py

self._p2_tracked = False # this might be wrong self._p2_tracked = False # this might be wrong
self._merged = False self._merged = False
self._clean_p2 = False self._clean_p2 = False
self._possibly_dirty = False self._possibly_dirty = False
self._mode = mode self._mode = mode
self._size = size self._size = size
self._mtime = mtime self._mtime = mtime
def set_tracked(self):
"""mark a file as tracked in the working copy
This will ultimately be called by command like `hg add`.
"""
self._wc_tracked = True
# `set_tracked` is replacing various `normallookup` call. So we set
# "possibly dirty" to stay on the safe side.
#
# Consider dropping this in the future in favor of something less broad.
self._possibly_dirty = True
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