mercurial: comparison mercurial/obsutil.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 encoding,
 node as nodemod,
 phases,
 util,
 )
-from .utils import (
+from .utils import dateutil
-dateutil,
-)
 ### obsolescence marker flag
 ## bumpedfix flag
 #
 # bumped version and fix the situation, breaking the transitivity of
 # "bumped" here.
 bumpedfix = 1
 usingsha256 = 2
 class marker(object):
 """Wrap obsolete marker raw data"""
 def __init__(self, repo, data):
 # the repo argument will be used to create changectx in later version
 return self._data[4]
 def flags(self):
 """The flags field of the marker"""
 return self._data[2]
 def getmarkers(repo, nodes=None, exclusive=False):
 """returns markers known in a repository
 If <nodes> is specified, only markers "relevant" to those nodes are are
 rawmarkers = repo.obsstore.relevantmarkers(nodes)
 for markerdata in rawmarkers:
 yield marker(repo, markerdata)
 def closestpredecessors(repo, nodeid):
 """yield the list of next predecessors pointing on visible changectx nodes
 This function respect the repoview filtering, filtered revision will be
 considered missing.
 if precnodeid in repo:
 yield precnodeid
 else:
 stack.append(precnodeid)
 def allpredecessors(obsstore, nodes, ignoreflags=0):
 """Yield node for every precursors of <nodes>.
 Some precursors may be unknown locally.
 continue
 suc = mark[0]
 if suc not in seen:
 seen.add(suc)
 remaining.add(suc)
 def allsuccessors(obsstore, nodes, ignoreflags=0):
 """Yield node for every successor of <nodes>.
 Some successors may be unknown locally.
 for suc in mark[1]:
 if suc not in seen:
 seen.add(suc)
 remaining.add(suc)
 def _filterprunes(markers):
 """return a set with no prune markers"""
 return set(m for m in markers if m[1])
 def exclusivemarkers(repo, nodes):
 """set of markers relevant to "nodes" but no other locally-known nodes
 This function compute the set of markers "exclusive" to a locally-known
 seennodes.add(prec)
 stack.append(prec)
 return exclmarkers
 def foreground(repo, nodes):
 """return all nodes in the "foreground" of other node
 The foreground of a revision is anything reachable using parent -> children
 or precursor -> successor relation. It is very similar to "descendant" but
 succs.update(allsuccessors(repo.obsstore, mutable))
 known = (n for n in succs if n in nm)
 foreground = set(repo.set('%ln::', known))
 return set(c.node() for c in foreground)
 # effectflag field
 #
 # Effect-flag is a 1-byte bit field used to store what changed between a
 # changeset and its successor(s).
 #
 # `effect-flags` set to off by default.
 #
 EFFECTFLAGFIELD = "ef1"
