This is an archive of the discontinued Mercurial Phabricator instance.

Differential D245

obsstore: rename precursors into predecessors
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd5acd967f95a: obsstore: rename precursors into predecessors
Summary

Use util.nouideprecwarn because obsstore doesn't have easy access to an ui
object.

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

Event Timeline

lothiraldan created this revision.Aug 7 2017, 6:08 AM
dsp added a subscriber: dsp.Aug 8 2017, 11:54 AM
dsp added inline comments.
mercurial/obsutil.py
210

should this be called predecessormarkers?

lothiraldan added inline comments.Aug 8 2017, 12:20 PM
mercurial/obsutil.py
210

Ideally yes.

I wanted to limit this series to external impacting changes only (either output or API changes) so extensions and tests could be updated once and for all.

I plan to do variables renaming in a later series as they won't involve test changing or extensions breaking.

Closed by commit rHGd5acd967f95a: obsstore: rename precursors into predecessors (authored by lothiraldan). · Explain WhyAug 9 2017, 11:36 AM
This revision was automatically updated to reflect the committed changes.
lothiraldan updated this revision to Diff 707.Aug 9 2017, 1:19 PM

Revision Contents
Changeset List

PathPackages
Mmercurial/obsolete.py (20 lines)
Mmercurial/obsutil.py (6 lines)

Diff 707

mercurial/obsolete.py

return markers return markers
@propertycache @propertycache
def successors(self): def successors(self):
successors = {} successors = {}
_addsuccessors(successors, self._all) _addsuccessors(successors, self._all)
return successors return successors
@propertycache @property
def precursors(self): def precursors(self):
msg = ("'obsstore.precursors' is deprecated, "
"use 'obsstore.predecessors'")
util.nouideprecwarn(msg, '4.4')
return self.predecessors
@propertycache
def predecessors(self):
predecessors = {} predecessors = {}
_addpredecessors(predecessors, self._all) _addpredecessors(predecessors, self._all)
return predecessors return predecessors
@propertycache @propertycache
def children(self): def children(self):
children = {} children = {}
_addchildren(children, self._all) _addchildren(children, self._all)
return children return children
def _cached(self, attr): def _cached(self, attr):
return attr in self.__dict__ return attr in self.__dict__
def _addmarkers(self, markers, rawdata): def _addmarkers(self, markers, rawdata):
markers = list(markers) # to allow repeated iteration markers = list(markers) # to allow repeated iteration
self._data = self._data + rawdata self._data = self._data + rawdata
self._all.extend(markers) self._all.extend(markers)
if self._cached('successors'): if self._cached('successors'):
_addsuccessors(self.successors, markers) _addsuccessors(self.successors, markers)
if self._cached('precursors'): if self._cached('predecessors'):
_addpredecessors(self.precursors, markers) _addpredecessors(self.predecessors, markers)
if self._cached('children'): if self._cached('children'):
_addchildren(self.children, markers) _addchildren(self.children, markers)
_checkinvalidmarkers(markers) _checkinvalidmarkers(markers)
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 precursors 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.precursors precursorsmarkers = self.predecessors
succsmarkers = self.successors succsmarkers = self.successors
children = self.children children = self.children
while pendingnodes: while pendingnodes:
direct = set() direct = set()
for current in pendingnodes: for current in pendingnodes:
direct.update(precursorsmarkers.get(current, ())) direct.update(precursorsmarkers.get(current, ()))
pruned = [m for m in children.get(current, ()) if not m[1]] pruned = [m for m in children.get(current, ()) if not m[1]]
direct.update(pruned) direct.update(pruned)
@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.
""" """
divergent = set() divergent = set()
obsstore = repo.obsstore obsstore = repo.obsstore
newermap = {} newermap = {}
for ctx in repo.set('(not public()) - obsolete()'): for ctx in repo.set('(not public()) - obsolete()'):
mark = obsstore.precursors.get(ctx.node(), ()) mark = obsstore.predecessors.get(ctx.node(), ())
toprocess = set(mark) toprocess = set(mark)
seen = set() seen = set()
while toprocess: while toprocess:
prec = toprocess.pop()[0] prec = toprocess.pop()[0]
if prec in seen: if prec in seen:
continue # emergency cycle hanging prevention continue # emergency cycle hanging prevention
seen.add(prec) seen.add(prec)
if prec not in newermap: if prec not in newermap:
obsutil.successorssets(repo, prec, cache=newermap) obsutil.successorssets(repo, prec, cache=newermap)
newer = [n for n in newermap[prec] if n] newer = [n for n in newermap[prec] if n]
if len(newer) > 1: if len(newer) > 1:
divergent.add(ctx.rev()) divergent.add(ctx.rev())
break break
toprocess.update(obsstore.precursors.get(prec, ())) toprocess.update(obsstore.predecessors.get(prec, ()))
return divergent return divergent
def createmarkers(repo, relations, flag=0, date=None, metadata=None, def createmarkers(repo, relations, flag=0, date=None, metadata=None,
operation=None): operation=None):
"""Add obsolete markers between changesets in a repo """Add obsolete markers between changesets in a repo
<relations> must be an iterable of (<old>, (<new>, ...)[,{metadata}]) <relations> must be an iterable of (<old>, (<new>, ...)[,{metadata}])

