This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10954

dirstate-entry: add a `state` property (and use it)
ClosedPublic

Authored by marmoute on Jul 4 2021, 5:50 PM.

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHG769037a279ec: dirstate-entry: add a `state` property (and use it)
Summary

This replace the [0] access. Ultimately is we should probably get ride of this
in its current form. However this is a good transitional solution to move away
for tuple indexing for now.

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.Jul 4 2021, 5:50 PM
SimonSapin added a subscriber: SimonSapin.Jul 5 2021, 12:14 AM

Why have both a v1_state method and a state property? What’s the difference between them?

marmoute added a comment.Jul 5 2021, 12:34 AM
In D10954#167659, @SimonSapin wrote:

Why have both a v1_state method and a state property? What’s the difference between `them?

v1_state return the exact content that we need to serialize the dirstate v1 format. The state one give use access to the current internal "state" encoding. It might diverge from v1_state in the future or disapper entirely.

SimonSapin accepted this revision.Jul 5 2021, 12:41 AM
pulkit accepted this revision.Jul 6 2021, 12:25 PM
This revision is now accepted and ready to land.Jul 6 2021, 12:25 PM
baymax updated this revision to Diff 28856.Jul 6 2021, 2:08 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute added a commit: rHG769037a279ec: dirstate-entry: add a `state` property (and use it).Jul 6 2021, 3:07 PM
Closed by commit rHG769037a279ec: dirstate-entry: add a `state` property (and use it) (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/parsers.c (12 lines)
Mmercurial/dirstate.py (27 lines)
Mmercurial/pure/parsers.py (15 lines)

Diff 28893

mercurial/cext/parsers.c

"return a \"mode\" suitable for v1 serialization"}, "return a \"mode\" suitable for v1 serialization"},
{"v1_size", (PyCFunction)dirstatetuple_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstatetuple_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstatetuple_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstatetuple_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{NULL} /* Sentinel */ {NULL} /* Sentinel */
}; };
static PyObject *dirstatetuple_get_state(dirstateTupleObject *self)
{
return PyBytes_FromStringAndSize(&self->state, 1);
};
static PyGetSetDef dirstatetuple_getset[] = {
{"state", (getter)dirstatetuple_get_state, NULL, "state", NULL},
{NULL} /* Sentinel */
};
PyTypeObject dirstateTupleType = { PyTypeObject dirstateTupleType = {
PyVarObject_HEAD_INIT(NULL, 0) /* header */ PyVarObject_HEAD_INIT(NULL, 0) /* header */
"dirstate_tuple", /* tp_name */ "dirstate_tuple", /* tp_name */
sizeof(dirstateTupleObject), /* tp_basicsize */ sizeof(dirstateTupleObject), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
(destructor)dirstate_tuple_dealloc, /* tp_dealloc */ (destructor)dirstate_tuple_dealloc, /* tp_dealloc */
0, /* tp_print */ 0, /* tp_print */
0, /* tp_getattr */ 0, /* tp_getattr */
0, /* tp_traverse */ 0, /* tp_traverse */
0, /* tp_clear */ 0, /* tp_clear */
0, /* tp_richcompare */ 0, /* tp_richcompare */
0, /* tp_weaklistoffset */ 0, /* tp_weaklistoffset */
0, /* tp_iter */ 0, /* tp_iter */
0, /* tp_iternext */ 0, /* tp_iternext */
dirstatetuple_methods, /* tp_methods */ dirstatetuple_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tp_getset */ dirstatetuple_getset, /* tp_getset */
0, /* tp_base */ 0, /* tp_base */
0, /* tp_dict */ 0, /* tp_dict */
0, /* tp_descr_get */ 0, /* tp_descr_get */
0, /* tp_descr_set */ 0, /* tp_descr_set */
0, /* tp_dictoffset */ 0, /* tp_dictoffset */
0, /* tp_init */ 0, /* tp_init */
0, /* tp_alloc */ 0, /* tp_alloc */
dirstate_tuple_new, /* tp_new */ dirstate_tuple_new, /* tp_new */

mercurial/dirstate.py

"""Return the current state of key (a filename) in the dirstate. """Return the current state of key (a filename) in the dirstate.
States are: States are:
n normal n normal
m needs merging m needs merging
r marked for removal r marked for removal
a marked for addition a marked for addition
? not tracked ? not tracked
XXX The "state" is a bit obscure to be in the "public" API. we should
consider migrating all user of this to going through the dirstate entry
instead.
""" """
return self._map.get(key, (b"?",))[0] entry = self._map.get(key)
if entry is not None:
return entry.state
return b'?'
def __contains__(self, key): def __contains__(self, key):
return key in self._map return key in self._map
def __iter__(self): def __iter__(self):
return iter(sorted(self._map)) return iter(sorted(self._map))
def items(self): def items(self):
candidatefiles = self._map.non_normal_or_other_parent_paths() candidatefiles = self._map.non_normal_or_other_parent_paths()
for f in candidatefiles: for f in candidatefiles:
s = self._map.get(f) s = self._map.get(f)
if s is None: if s is None:
continue continue
# Discard 'm' markers when moving away from a merge state # Discard 'm' markers when moving away from a merge state
if s[0] == b'm': if s.state == b'm':
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.normallookup(f) self.normallookup(f)
# Also fix up otherparent markers # Also fix up otherparent markers
elif s[0] == b'n' and s[2] == FROM_P2: elif s.state == b'n' and s[2] == FROM_P2:
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if source: if source:
copies[f] = source copies[f] = source
self.add(f) self.add(f)
return copies return copies
def setbranch(self, branch): def setbranch(self, branch):
self.__class__._branch.set(self, encoding.fromlocal(branch)) self.__class__._branch.set(self, encoding.fromlocal(branch))
msg = _(b'directory %r already in dirstate') msg = _(b'directory %r already in dirstate')
msg %= pycompat.bytestr(f) msg %= pycompat.bytestr(f)
raise error.Abort(msg) raise error.Abort(msg)
# shadows # shadows
for d in pathutil.finddirs(f): for d in pathutil.finddirs(f):
if self._map.hastrackeddir(d): if self._map.hastrackeddir(d):
break break
entry = self._map.get(d) entry = self._map.get(d)
if entry is not None and entry[0] != b'r': if entry is not None and entry.state != b'r':
msg = _(b'file %r in dirstate clashes with %r') msg = _(b'file %r in dirstate clashes with %r')
msg %= (pycompat.bytestr(d), pycompat.bytestr(f)) msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
raise error.Abort(msg) raise error.Abort(msg)
if state == b'a': if state == b'a':
assert not possibly_dirty assert not possibly_dirty
assert not from_p2 assert not from_p2
size = NONNORMAL size = NONNORMAL
mtime = AMBIGUOUS_TIME mtime = AMBIGUOUS_TIME
def normallookup(self, f): def normallookup(self, f):
'''Mark a file normal, but possibly dirty.''' '''Mark a file normal, but possibly dirty.'''
if self.in_merge: if self.in_merge:
# if there is a merge going on and the file was either # if there is a merge going on and the file was either
# in state 'm' (-1) or coming from other parent (-2) before # in state 'm' (-1) or coming from other parent (-2) before
# being removed, restore that state. # being removed, restore that state.
entry = self._map.get(f) entry = self._map.get(f)
if entry is not None: if entry is not None:
if entry[0] == b'r' and entry[2] in (NONNORMAL, FROM_P2): if entry.state == b'r' and entry[2] in (NONNORMAL, FROM_P2):
source = self._map.copymap.get(f) source = self._map.copymap.get(f)
if entry[2] == NONNORMAL: if entry[2] == NONNORMAL:
self.merge(f) self.merge(f)
elif entry[2] == FROM_P2: elif entry[2] == FROM_P2:
self.otherparent(f) self.otherparent(f)
if source: if source:
self.copy(source, f) self.copy(source, f)
return return
if entry[0] == b'm' or entry[0] == b'n' and entry[2] == FROM_P2: if (
entry.state == b'm'
or entry.state == b'n'
and entry[2] == FROM_P2
):
return return
self._addpath(f, b'n', 0, possibly_dirty=True) self._addpath(f, b'n', 0, possibly_dirty=True)
self._map.copymap.pop(f, None) self._map.copymap.pop(f, None)
def otherparent(self, f): def otherparent(self, f):
'''Mark as coming from the other parent, always dirty.''' '''Mark as coming from the other parent, always dirty.'''
if not self.in_merge: if not self.in_merge:
msg = _(b"setting %r to other parent only allowed in merges") % f msg = _(b"setting %r to other parent only allowed in merges") % f
now = util.fstat(st)[stat.ST_MTIME] & _rangemask now = util.fstat(st)[stat.ST_MTIME] & _rangemask
# enough 'delaywrite' prevents 'pack_dirstate' from dropping # enough 'delaywrite' prevents 'pack_dirstate' from dropping
# timestamp of each entries in dirstate, because of 'now > mtime' # timestamp of each entries in dirstate, because of 'now > mtime'
delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite') delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite')
if delaywrite > 0: if delaywrite > 0:
# do we have any files to delay for? # do we have any files to delay for?
for f, e in pycompat.iteritems(self._map): for f, e in pycompat.iteritems(self._map):
if e[0] == b'n' and e[3] == now: if e.state == b'n' and e[3] == now:
import time # to avoid useless import import time # to avoid useless import
# rather than sleep n seconds, sleep until the next # rather than sleep n seconds, sleep until the next
# multiple of n seconds # multiple of n seconds
clock = time.time() clock = time.time()
start = int(clock) - (int(clock) % delaywrite) start = int(clock) - (int(clock) % delaywrite)
end = start + delaywrite end = start + delaywrite
time.sleep(end - clock) time.sleep(end - clock)
# This is equivalent to 'state, mode, size, time = dmap[fn]' but not # This is equivalent to 'state, mode, size, time = dmap[fn]' but not
# written like that for performance reasons. dmap[fn] is not a # written like that for performance reasons. dmap[fn] is not a
# Python tuple in compiled builds. The CPython UNPACK_SEQUENCE # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE
# opcode has fast paths when the value to be unpacked is a tuple or # opcode has fast paths when the value to be unpacked is a tuple or
# a list, but falls back to creating a full-fledged iterator in # a list, but falls back to creating a full-fledged iterator in
# general. That is much slower than simply accessing and storing the # general. That is much slower than simply accessing and storing the
# tuple members one by one. # tuple members one by one.
t = dget(fn) t = dget(fn)
state = t[0] state = t.state
mode = t[1] mode = t[1]
size = t[2] size = t[2]
time = t[3] time = t[3]
if not st and state in b"nma": if not st and state in b"nma":
dadd(fn) dadd(fn)
elif state == b'n': elif state == b'n':
if ( if (

mercurial/pure/parsers.py

return self._mode return self._mode
elif idx == 2 or idx == -2: elif idx == 2 or idx == -2:
return self._size return self._size
elif idx == 3 or idx == -1: elif idx == 3 or idx == -1:
return self._mtime return self._mtime
else: else:
raise IndexError(idx) raise IndexError(idx)
@property
def state(self):
"""
States are:
n normal
m needs merging
r marked for removal
a marked for addition
XXX This "state" is a bit obscure and mostly a direct expression of the
dirstatev1 format. It would make sense to ultimately deprecate it in
favor of the more "semantic" attributes.
"""
return self._state
def v1_state(self): def v1_state(self):
"""return a "state" suitable for v1 serialization""" """return a "state" suitable for v1 serialization"""
return self._state return self._state
def v1_mode(self): def v1_mode(self):
"""return a "mode" suitable for v1 serialization""" """return a "mode" suitable for v1 serialization"""
return self._mode return self._mode