-DESCCHANGED = 1 << 0 # action changed the description
+DESCCHANGED = 1 << 0  # action changed the description
-METACHANGED = 1 << 1 # action change the meta
+METACHANGED = 1 << 1  # action change the meta
-DIFFCHANGED = 1 << 3 # action change diff introduced by the changeset
+DIFFCHANGED = 1 << 3  # action change diff introduced by the changeset
-PARENTCHANGED = 1 << 2 # action change the parent
+PARENTCHANGED = 1 << 2  # action change the parent
-USERCHANGED = 1 << 4 # the user changed
+USERCHANGED = 1 << 4  # the user changed
-DATECHANGED = 1 << 5 # the date changed
+DATECHANGED = 1 << 5  # the date changed
-BRANCHCHANGED = 1 << 6 # the branch changed
+BRANCHCHANGED = 1 << 6  # the branch changed
 METABLACKLIST = [
 re.compile('^branch$'),
 re.compile('^.*-source$'),
 re.compile('^.*_source$'),
 re.compile('^source$'),
 ]
 def metanotblacklisted(metaitem):
 """ Check that the key of a meta item (extrakey, extravalue) does not
 match at least one of the blacklist pattern
 """
 metakey = metaitem[0]
 return not any(pattern.match(metakey) for pattern in METABLACKLIST)
 def _prepare_hunk(hunk):
 """Drop all information but the username and patch"""
 cleanhunk = []
 for line in hunk.splitlines():
 if line.startswith(b'@@'):
 line = b'@@\n'
 cleanhunk.append(line)
 return cleanhunk
 def _getdifflines(iterdiff):
 """return a cleaned up lines"""
 lines = next(iterdiff, None)
 if lines is None:
 return lines
 return _prepare_hunk(lines)
 def _cmpdiff(leftctx, rightctx):
 """return True if both ctx introduce the "same diff"
 This is a first and basic implementation, with many shortcoming.
 if left != right:
 return False
 return True
 def geteffectflag(source, successors):
 """ From an obs-marker relation, compute what changed between the
 predecessor and the successor.
 """
 effects = 0
 # Check if the diff has changed
 if not _cmpdiff(source, changectx):
 effects |= DIFFCHANGED
 return effects
 def getobsoleted(repo, tr):
 """return the set of pre-existing revisions obsoleted by a transaction"""
 torev = repo.unfiltered().changelog.nodemap.get
 phase = repo._phasecache.phase
 continue
 if set(succsmarkers(node) or []).issubset(addedmarkers):
 obsoleted.add(rev)
 return obsoleted
 class _succs(list):
 """small class to represent a successors with some metadata about it"""
 def __init__(self, *args, **kwargs):
 super(_succs, self).__init__(*args, **kwargs)
 # immutable
 return set(self)
 def canmerge(self, other):
 return self._set.issubset(other._set)
 def successorssets(repo, initialnode, closest=False, cache=None):
 """Return set of all latest successors of initial nodes
 The successors set of a changeset A are the group of revisions that succeed
 #
 current = toproceed[-1]
 # case 2 condition is a bit hairy because of closest,
 # we compute it on its own
-case2condition =  ((current not in succmarkers)
+case2condition = (current not in succmarkers) or (
-or (closest and current != initialnode
+closest and current != initialnode and current in repo
-and current in repo))
+)
 if current in cache:
 # case (1): We already know the successors sets
 stackedset.remove(toproceed.pop())
 elif case2condition:
 markss = productresult
 succssets.extend(markss)
 # remove duplicated and subset
 seen = []
 final = []
-candidates = sorted((s for s in succssets if s),
+candidates = sorted(
-key=len, reverse=True)
+(s for s in succssets if s), key=len, reverse=True
+)
 for cand in candidates:
 for seensuccs in seen:
 if cand.canmerge(seensuccs):
 seensuccs.markers.update(cand.markers)
 break
 else:
 final.append(cand)
 seen.append(cand)
-final.reverse() # put small successors set first
+final.reverse()  # put small successors set first
 cache[current] = final
 return cache[initialnode]
 def successorsandmarkers(repo, ctx):
 """compute the raw data needed for computing obsfate
 Returns a list of dict, one dict per successors set
 """
 if ssets == []:
 ssets = [[]]
 # Try to recover pruned markers
 succsmap = repo.obsstore.successors