mercurial/obsutil.py

def closestpredecessors(repo, nodeid): def closestpredecessors(repo, nodeid):
"""yield the list of next predecessors pointing on visible changectx nodes """yield the list of next predecessors pointing on visible changectx nodes
This function respect the repoview filtering, filtered revision will be This function respect the repoview filtering, filtered revision will be
considered missing. considered missing.
""" """
precursors = repo.obsstore.precursors precursors = repo.obsstore.predecessors
stack = [nodeid] stack = [nodeid]
seen = set(stack) seen = set(stack)
while stack: while stack:
current = stack.pop() current = stack.pop()
currentpreccs = precursors.get(current, ()) currentpreccs = precursors.get(current, ())
for prec in currentpreccs: for prec in currentpreccs:
This is a linear yield unsuited to detecting folded changesets. It includes This is a linear yield unsuited to detecting folded changesets. It includes
initial nodes too.""" initial nodes too."""
remaining = set(nodes) remaining = set(nodes)
seen = set(remaining) seen = set(remaining)
while remaining: while remaining:
current = remaining.pop() current = remaining.pop()
yield current yield current
for mark in obsstore.precursors.get(current, ()): for mark in obsstore.predecessors.get(current, ()):
# ignore marker flagged with specified flag # ignore marker flagged with specified flag
if mark[2] & ignoreflags: if mark[2] & ignoreflags:
continue continue
suc = mark[0] suc = mark[0]
if suc not in seen: if suc not in seen:
seen.add(suc) seen.add(suc)
remaining.add(suc) remaining.add(suc)
the pruned changesets. the pruned changesets.
""" """
# running on a filtered repository would be dangerous as markers could be # running on a filtered repository would be dangerous as markers could be
# reported as exclusive when they are relevant for other filtered nodes. # reported as exclusive when they are relevant for other filtered nodes.
unfi = repo.unfiltered() unfi = repo.unfiltered()
# shortcut to various useful item # shortcut to various useful item
nm = unfi.changelog.nodemap nm = unfi.changelog.nodemap
precursorsmarkers = unfi.obsstore.precursors precursorsmarkers = unfi.obsstore.predecessors
dspUnsubmitted
Not Done

should this be called predecessormarkers?

dsp: should this be called `predecessormarkers`?
lothiraldanAuthorUnsubmitted
Not Done

Ideally yes.

I wanted to limit this series to external impacting changes only (either output or API changes) so extensions and tests could be updated once and for all.

I plan to do variables renaming in a later series as they won't involve test changing or extensions breaking.

lothiraldan: Ideally yes. I wanted to limit this series to external impacting changes only (either output…
successormarkers = unfi.obsstore.successors successormarkers = unfi.obsstore.successors
childrenmarkers = unfi.obsstore.children childrenmarkers = unfi.obsstore.children
# exclusive markers (return of the function) # exclusive markers (return of the function)
exclmarkers = set() exclmarkers = set()
# we need fast membership testing # we need fast membership testing
nodes = set(nodes) nodes = set(nodes)
# looking for head in the obshistory # looking for head in the obshistory