( )⚙ D246 obsolete: rename precursor into predecessor in obsolete docstrings

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D246

obsolete: rename precursor into predecessor in obsolete docstrings
ClosedPublic

Authored by lothiraldan on Aug 7 2017, 6:09 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG0c3112f17610: obsolete: rename precursor into predecessor in obsolete docstrings
Summary

The renaming is done according to
https://www.mercurial-scm.org/wiki/CEDVocabulary.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/obsolete.py (27 lines)

Diff 591

mercurial/obsolete.py

Obsolete markers can be used to record and distribute changeset graph Obsolete markers can be used to record and distribute changeset graph
transformations performed by history rewrite operations, and help transformations performed by history rewrite operations, and help
building new tools to reconcile conflicting rewrite actions. To building new tools to reconcile conflicting rewrite actions. To
facilitate conflict resolution, markers include various annotations facilitate conflict resolution, markers include various annotations
besides old and news changeset identifiers, such as creation date or besides old and news changeset identifiers, such as creation date or
author name. author name.
The old obsoleted changeset is called a "precursor" and possible The old obsoleted changeset is called a "predecessor" and possible
replacements are called "successors". Markers that used changeset X as replacements are called "successors". Markers that used changeset X as
a precursor are called "successor markers of X" because they hold a predecessor are called "successor markers of X" because they hold
information about the successors of X. Markers that use changeset Y as information about the successors of X. Markers that use changeset Y as
a successors are call "precursor markers of Y" because they hold a successors are call "predecessor markers of Y" because they hold
information about the precursors of Y. information about the predecessors of Y.
Examples: Examples:
- When changeset A is replaced by changeset A', one marker is stored: - When changeset A is replaced by changeset A', one marker is stored:
(A, (A',)) (A, (A',))
- When changesets A and B are folded into a new changeset C, two markers are - When changesets A and B are folded into a new changeset C, two markers are
# #
# 0: parents data stored but no parent, # 0: parents data stored but no parent,
# 1: one parent stored, # 1: one parent stored,
# 2: two parents stored, # 2: two parents stored,
# 3: no parent data stored # 3: no parent data stored
# #
# - uint8: number of metadata entries M # - uint8: number of metadata entries M
# #
# - 20 or 32 bytes: precursor changeset identifier. # - 20 or 32 bytes: predecessor changeset identifier.
# #
# - N*(20 or 32) bytes: successors changesets identifiers. # - N*(20 or 32) bytes: successors changesets identifiers.
# #
# - P*(20 or 32) bytes: parents of the precursors changesets. # - P*(20 or 32) bytes: parents of the predecessors changesets.
# #
# - M*(uint8, uint8): size of all metadata entries (key and value) # - M*(uint8, uint8): size of all metadata entries (key and value)
# #
# - remaining bytes: the metadata, each (key, value) pair after the other. # - remaining bytes: the metadata, each (key, value) pair after the other.
_fm1version = 1 _fm1version = 1
_fm1fixed = '>IdhHBBB20s' _fm1fixed = '>IdhHBBB20s'
_fm1nodesha1 = '20s' _fm1nodesha1 = '20s'
_fm1nodesha256 = '32s' _fm1nodesha256 = '32s'
if node.nullid in mark[1]: if node.nullid in mark[1]:
raise error.Abort(_('bad obsolescence marker detected: ' raise error.Abort(_('bad obsolescence marker detected: '
'invalid successors nullid')) 'invalid successors nullid'))
class obsstore(object): class obsstore(object):
"""Store obsolete markers """Store obsolete markers
Markers can be accessed with two mappings: Markers can be accessed with two mappings:
- precursors[x] -> set(markers on precursors edges of x) - predecessors[x] -> set(markers on predecessors edges of x)
- successors[x] -> set(markers on successors edges of x) - successors[x] -> set(markers on successors edges of x)
- children[x] -> set(markers on precursors edges of children(x) - children[x] -> set(markers on predecessors edges of children(x)
""" """
fields = ('prec', 'succs', 'flag', 'meta', 'date', 'parents') fields = ('prec', 'succs', 'flag', 'meta', 'date', 'parents')
# prec: nodeid, precursor changesets # prec: nodeid, predecessors changesets
# succs: tuple of nodeid, successor changesets (0-N length) # succs: tuple of nodeid, successor changesets (0-N length)
# flag: integer, flag field carrying modifier for the markers (see doc) # flag: integer, flag field carrying modifier for the markers (see doc)
# meta: binary blob, encoded metadata dictionary # meta: binary blob, encoded metadata dictionary
# date: (float, int) tuple, date of marker creation # date: (float, int) tuple, date of marker creation
# parents: (tuple of nodeid) or None, parents of precursors # parents: (tuple of nodeid) or None, parents of predecessors
# None is used when no data has been recorded # None is used when no data has been recorded
def __init__(self, svfs, defaultformat=_fm1version, readonly=False): def __init__(self, svfs, defaultformat=_fm1version, readonly=False):
# caches for various obsolescence related cache # caches for various obsolescence related cache
self.caches = {} self.caches = {}
self.svfs = svfs self.svfs = svfs
self._defaultformat = defaultformat self._defaultformat = defaultformat
self._readonly = readonly self._readonly = readonly
def relevantmarkers(self, nodes): def relevantmarkers(self, nodes):
"""return a set of all obsolescence markers relevant to a set of nodes. """return a set of all obsolescence markers relevant to a set of nodes.
"relevant" to a set of nodes mean: "relevant" to a set of nodes mean:
- marker that use this changeset as successor - marker that use this changeset as successor
- prune marker of direct children on this changeset - prune marker of direct children on this changeset
- recursive application of the two rules on precursors of these markers - recursive application of the two rules on predecessors of these
markers
It is a set so you cannot rely on order.""" It is a set so you cannot rely on order."""
pendingnodes = set(nodes) pendingnodes = set(nodes)
seenmarkers = set() seenmarkers = set()
seennodes = set(pendingnodes) seennodes = set(pendingnodes)
precursorsmarkers = self.predecessors precursorsmarkers = self.predecessors
succsmarkers = self.successors succsmarkers = self.successors
phase = repo._phasecache.phase # would be faster to grab the full list phase = repo._phasecache.phase # would be faster to grab the full list
public = phases.public public = phases.public
cl = repo.changelog cl = repo.changelog
torev = cl.nodemap.get torev = cl.nodemap.get
for ctx in repo.set('(not public()) and (not obsolete())'): for ctx in repo.set('(not public()) and (not obsolete())'):
rev = ctx.rev() rev = ctx.rev()
# We only evaluate mutable, non-obsolete revision # We only evaluate mutable, non-obsolete revision
node = ctx.node() node = ctx.node()
# (future) A cache of precursors may worth if split is very common # (future) A cache of predecessors may worth if split is very common
for pnode in obsutil.allprecursors(repo.obsstore, [node], for pnode in obsutil.allprecursors(repo.obsstore, [node],
ignoreflags=bumpedfix): ignoreflags=bumpedfix):
prev = torev(pnode) # unfiltered! but so is phasecache prev = torev(pnode) # unfiltered! but so is phasecache
if (prev is not None) and (phase(repo, prev) <= public): if (prev is not None) and (phase(repo, prev) <= public):
# we have a public precursor # we have a public predecessor
bumped.add(rev) bumped.add(rev)
break # Next draft! break # Next draft!
return bumped return bumped
@cachefor('divergent') @cachefor('divergent')
def _computedivergentset(repo): def _computedivergentset(repo):
"""the set of rev that compete to be the final successors of some revision. """the set of rev that compete to be the final successors of some revision.
""" """