( )⚙ D10981 dirstate-entry: add a `mtime` property

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10981

dirstate-entry: add a `mtime` property
ClosedPublic

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

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHG77fce401a2bb: dirstate-entry: add a `mtime` property
Summary

This is clearer than "tuple" indexing.

Diff Detail

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

Event Timeline

marmoute created this revision.Jul 4 2021, 5:52 PM
SimonSapin accepted this revision.Jul 5 2021, 1:27 AM
baymax updated this revision to Diff 28883.Jul 6 2021, 2:09 PM

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

pulkit accepted this revision.Jul 6 2021, 3:12 PM
This revision is now accepted and ready to land.Jul 6 2021, 3:12 PM
marmoute added a commit: rHG77fce401a2bb: dirstate-entry: add a `mtime` property.Jul 6 2021, 3:42 PM
Closed by commit rHG77fce401a2bb: dirstate-entry: add a `mtime` property (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 28802

mercurial/cext/parsers.c

return PyInt_FromLong(self->mode); return PyInt_FromLong(self->mode);
}; };
static PyObject *dirstatetuple_get_size(dirstateTupleObject *self) static PyObject *dirstatetuple_get_size(dirstateTupleObject *self)
{ {
return PyInt_FromLong(self->size); return PyInt_FromLong(self->size);
}; };
static PyObject *dirstatetuple_get_mtime(dirstateTupleObject *self)
{
return PyInt_FromLong(self->mtime);
};
static PyObject *dirstatetuple_get_state(dirstateTupleObject *self) static PyObject *dirstatetuple_get_state(dirstateTupleObject *self)
{ {
return PyBytes_FromStringAndSize(&self->state, 1); return PyBytes_FromStringAndSize(&self->state, 1);
}; };
static PyObject *dirstatetuple_get_tracked(dirstateTupleObject *self) static PyObject *dirstatetuple_get_tracked(dirstateTupleObject *self)
{ {
if (self->state == 'a' || self->state == 'm' || self->state == 'n') { if (self->state == 'a' || self->state == 'm' || self->state == 'n') {
} else { } else {
Py_RETURN_FALSE; Py_RETURN_FALSE;
} }
}; };
static PyGetSetDef dirstatetuple_getset[] = { static PyGetSetDef dirstatetuple_getset[] = {
{"mode", (getter)dirstatetuple_get_mode, NULL, "mode", NULL}, {"mode", (getter)dirstatetuple_get_mode, NULL, "mode", NULL},
{"size", (getter)dirstatetuple_get_size, NULL, "size", NULL}, {"size", (getter)dirstatetuple_get_size, NULL, "size", NULL},
{"mtime", (getter)dirstatetuple_get_mtime, NULL, "mtime", NULL},
{"state", (getter)dirstatetuple_get_state, NULL, "state", NULL}, {"state", (getter)dirstatetuple_get_state, NULL, "state", NULL},
{"tracked", (getter)dirstatetuple_get_tracked, NULL, "tracked", NULL}, {"tracked", (getter)dirstatetuple_get_tracked, NULL, "tracked", NULL},
{"added", (getter)dirstatetuple_get_added, NULL, "added", NULL}, {"added", (getter)dirstatetuple_get_added, NULL, "added", NULL},
{"merged_removed", (getter)dirstatetuple_get_merged_removed, NULL, {"merged_removed", (getter)dirstatetuple_get_merged_removed, NULL,
"merged_removed", NULL}, "merged_removed", NULL},
{"merged", (getter)dirstatetuple_get_merged, NULL, "merged", NULL}, {"merged", (getter)dirstatetuple_get_merged, NULL, "merged", NULL},
{"from_p2_removed", (getter)dirstatetuple_get_from_p2_removed, NULL, {"from_p2_removed", (getter)dirstatetuple_get_from_p2_removed, NULL,
"from_p2_removed", NULL}, "from_p2_removed", NULL},

mercurial/dirstate.py

# 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)
mode = t.mode mode = t.mode
size = t.size size = t.size
time = t[3] time = t.mtime
if not st and t.tracked: if not st and t.tracked:
dadd(fn) dadd(fn)
elif t.merged: elif t.merged:
madd(fn) madd(fn)
elif t.added: elif t.added:
aadd(fn) aadd(fn)
elif t.removed: elif t.removed:

mercurial/pure/parsers.py

def mode(self): def mode(self):
return self._mode return self._mode
@property @property
def size(self): def size(self):
return self._size return self._size
@property @property
def mtime(self):
return self._mtime
@property
def state(self): def state(self):
""" """
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