( )⚙ D11364 dirstate-item: keep the full information in memory (for pure form)

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11364

dirstate-item: keep the full information in memory (for pure form)
ClosedPublic

Authored by marmoute on Aug 27 2021, 10:49 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGb81f52ca8075: dirstate-item: keep the full information in memory (for pure form)
Summary

This changeset is finally reaching the area where we have been headed this whole
time. Since all implementation details are contained inside de DirstateItem
logic, we can change the way it is implemented.

So we store the information that are passed to the object and use them to
dynamically compute the "legacy" value.

For now we only do this for the Pure implementation, as this is a good
demonstration for the logic is fully insulated.

The next step will be the update the C code too, to implement the various method
with the new attribute (instead of the legacy one) and then start seriously
thinking about the parameters we feed into DirstateItem.

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 27 2021, 10:49 AM
Alphare accepted this revision.Aug 30 2021, 5:49 AM
This revision is now accepted and ready to land.Aug 30 2021, 5:49 AM
baymax updated this revision to Diff 30141.Aug 30 2021, 8:59 AM

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

Revision Contents
Changeset List

PathPackages
Mmercurial/pure/parsers.py (232 lines)

Diff 30155

mercurial/pure/parsers.py

It contains: It contains:
- state (one of 'n', 'a', 'r', 'm') - state (one of 'n', 'a', 'r', 'm')
- mode, - mode,
- size, - size,
- mtime, - mtime,
""" """
_state = attr.ib() _wc_tracked = attr.ib()
_p1_tracked = attr.ib()
_p2_tracked = attr.ib()
# the three item above should probably be combined
#
# However it is unclear if they properly cover some of the most advanced
# merge case. So we should probably wait on this to be settled.
_merged = attr.ib()
_clean_p1 = attr.ib()
_clean_p2 = attr.ib()
_possibly_dirty = attr.ib()
_mode = attr.ib() _mode = attr.ib()
_size = attr.ib() _size = attr.ib()
_mtime = attr.ib() _mtime = attr.ib()
def __init__( def __init__(
self, self,
wc_tracked=False, wc_tracked=False,
p1_tracked=False, p1_tracked=False,
p2_tracked=False, p2_tracked=False,
merged=False, merged=False,
clean_p1=False, clean_p1=False,
clean_p2=False, clean_p2=False,
possibly_dirty=False, possibly_dirty=False,
parentfiledata=None, parentfiledata=None,
): ):
if merged and (clean_p1 or clean_p2): if merged and (clean_p1 or clean_p2):
msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`' msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
self._state = None self._wc_tracked = wc_tracked
self._mode = 0 self._p1_tracked = p1_tracked
self._size = NONNORMAL self._p2_tracked = p2_tracked
self._mtime = AMBIGUOUS_TIME self._merged = merged
if not (p1_tracked or p2_tracked or wc_tracked): self._clean_p1 = clean_p1
pass # the object has no state to record self._clean_p2 = clean_p2
elif merged: self._possibly_dirty = possibly_dirty
self._state = b'm'
self._size = FROM_P2
self._mtime = AMBIGUOUS_TIME
elif not (p1_tracked or p2_tracked) and wc_tracked:
self._state = b'a'
self._size = NONNORMAL
self._mtime = AMBIGUOUS_TIME
elif (p1_tracked or p2_tracked) and not wc_tracked:
self._state = b'r'
self._size = 0
self._mtime = 0
elif clean_p2 and wc_tracked:
self._state = b'n'
self._size = FROM_P2
self._mtime = AMBIGUOUS_TIME
elif not p1_tracked and p2_tracked and wc_tracked:
self._state = b'n'
self._size = FROM_P2
self._mtime = AMBIGUOUS_TIME
elif possibly_dirty:
self._state = b'n'
self._size = NONNORMAL
self._mtime = AMBIGUOUS_TIME
elif wc_tracked:
# this is a "normal" file
if parentfiledata is None: if parentfiledata is None:
msg = b'failed to pass parentfiledata for a normal file' self._mode = None
raise error.ProgrammingError(msg) self._size = None
self._state = b'n' self._mtime = None
else:
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:
assert False, 'unreachable'
@classmethod @classmethod
def new_added(cls): def new_added(cls):
"""constructor to help legacy API to build a new "added" item """constructor to help legacy API to build a new "added" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() instance = cls()
instance._state = b'a' instance._wc_tracked = True
instance._mode = 0 instance._p1_tracked = False
instance._size = NONNORMAL instance._p2_tracked = False
instance._mtime = AMBIGUOUS_TIME
return instance return instance
@classmethod @classmethod
def new_merged(cls): def new_merged(cls):
"""constructor to help legacy API to build a new "merged" item """constructor to help legacy API to build a new "merged" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() instance = cls()
instance._state = b'm' instance._wc_tracked = True
instance._mode = 0 instance._p1_tracked = True # might not be True because of rename ?
instance._size = FROM_P2 instance._p2_tracked = True # might not be True because of rename ?
instance._mtime = AMBIGUOUS_TIME instance._merged = True
return instance return instance
@classmethod @classmethod
def new_from_p2(cls): def new_from_p2(cls):
"""constructor to help legacy API to build a new "from_p2" item """constructor to help legacy API to build a new "from_p2" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() instance = cls()
instance._state = b'n' instance._wc_tracked = True
instance._mode = 0 instance._p1_tracked = False # might actually be True
instance._size = FROM_P2 instance._p2_tracked = True
instance._mtime = AMBIGUOUS_TIME instance._clean_p2 = True
return instance return instance
@classmethod @classmethod
def new_possibly_dirty(cls): def new_possibly_dirty(cls):
"""constructor to help legacy API to build a new "possibly_dirty" item """constructor to help legacy API to build a new "possibly_dirty" item
Should eventually be removed Should eventually be removed
""" """
instance = cls() instance = cls()
instance._state = b'n' instance._wc_tracked = True
instance._mode = 0 instance._p1_tracked = True
instance._size = NONNORMAL instance._possibly_dirty = True
instance._mtime = AMBIGUOUS_TIME
return instance return instance
@classmethod @classmethod
def new_normal(cls, mode, size, mtime): def new_normal(cls, mode, size, mtime):
"""constructor to help legacy API to build a new "normal" item """constructor to help legacy API to build a new "normal" item
Should eventually be removed Should eventually be removed
""" """
assert size != FROM_P2 assert size != FROM_P2
assert size != NONNORMAL assert size != NONNORMAL
instance = cls() instance = cls()
instance._state = b'n' instance._wc_tracked = True
instance._p1_tracked = True
instance._mode = mode instance._mode = mode
instance._size = size instance._size = size
instance._mtime = mtime instance._mtime = mtime
return instance return instance
@classmethod @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.
""" """
if state == b'm':
return cls.new_merged()
elif state == b'a':
return cls.new_added()
elif state == b'r':
instance = cls() instance = cls()
instance._state = state instance._wc_tracked = False
instance._mode = mode if size == NONNORMAL:
instance._size = size instance._merged = True
instance._mtime = mtime instance._p1_tracked = (
True # might not be True because of rename ?
)
instance._p2_tracked = (
True # might not be True because of rename ?
)
elif size == FROM_P2:
instance._clean_p2 = True
instance._p1_tracked = (
False # We actually don't know (file history)
)
instance._p2_tracked = True
else:
instance._p1_tracked = True
return instance return instance
elif state == b'n':
if size == FROM_P2:
return cls.new_from_p2()
elif size == NONNORMAL:
return cls.new_possibly_dirty()
elif mtime == AMBIGUOUS_TIME:
instance = cls.new_normal(mode, size, 42)
instance._mtime = None
instance._possibly_dirty = True
return instance
else:
return cls.new_normal(mode, size, mtime)
else:
raise RuntimeError(b'unknown state: %s' % state)
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._mtime = AMBIGUOUS_TIME 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)
size = 0 self._wc_tracked = False
if self.merged: # merge self._mode = None
size = NONNORMAL self._size = None
elif self.from_p2: self._mtime = None
size = FROM_P2
self._state = b'r'
self._mode = 0
self._size = size
self._mtime = 0
@property @property
def mode(self): def mode(self):
return self.v1_mode() return self.v1_mode()
@property @property
def size(self): def size(self):
return self.v1_size() return self.v1_size()
"""True is the entry is `otherparent` in the dirstatemap sense """True is the entry is `otherparent` in the dirstatemap sense
There is no reason for any code, but the dirstatemap one to use this. There is no reason for any code, but the dirstatemap one to use this.
""" """
return self.v1_size() == FROM_P2 return self.v1_size() == FROM_P2
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 if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
# the object has no state to record, this is -currently-
# unsupported
raise RuntimeError('untracked item')
elif not self._wc_tracked:
return b'r'
elif self._merged:
return b'm'
elif not (self._p1_tracked or self._p2_tracked) and self._wc_tracked:
return b'a'
elif self._clean_p2 and self._wc_tracked:
return b'n'
elif not self._p1_tracked and self._p2_tracked and self._wc_tracked:
return b'n'
elif self._possibly_dirty:
return b'n'
elif self._wc_tracked:
return b'n'
else:
raise RuntimeError('unreachable')
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 if self._mode is not None else 0
def v1_size(self): def v1_size(self):
"""return a "size" suitable for v1 serialization""" """return a "size" suitable for v1 serialization"""
if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
# the object has no state to record, this is -currently-
# unsupported
raise RuntimeError('untracked item')
elif not self._wc_tracked:
# File was deleted
if self._merged:
return NONNORMAL
elif self._clean_p2:
return FROM_P2
else:
return 0
elif self._merged:
return FROM_P2
elif not (self._p1_tracked or self._p2_tracked) and self._wc_tracked:
# Added
return NONNORMAL
elif self._clean_p2 and self._wc_tracked:
return FROM_P2
elif not self._p1_tracked and self._p2_tracked and self._wc_tracked:
return FROM_P2
elif self._possibly_dirty:
if self._size is None:
return NONNORMAL
else:
return self._size
elif self._wc_tracked:
return self._size return self._size
else:
raise RuntimeError('unreachable')
def v1_mtime(self): def v1_mtime(self):
"""return a "mtime" suitable for v1 serialization""" """return a "mtime" suitable for v1 serialization"""
if not (self._p1_tracked or self._p2_tracked or self._wc_tracked):
# the object has no state to record, this is -currently-
# unsupported
raise RuntimeError('untracked item')
elif not self._wc_tracked:
return 0
elif self._possibly_dirty:
return AMBIGUOUS_TIME
elif self._merged:
return AMBIGUOUS_TIME
elif not (self._p1_tracked or self._p2_tracked) and self._wc_tracked:
return AMBIGUOUS_TIME
elif self._clean_p2 and self._wc_tracked:
return AMBIGUOUS_TIME
elif not self._p1_tracked and self._p2_tracked and self._wc_tracked:
return AMBIGUOUS_TIME
elif self._wc_tracked:
if self._mtime is None:
return 0
else:
return self._mtime return self._mtime
else:
raise RuntimeError('unreachable')
def need_delay(self, now): def need_delay(self, now):
"""True if the stored mtime would be ambiguous with the current time""" """True if the stored mtime would be ambiguous with the current time"""
return self.v1_state() == b'n' and self.v1_mtime() == now return self.v1_state() == b'n' and self.v1_mtime() == now
def gettype(q): def gettype(q):
return int(q & 0xFFFF) return int(q & 0xFFFF)