mercurial: comparison mercurial/obsutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 augmented with obsolescence information.
 Beware that possible obsolescence cycle may result if complex situation.
 """
 repo = repo.unfiltered()
-foreground = set(repo.set('%ln::', nodes))
+foreground = set(repo.set(b'%ln::', nodes))
 if repo.obsstore:
 # We only need this complicated logic if there is obsolescence
 # XXX will probably deserve an optimised revset.
 nm = repo.changelog.nodemap
 plen = -1
 plen = len(foreground)
 succs = set(c.node() for c in foreground)
 mutable = [c.node() for c in foreground if c.mutable()]
 succs.update(allsuccessors(repo.obsstore, mutable))
 known = (n for n in succs if n in nm)
-foreground = set(repo.set('%ln::', known))
+foreground = set(repo.set(b'%ln::', known))
 return set(c.node() for c in foreground)
 # effectflag field
 #
 #
 # The effect-flag is placed behind an experimental flag
 # `effect-flags` set to off by default.
 #
-EFFECTFLAGFIELD = "ef1"
+EFFECTFLAGFIELD = b"ef1"
 DESCCHANGED = 1 << 0  # action changed the description
 METACHANGED = 1 << 1  # action change the meta
 DIFFCHANGED = 1 << 3  # action change diff introduced by the changeset
 PARENTCHANGED = 1 << 2  # action change the parent
 USERCHANGED = 1 << 4  # the user changed
 DATECHANGED = 1 << 5  # the date changed
 BRANCHCHANGED = 1 << 6  # the branch changed
 METABLACKLIST = [
-re.compile('^branch$'),
+re.compile(b'^branch$'),
-re.compile('^.*-source$'),
+re.compile(b'^.*-source$'),
-re.compile('^.*_source$'),
+re.compile(b'^.*_source$'),
-re.compile('^source$'),
+re.compile(b'^source$'),
 ]
 def metanotblacklisted(metaitem):
 """ Check that the key of a meta item (extrakey, extravalue) does not
 def _cmpdiff(leftctx, rightctx):
 """return True if both ctx introduce the "same diff"
 This is a first and basic implementation, with many shortcoming.
 """
-diffopts = diffutil.diffallopts(leftctx.repo().ui, {'git': True})
+diffopts = diffutil.diffallopts(leftctx.repo().ui, {b'git': True})
 # Leftctx or right ctx might be filtered, so we need to use the contexts
 # with an unfiltered repository to safely compute the diff
 # leftctx and rightctx can be from different repository views in case of
 """return the set of pre-existing revisions obsoleted by a transaction"""
 torev = repo.unfiltered().changelog.nodemap.get
 phase = repo._phasecache.phase
 succsmarkers = repo.obsstore.successors.get
 public = phases.public
-addedmarkers = tr.changes['obsmarkers']
+addedmarkers = tr.changes[b'obsmarkers']
-origrepolen = tr.changes['origrepolen']
+origrepolen = tr.changes[b'origrepolen']
 seenrevs = set()
 obsoleted = set()
 for mark in addedmarkers:
 node = mark[0]
 rev = torev(node)
 if not foundany:
 fullsuccessorsets.append(_succs())
 values = []
 for sset in fullsuccessorsets:
-values.append({'successors': sset, 'markers': sset.markers})
+values.append({b'successors': sset, b'markers': sset.markers})
 return values
 def _getobsfate(successorssets):
 - superseded_split
 """
 if len(successorssets) == 0:
 # The commit has been pruned
-return 'pruned'
+return b'pruned'
 elif len(successorssets) > 1:
-return 'diverged'
+return b'diverged'
 else:
 # No divergence, only one set of successors
 successors = successorssets[0]
 if len(successors) == 1:
-return 'superseded'
+return b'superseded'
 else:
-return 'superseded_split'
+return b'superseded_split'
 def obsfateverb(successorset, markers):
 """ Return the verb summarizing the successorset and potentially using
 information from the markers
 """
 if not successorset:
-verb = 'pruned'
+verb = b'pruned'
 elif len(successorset) == 1:
-verb = 'rewritten'
+verb = b'rewritten'
 else:
-verb = 'split'
+verb = b'split'
 return verb
 def markersdates(markers):
 """returns the list of dates for a list of 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'])
+encoding.tolocal(meta[b'user'])
 for meta in markersmeta
-if meta.get('user')
+if meta.get(b'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 if meta.get('operation')
+meta.get(b'operation') for meta in markersmeta if meta.get(b'operation')
 )
 return sorted(operations)
 line.append(obsfateverb(successors, markers))
 # Operations
 operations = markersoperations(markers)
 if operations:
-line.append(" using %s" % ", ".join(operations))
+line.append(b" using %s" % b", ".join(operations))
 # Successors
 if successors:
 fmtsuccessors = [formatctx(repo[succ]) for succ in successors]
-line.append(" as %s" % ", ".join(fmtsuccessors))
+line.append(b" as %s" % b", ".join(fmtsuccessors))
 # Users
 users = markersusers(markers)
 # Filter out current user in not verbose mode to reduce amount of
 # information
 currentuser = ui.username(acceptempty=True)
 if len(users) == 1 and currentuser in users:
 users = None
 if (verbose or normal) and users:
-line.append(" by %s" % ", ".join(users))
+line.append(b" by %s" % b", ".join(users))
 # Date
 dates = markersdates(markers)
 if dates and verbose:
 min_date = min(dates)
 max_date = max(dates)
 if min_date == max_date:
