This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11330

dirstate-item: add dedicated "legacy" constructor for `addfile` case
ClosedPublic

Authored by marmoute on Aug 21 2021, 5:57 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc0d6a59a7704: dirstate-item: add dedicated "legacy" constructor for `addfile` case
Summary

This way the internal details of how a DirstateItem is encoded is encapsulated
within the DirstateItem. This will finally give use some latitude to change the
data we store in a DirstateItem.

The addfile logic will likely be rewritten eventually and these dedicated
constructor can be removed at that time.

In the mean-time this should help with hiding internal details of DirstateItem
and to migrate it to new internal storage and logic.

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.Aug 21 2021, 5:57 AM
baymax updated this revision to Diff 30056.Aug 26 2021, 9:01 AM

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

Alphare accepted this revision.Aug 26 2021, 9:12 AM
This revision is now accepted and ready to land.Aug 26 2021, 9:12 AM

Revision Contents
Changeset List

PathPackages
Mmercurial/cext/parsers.c (111 lines)
Mmercurial/dirstatemap.py (30 lines)
Mmercurial/pure/parsers.py (67 lines)

Diff 30098

mercurial/cext/parsers.c

t->state = state; t->state = state;
t->mode = mode; t->mode = mode;
t->size = size; t->size = size;
t->mtime = mtime; t->mtime = mtime;
return (PyObject *)t; return (PyObject *)t;
}; };
/* constructor to help legacy API to build a new "added" item
Should eventually be removed */
static PyObject *dirstate_item_new_added(PyTypeObject *subtype)
{
dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = 'a';
t->mode = 0;
t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "merged" item
Should eventually be removed */
static PyObject *dirstate_item_new_merged(PyTypeObject *subtype)
{
dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = 'm';
t->mode = 0;
t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "from_p2" item
Should eventually be removed */
static PyObject *dirstate_item_new_from_p2(PyTypeObject *subtype)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = 'n';
t->mode = 0;
t->size = dirstate_v1_from_p2;
t->mtime = ambiguous_time;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "possibly" item
Should eventually be removed */
static PyObject *dirstate_item_new_possibly_dirty(PyTypeObject *subtype)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = 'n';
t->mode = 0;
t->size = dirstate_v1_nonnormal;
t->mtime = ambiguous_time;
return (PyObject *)t;
};
/* constructor to help legacy API to build a new "normal" item
Should eventually be removed */
static PyObject *dirstate_item_new_normal(PyTypeObject *subtype, PyObject *args)
{
/* We do all the initialization here and not a tp_init function because
* dirstate_item is immutable. */
dirstateItemObject *t;
int size, mode, mtime;
if (!PyArg_ParseTuple(args, "iii", &mode, &size, &mtime)) {
return NULL;
}
t = (dirstateItemObject *)subtype->tp_alloc(subtype, 1);
if (!t) {
return NULL;
}
t->state = 'n';
t->mode = mode;
t->size = size;
t->mtime = mtime;
return (PyObject *)t;
};
/* 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. */
static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self) static PyObject *dirstate_item_set_possibly_dirty(dirstateItemObject *self)
{ {
self->mtime = ambiguous_time; self->mtime = ambiguous_time;
Py_RETURN_NONE; Py_RETURN_NONE;
} }
{"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS, {"v1_size", (PyCFunction)dirstate_item_v1_size, METH_NOARGS,
"return a \"size\" suitable for v1 serialization"}, "return a \"size\" suitable for v1 serialization"},
{"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS, {"v1_mtime", (PyCFunction)dirstate_item_v1_mtime, METH_NOARGS,
"return a \"mtime\" suitable for v1 serialization"}, "return a \"mtime\" suitable for v1 serialization"},
{"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O, {"need_delay", (PyCFunction)dirstate_item_need_delay, METH_O,
"True if the stored mtime would be ambiguous with the current time"}, "True if the stored mtime would be ambiguous with the current time"},
{"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth, {"from_v1_data", (PyCFunction)dirstate_item_from_v1_meth,
METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"}, METH_VARARGS | METH_CLASS, "build a new DirstateItem object from V1 data"},
{"new_added", (PyCFunction)dirstate_item_new_added,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"added\" item"},
{"new_merged", (PyCFunction)dirstate_item_new_merged,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"merged\" item"},
{"new_from_p2", (PyCFunction)dirstate_item_new_from_p2,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"from_p2\" item"},
{"new_possibly_dirty", (PyCFunction)dirstate_item_new_possibly_dirty,
METH_NOARGS | METH_CLASS,
"constructor to help legacy API to build a new \"possibly_dirty\" item"},
{"new_normal", (PyCFunction)dirstate_item_new_normal,
METH_VARARGS | METH_CLASS,
"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_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)

mercurial/dirstatemap.py

from_p2=False, from_p2=False,
possibly_dirty=False, possibly_dirty=False,
): ):
"""Add a tracked file to the dirstate.""" """Add a tracked file to the dirstate."""
if added: if added:
assert not merged assert not merged
assert not possibly_dirty assert not possibly_dirty
assert not from_p2 assert not from_p2
state = b'a' new_entry = DirstateItem.new_added()
size = NONNORMAL
mtime = AMBIGUOUS_TIME
elif merged: elif merged:
assert not possibly_dirty assert not possibly_dirty
assert not from_p2 assert not from_p2
state = b'm' new_entry = DirstateItem.new_merged()
size = FROM_P2
mtime = AMBIGUOUS_TIME
elif from_p2: elif from_p2:
assert not possibly_dirty assert not possibly_dirty
state = b'n' new_entry = DirstateItem.new_from_p2()
size = FROM_P2
mtime = AMBIGUOUS_TIME
elif possibly_dirty: elif possibly_dirty:
state = b'n' new_entry = DirstateItem.new_possibly_dirty()
size = NONNORMAL
mtime = AMBIGUOUS_TIME
else: else:
assert size != FROM_P2
assert size != NONNORMAL
assert size is not None assert size is not None
assert mtime is not None assert mtime is not None
state = b'n'
size = size & rangemask size = size & rangemask
mtime = mtime & rangemask mtime = mtime & rangemask
assert state is not None new_entry = DirstateItem.new_normal(mode, size, mtime)
assert size is not None
assert mtime is not None
old_entry = self.get(f) old_entry = self.get(f)
self._dirs_incr(f, old_entry) self._dirs_incr(f, old_entry)
e = self._map[f] = DirstateItem.from_v1_data(state, mode, size, mtime) self._map[f] = new_entry
if e.dm_nonnormal: if new_entry.dm_nonnormal:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if e.dm_otherparent: if new_entry.dm_otherparent:
self.otherparentset.add(f) self.otherparentset.add(f)
def reset_state( def reset_state(
self, self,
filename, filename,
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_tracked=False, p2_tracked=False,

mercurial/pure/parsers.py

self._state = b'n' self._state = b'n'
self._mode = parentfiledata[0] self._mode = parentfiledata[0]
self._size = parentfiledata[1] self._size = parentfiledata[1]
self._mtime = parentfiledata[2] self._mtime = parentfiledata[2]
else: else:
assert False, 'unreachable' assert False, 'unreachable'
@classmethod @classmethod
def new_added(cls):
"""constructor to help legacy API to build a new "added" item
Should eventually be removed
"""
instance = cls()
instance._state = b'a'
instance._mode = 0
instance._size = NONNORMAL
instance._mtime = AMBIGUOUS_TIME
return instance
@classmethod
def new_merged(cls):
"""constructor to help legacy API to build a new "merged" item
Should eventually be removed
"""
instance = cls()
instance._state = b'm'
instance._mode = 0
instance._size = FROM_P2
instance._mtime = AMBIGUOUS_TIME
return instance
@classmethod
def new_from_p2(cls):
"""constructor to help legacy API to build a new "from_p2" item
Should eventually be removed
"""
instance = cls()
instance._state = b'n'
instance._mode = 0
instance._size = FROM_P2
instance._mtime = AMBIGUOUS_TIME
return instance
@classmethod
def new_possibly_dirty(cls):
"""constructor to help legacy API to build a new "possibly_dirty" item
Should eventually be removed
"""
instance = cls()
instance._state = b'n'
instance._mode = 0
instance._size = NONNORMAL
instance._mtime = AMBIGUOUS_TIME
return instance
@classmethod
def new_normal(cls, mode, size, mtime):
"""constructor to help legacy API to build a new "normal" item
Should eventually be removed
"""
assert size != FROM_P2
assert size != NONNORMAL
instance = cls()
instance._state = b'n'
instance._mode = mode
instance._size = size
instance._mtime = mtime
return instance
@classmethod
def from_v1_data(cls, state, mode, size, mtime): def from_v1_data(cls, state, mode, size, mtime):
"""Build a new DirstateItem object from V1 data """Build a new DirstateItem object from V1 data
Since the dirstate-v1 format is frozen, the signature of this function Since the dirstate-v1 format is frozen, the signature of this function
is not expected to change, unlike the __init__ one. is not expected to change, unlike the __init__ one.
""" """
instance = cls() instance = cls()
instance._state = state instance._state = state