-fullsuccessorsets = [] # successor set + markers
+fullsuccessorsets = []  # successor set + markers
 for sset in ssets:
 if sset:
 fullsuccessorsets.append(sset)
 else:
 # successorsset return an empty set() when ctx or one of its
 for sset in fullsuccessorsets:
 values.append({'successors': sset, 'markers': sset.markers})
 return values
 def _getobsfate(successorssets):
 """ Compute a changeset obsolescence fate based on its successorssets.
 Successors can be the tipmost ones or the immediate ones. This function
 return values are not meant to be shown directly to users, it is meant to
 be used by internal functions only.
 if len(successors) == 1:
 return 'superseded'
 else:
 return 'superseded_split'
 def obsfateverb(successorset, markers):
 """ Return the verb summarizing the successorset and potentially using
 information from the markers
 """
 if not successorset:
 verb = 'rewritten'
 else:
 verb = 'split'
 return verb
 def markersdates(markers):
 """returns the list of dates for a list of markers
 """
 return [m[4] for m in markers]
 def markersusers(markers):
 """ Returns a sorted list of markers users without duplicates
 """
 markersmeta = [dict(m[3]) for m in markers]
-users = set(encoding.tolocal(meta['user']) for meta in markersmeta
+users = set(
-if meta.get('user'))
+encoding.tolocal(meta['user'])
+for meta in markersmeta
+if meta.get('user')
+)
 return sorted(users)
 def markersoperations(markers):
 """ Returns a sorted list of markers operations without duplicates
 """
 markersmeta = [dict(m[3]) for m in markers]
-operations = set(meta.get('operation') for meta in markersmeta
+operations = set(
-if meta.get('operation'))
+meta.get('operation') for meta in markersmeta if meta.get('operation')
+)
 return sorted(operations)
 def obsfateprinter(ui, repo, successors, markers, formatctx):
 """ Build a obsfate string for a single successorset using all obsfate
 related function defined in obsutil
 """
 filteredmsgtable = {
 "pruned": _("hidden revision '%s' is pruned"),
 "diverged": _("hidden revision '%s' has diverged"),
 "superseded": _("hidden revision '%s' was rewritten as: %s"),
 "superseded_split": _("hidden revision '%s' was split as: %s"),
-"superseded_split_several": _("hidden revision '%s' was split as: %s and "
+"superseded_split_several": _(
-"%d more"),
+"hidden revision '%s' was split as: %s and " "%d more"
+),
 }
 def _getfilteredreason(repo, changeid, ctx):
 """return a human-friendly string on why a obsolete changeset is hidden
 """
 successors = successorssets(repo, ctx.node())
 firstsuccessors = ', '.join(succs[:2])
 remainingnumber = len(succs) - 2
 args = (changeid, firstsuccessors, remainingnumber)
 return filteredmsgtable['superseded_split_several'] % args
 def divergentsets(repo, ctx):
 """Compute sets of commits divergent with a given one"""
 cache = {}
 base = {}
 continue
 if tuple(nsuccset) in base:
 # we already know the latest base for this divergency
 continue
 base[tuple(nsuccset)] = n
-return [{'divergentnodes': divset, 'commonpredecessor': b}
+return [
-for divset, b in base.iteritems()]
+{'divergentnodes': divset, 'commonpredecessor': b}
+for divset, b in base.iteritems()
+]
 def whyunstable(repo, ctx):
 result = []
 if ctx.orphan():
 for parent in ctx.parents():
 if parent.orphan():
 kind = 'orphan'
 elif parent.obsolete():
 kind = 'obsolete'
 if kind is not None:
-result.append({'instability': 'orphan',
+result.append(
-'reason': '%s parent' % kind,
+{
-'node': parent.hex()})
+'instability': 'orphan',
+'reason': '%s parent' % kind,
+'node': parent.hex(),
+}
+)
 if ctx.phasedivergent():
-predecessors = allpredecessors(repo.obsstore, [ctx.node()],
+predecessors = allpredecessors(
-ignoreflags=bumpedfix)
+repo.obsstore, [ctx.node()], ignoreflags=bumpedfix
-immutable = [repo[p] for p in predecessors
+)
-if p in repo and not repo[p].mutable()]
+immutable = [
+repo[p] for p in predecessors if p in repo and not repo[p].mutable()
+]
 for predecessor in immutable:
-result.append({'instability': 'phase-divergent',
+result.append(
-'reason': 'immutable predecessor',
+{
-'node': predecessor.hex()})
+'instability': 'phase-divergent',
+'reason': 'immutable predecessor',
+'node': predecessor.hex(),
+}
+)
 if ctx.contentdivergent():
 dsets = divergentsets(repo, ctx)
 for dset in dsets:
 divnodes = [repo[n] for n in dset['divergentnodes']]
-result.append({'instability': 'content-divergent',
+result.append(
-'divergentnodes': divnodes,
+{
-'reason': 'predecessor',
+'instability': 'content-divergent',
-'node': nodemod.hex(dset['commonpredecessor'])})
+'divergentnodes': divnodes,
+'reason': 'predecessor',
+'node': nodemod.hex(dset['commonpredecessor']),
+}
+)
 return result

changeset 43076	2372284d9457
parent 41713	9de6c4f61608
child 43077	687b865b95ad