-fmtmin_date = dateutil.datestr(min_date, '%Y-%m-%d %H:%M %1%2')
+fmtmin_date = dateutil.datestr(min_date, b'%Y-%m-%d %H:%M %1%2')
-line.append(" (at %s)" % fmtmin_date)
+line.append(b" (at %s)" % fmtmin_date)
 else:
-fmtmin_date = dateutil.datestr(min_date, '%Y-%m-%d %H:%M %1%2')
+fmtmin_date = dateutil.datestr(min_date, b'%Y-%m-%d %H:%M %1%2')
-fmtmax_date = dateutil.datestr(max_date, '%Y-%m-%d %H:%M %1%2')
+fmtmax_date = dateutil.datestr(max_date, b'%Y-%m-%d %H:%M %1%2')
-line.append(" (between %s and %s)" % (fmtmin_date, fmtmax_date))
+line.append(b" (between %s and %s)" % (fmtmin_date, fmtmax_date))
-return "".join(line)
+return b"".join(line)
 filteredmsgtable = {
-"pruned": _("hidden revision '%s' is pruned"),
+b"pruned": _(b"hidden revision '%s' is pruned"),
-"diverged": _("hidden revision '%s' has diverged"),
+b"diverged": _(b"hidden revision '%s' has diverged"),
-"superseded": _("hidden revision '%s' was rewritten as: %s"),
+b"superseded": _(b"hidden revision '%s' was rewritten as: %s"),
-"superseded_split": _("hidden revision '%s' was split as: %s"),
+b"superseded_split": _(b"hidden revision '%s' was split as: %s"),
-"superseded_split_several": _(
+b"superseded_split_several": _(
-"hidden revision '%s' was split as: %s and " "%d more"
+b"hidden revision '%s' was split as: %s and " b"%d more"
 ),
 }
 def _getfilteredreason(repo, changeid, ctx):
 """
 successors = successorssets(repo, ctx.node())
 fate = _getobsfate(successors)
 # Be more precise in case the revision is superseded
-if fate == 'pruned':
+if fate == b'pruned':
-return filteredmsgtable['pruned'] % changeid
+return filteredmsgtable[b'pruned'] % changeid
-elif fate == 'diverged':
+elif fate == b'diverged':
-return filteredmsgtable['diverged'] % changeid
+return filteredmsgtable[b'diverged'] % changeid
-elif fate == 'superseded':
+elif fate == b'superseded':
 single_successor = nodemod.short(successors[0][0])
-return filteredmsgtable['superseded'] % (changeid, single_successor)
+return filteredmsgtable[b'superseded'] % (changeid, single_successor)
-elif fate == 'superseded_split':
+elif fate == b'superseded_split':
 succs = []
 for node_id in successors[0]:
 succs.append(nodemod.short(node_id))
 if len(succs) <= 2:
-fmtsuccs = ', '.join(succs)
+fmtsuccs = b', '.join(succs)
-return filteredmsgtable['superseded_split'] % (changeid, fmtsuccs)
+return filteredmsgtable[b'superseded_split'] % (changeid, fmtsuccs)
 else:
-firstsuccessors = ', '.join(succs[:2])
+firstsuccessors = b', '.join(succs[:2])
 remainingnumber = len(succs) - 2
 args = (changeid, firstsuccessors, remainingnumber)
-return filteredmsgtable['superseded_split_several'] % args
+return filteredmsgtable[b'superseded_split_several'] % args
 def divergentsets(repo, ctx):
 """Compute sets of commits divergent with a given one"""
 cache = {}
 if tuple(nsuccset) in base:
 # we already know the latest base for this divergency
 continue
 base[tuple(nsuccset)] = n
 return [
-{'divergentnodes': divset, 'commonpredecessor': b}
+{b'divergentnodes': divset, b'commonpredecessor': b}
 for divset, b in base.iteritems()
 ]
 def whyunstable(repo, ctx):
 result = []
 if ctx.orphan():
 for parent in ctx.parents():
 kind = None
 if parent.orphan():
-kind = 'orphan'
+kind = b'orphan'
 elif parent.obsolete():
-kind = 'obsolete'
+kind = b'obsolete'
 if kind is not None:
 result.append(
 {
-'instability': 'orphan',
+b'instability': b'orphan',
-'reason': '%s parent' % kind,
+b'reason': b'%s parent' % kind,
-'node': parent.hex(),
+b'node': parent.hex(),
 }
 )
 if ctx.phasedivergent():
 predecessors = allpredecessors(
 repo.obsstore, [ctx.node()], ignoreflags=bumpedfix
 repo[p] for p in predecessors if p in repo and not repo[p].mutable()
 ]
 for predecessor in immutable:
 result.append(
 {
-'instability': 'phase-divergent',
+b'instability': b'phase-divergent',
-'reason': 'immutable predecessor',
+b'reason': b'immutable predecessor',
-'node': predecessor.hex(),
+b'node': predecessor.hex(),
 }
 )
 if ctx.contentdivergent():
 dsets = divergentsets(repo, ctx)
 for dset in dsets:
-divnodes = [repo[n] for n in dset['divergentnodes']]
+divnodes = [repo[n] for n in dset[b'divergentnodes']]
 result.append(
 {
-'instability': 'content-divergent',
+b'instability': b'content-divergent',
-'divergentnodes': divnodes,
+b'divergentnodes': divnodes,
-'reason': 'predecessor',
+b'reason': b'predecessor',
-'node': nodemod.hex(dset['commonpredecessor']),
+b'node': nodemod.hex(dset[b'commonpredecessor']),
 }
 )
 return result

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43106	d783f945a701