evolve: comparison hgext3rd/evolve/obshistory.py

equal deleted inserted replaced

-:67567d7f1174
+:48b30ff742cb
 )
 eh = exthelper.exthelper()
 # Config
-efd = {'default': True} # pass a default value unless the config is registered
+efd = {b'default': True} # pass a default value unless the config is registered
 @eh.extsetup
 def enableeffectflags(ui):
 item = (getattr(ui, '_knownconfig', {})
-.get('experimental', {})
+.get(b'experimental', {})
-.get('evolution.effect-flags'))
+.get(b'evolution.effect-flags'))
 if item is not None:
 item.default = True
 efd.clear()
 @eh.command(
 Paths in the DAG are represented with '|', '/' and so forth.
 Returns 0 on success.
 """
-ui.pager('obslog')
+ui.pager(b'obslog')
 revs = list(revs) + opts['rev']
 if not revs:
-revs = ['.']
+revs = [b'.']
 revs = scmutil.revrange(repo, revs)
 if opts['graph']:
 return _debugobshistorygraph(ui, repo, revs, opts)
 if not foundany:
 fullsuccessorsets.append(compat._succs())
 values = []
 for sset in fullsuccessorsets:
-values.append({'successors': sset, 'markers': sset.markers})
+values.append({b'successors': sset, b'markers': sset.markers})
 return values
 class obsmarker_printer(compat.changesetprinter):
 """show (available) information about a node
 super(obsmarker_printer, self).__init__(ui, repo, *args, **kwargs)
 diffopts = kwargs.get('diffopts', {})
 # Compat 4.6
 if not util.safehasattr(self, "_includediff"):
-self._includediff = diffopts and diffopts.get('patch')
+self._includediff = diffopts and diffopts.get(b'patch')
-self.template = diffopts and diffopts.get('template')
+self.template = diffopts and diffopts.get(b'template')
-self.filter = diffopts and diffopts.get('filternonlocal')
+self.filter = diffopts and diffopts.get(b'filternonlocal')
 def show(self, ctx, copies=None, matchfn=None, **props):
 if self.buffered:
 self.ui.pushbuffer(labeled=True)
 changenode = ctx.node()
-_props = {"template": self.template}
+_props = {b"template": self.template}
-fm = self.ui.formatter('debugobshistory', _props)
+fm = self.ui.formatter(b'debugobshistory', _props)
 _debugobshistorydisplaynode(fm, self.repo, changenode)
-markerfm = fm.nested("markers")
+markerfm = fm.nested(b"markers")
 # Succs markers
 if self.filter is False:
 succs = self.repo.obsstore.successors.get(changenode, ())
 succs = sorted(succs)
 else:
 r = _successorsandmarkers(self.repo, ctx)
 for succset in sorted(r):
-markers = succset["markers"]
+markers = succset[b"markers"]
 if not markers:
 continue
-successors = succset["successors"]
+successors = succset[b"successors"]
 _debugobshistorydisplaysuccsandmarkers(markerfm, successors, markers, ctx.node(), self.repo, self._includediff)
 markerfm.end()
-markerfm.plain('\n')
+markerfm.plain(b'\n')
 fm.end()
 self.hunk[ctx.node()] = self.ui.popbuffer()
 else:
 ### graph output is buffered only
-msg = 'cannot be used outside of the graphlog (yet)'
+msg = b'cannot be used outside of the graphlog (yet)'
 raise error.ProgrammingError(msg)
 def flush(self, ctx):
 ''' changeset_printer has some logic around buffering data
 in self.headers that we don't use
 '''
 pass
 def patchavailable(node, repo, successors):
 if node not in repo:
-return False, "context is not local"
+return False, b"context is not local"
 if len(successors) == 0:
-return False, "no successors"
+return False, b"no successors"
 elif len(successors) > 1:
-return False, "too many successors (%d)" % len(successors)
+return False, b"too many successors (%d)" % len(successors)
 succ = successors[0]
 if succ not in repo:
-return False, "successor is unknown locally"
+return False, b"successor is unknown locally"
 # Check that both node and succ have the same parents
 nodep1, nodep2 = repo[node].p1(), repo[node].p2()
 succp1, succp2 = repo[succ].p1(), repo[succ].p2()
 if nodep1 != succp1 or nodep2 != succp2:
-return False, "changesets rebased"
+return False, b"changesets rebased"
 return True, succ
 def getmarkerdescriptionpatch(repo, basedesc, succdesc):
 # description are stored without final new line,
 # add one to avoid ugly diff
-basedesc += '\n'
+basedesc += b'\n'
-succdesc += '\n'
+succdesc += b'\n'
 # fake file name
-basename = "changeset-description"
+basename = b"changeset-description"
-succname = "changeset-description"
+succname = b"changeset-description"
 d = compat.strdiff(basedesc, succdesc, basename, succname)
 uheaders, hunks = d
 # Copied from patch.diff
-text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
+text = b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
-patch = "\n".join(uheaders + [text])
+patch = b"\n".join(uheaders + [text])
 return patch
 class missingchangectx(object):
 ''' a minimal object mimicking changectx for change contexts
 assert cycle
 # Then choose a random node from the cycle
 breaknode = sorted(cycle)[0]
 # And display it by force
-repo.ui.debug('obs-cycle detected, forcing display of %s\n'
+repo.ui.debug(b'obs-cycle detected, forcing display of %s\n'
 % nodemod.short(breaknode))
 validcandidates = [breaknode]
 # Display all valid candidates
 for cand in sorted(validcandidates):
 compat.displaygraph(ui, repo, walker, displayer, edges)
 def _debugobshistoryrevs(ui, repo, revs, opts):
 """ Display the obsolescence history for revset
 """
-fm = ui.formatter('debugobshistory', pycompat.byteskwargs(opts))
+fm = ui.formatter(b'debugobshistory', pycompat.byteskwargs(opts))
 precursors = repo.obsstore.predecessors
 successors = repo.obsstore.successors
 nodec = repo.changelog.node
 unfi = repo.unfiltered()
 nodes = [nodec(r) for r in revs]
 _debugobshistorydisplaynode(fm, unfi, ctxnode)
 succs = successors.get(ctxnode, ())
-markerfm = fm.nested("markers")
+markerfm = fm.nested(b"markers")
 for successor in sorted(succs):
 includediff = opts and opts.get("patch")
 _debugobshistorydisplaymarker(markerfm, successor, ctxnode, unfi, includediff)
 markerfm.end()
 shortdescription = ctx.description().strip()
 if shortdescription:
 shortdescription = shortdescription.splitlines()[0]
 fm.startitem()
-fm.write('node', '%s', bytes(ctx),
+fm.write(b'node', b'%s', bytes(ctx),
-label="evolve.node")
+label=b"evolve.node")
-fm.plain(' ')
+fm.plain(b' ')
-fm.write('rev', '(%d)', ctx.rev(),
+fm.write(b'rev', b'(%d)', ctx.rev(),
-label="evolve.rev")
+label=b"evolve.rev")
-fm.plain(' ')
+fm.plain(b' ')
-fm.write('shortdescription', '%s', shortdescription,
+fm.write(b'shortdescription', b'%s', shortdescription,
-label="evolve.short_description")
+label=b"evolve.short_description")
-fm.plain('\n')
+fm.plain(b'\n')
 def _debugobshistorydisplaymissingctx(fm, nodewithoutctx):
 hexnode = nodemod.short(nodewithoutctx)
 fm.startitem()
-fm.write('node', '%s', hexnode,
+fm.write(b'node', b'%s', hexnode,
-label="evolve.node evolve.missing_change_ctx")
+label=b"evolve.node evolve.missing_change_ctx")
-fm.plain('\n')
+fm.plain(b'\n')
 def _debugobshistorydisplaymarker(fm, marker, node, repo, includediff=False):
 succnodes = marker[1]
 date = marker[4]
 metadata = dict(marker[3])
 fm.startitem()
-fm.plain('  ')
+fm.plain(b'  ')
 # Detect pruned revisions
 if len(succnodes) == 0:
-verb = 'pruned'
+verb = b'pruned'
 else:
-verb = 'rewritten'
+verb = b'rewritten'
-fm.write('verb', '%s', verb,
+fm.write(b'verb', b'%s', verb,
-label="evolve.verb")
+label=b"evolve.verb")
-effectflag = metadata.get('ef1')
+effectflag = metadata.get(b'ef1')
 if effectflag is not None:
 try:
 effectflag = int(effectflag)
 except ValueError:
 effectflag = None
 if effectflag:
 effect = []
 # XXX should be a dict
 if effectflag & DESCCHANGED:
-effect.append('description')
+effect.append(b'description')
 if effectflag & METACHANGED:
-effect.append('meta')
+effect.append(b'meta')
 if effectflag & USERCHANGED:
-effect.append('user')
+effect.append(b'user')
 if effectflag & DATECHANGED:
-effect.append('date')
+effect.append(b'date')
 if effectflag & BRANCHCHANGED:
-effect.append('branch')
+effect.append(b'branch')
 if effectflag & PARENTCHANGED:
-effect.append('parent')
+effect.append(b'parent')
 if effectflag & DIFFCHANGED:
-effect.append('content')
+effect.append(b'content')
 if effect:
-fmteffect = fm.formatlist(effect, 'effect', sep=', ')
+fmteffect = fm.formatlist(effect, b'effect', sep=b', ')
-fm.write('effect', '(%s)', fmteffect)
+fm.write(b'effect', b'(%s)', fmteffect)
 if len(succnodes) > 0:
-fm.plain(' as ')
+fm.plain(b' as ')
 shortsnodes = (nodemod.short(succnode) for succnode in sorted(succnodes))
-nodes = fm.formatlist(shortsnodes, 'succnodes', sep=', ')
+nodes = fm.formatlist(shortsnodes, b'succnodes', sep=b', ')
-fm.write('succnodes', '%s', nodes,
+fm.write(b'succnodes', b'%s', nodes,
-label="evolve.node")
+label=b"evolve.node")
-operation = metadata.get('operation')
+operation = metadata.get(b'operation')
 if operation:
-fm.plain(' using ')
+fm.plain(b' using ')
-fm.write('operation', '%s', operation, label="evolve.operation")
+fm.write(b'operation', b'%s', operation, label=b"evolve.operation")
-fm.plain(' by ')
+fm.plain(b' by ')
-fm.write('user', '%s', metadata['user'],
+fm.write(b'user', b'%s', metadata[b'user'],
-label="evolve.user")
+label=b"evolve.user")
-fm.plain(' ')
+fm.plain(b' ')
-fm.write('date', '(%s)', fm.formatdate(date),
+fm.write(b'date', b'(%s)', fm.formatdate(date),
-label="evolve.date")
+label=b"evolve.date")
 # initial support for showing note
-if metadata.get('note'):
+if metadata.get(b'note'):
-fm.plain('\n    note: ')
+fm.plain(b'\n    note: ')
-fm.write('note', "%s", metadata['note'], label="evolve.note")
+fm.write(b'note', b"%s", metadata[b'note'], label=b"evolve.note")
 # Patch display
 if includediff is True:
 _patchavailable = patchavailable(node, repo, marker[1])
 basectx.description(),
 succctx.description())
 if descriptionpatch:
 # add the diffheader
-diffheader = "diff -r %s -r %s changeset-description\n" % \
+diffheader = b"diff -r %s -r %s changeset-description\n" %\
 (basectx, succctx)
 descriptionpatch = diffheader + descriptionpatch
 def tolist(text):
 return [text]
-fm.plain("\n")
+fm.plain(b"\n")
 for chunk, label in patch.difflabel(tolist, descriptionpatch):
-chunk = chunk.strip('\t')
+chunk = chunk.strip(b'\t')
-if chunk and chunk != '\n':
+if chunk and chunk != b'\n':
-fm.plain('    ')
+fm.plain(b'    ')
-fm.write('desc-diff', '%s', chunk, label=label)
+fm.write(b'desc-diff', b'%s', chunk, label=label)
 # Content patch
 diffopts = patch.diffallopts(repo.ui, {})
 matchfn = scmutil.matchall(repo)
 firstline = True
 for chunk, label in patch.diffui(repo, node, succ, matchfn,
 opts=diffopts):
 if firstline:
-fm.plain('\n')
+fm.plain(b'\n')
 firstline = False
-if chunk and chunk != '\n':
+if chunk and chunk != b'\n':
-fm.plain('    ')
+fm.plain(b'    ')
-fm.write('patch', '%s', chunk, label=label)
+fm.write(b'patch', b'%s', chunk, label=label)
 else:
-nopatch = "    (No patch available, %s)" % _patchavailable[1]
+nopatch = b"    (No patch available, %s)" % _patchavailable[1]
-fm.plain("\n")
+fm.plain(b"\n")
 # TODO: should be in json too
 fm.plain(nopatch)
-fm.plain("\n")
+fm.plain(b"\n")
 def _debugobshistorydisplaysuccsandmarkers(fm, succnodes, markers, node, repo, includediff=False):
 """
 This function is a duplication of _debugobshistorydisplaymarker modified
 to accept multiple markers as input.
 """
 fm.startitem()
-fm.plain('  ')
+fm.plain(b'  ')
 # Detect pruned revisions
-verb = _successorsetverb(succnodes, markers)["verb"]
+verb = _successorsetverb(succnodes, markers)[b"verb"]
-fm.write('verb', '%s', verb,
+fm.write(b'verb', b'%s', verb,
-label="evolve.verb")
+label=b"evolve.verb")
 # Effect flag
 metadata = [dict(marker[3]) for marker in markers]
-ef1 = [data.get('ef1') for data in metadata]
+ef1 = [data.get(b'ef1') for data in metadata]
 effectflag = 0
 for ef in ef1:
 if ef:
 effectflag |= int(ef)
 if effectflag:
 effect = []
 # XXX should be a dict
 if effectflag & DESCCHANGED:
-effect.append('description')
+effect.append(b'description')
 if effectflag & METACHANGED:
-effect.append('meta')
+effect.append(b'meta')
 if effectflag & USERCHANGED:
-effect.append('user')
+effect.append(b'user')
 if effectflag & DATECHANGED:
-effect.append('date')
+effect.append(b'date')
 if effectflag & BRANCHCHANGED:
-effect.append('branch')
+effect.append(b'branch')
 if effectflag & PARENTCHANGED:
-effect.append('parent')
+effect.append(b'parent')
 if effectflag & DIFFCHANGED:
-effect.append('content')
+effect.append(b'content')
 if effect:
-fmteffect = fm.formatlist(effect, 'effect', sep=', ')
+fmteffect = fm.formatlist(effect, b'effect', sep=b', ')
-fm.write('effect', '(%s)', fmteffect)
+fm.write(b'effect', b'(%s)', fmteffect)
 if len(succnodes) > 0:
-fm.plain(' as ')
+fm.plain(b' as ')
 shortsnodes = (nodemod.short(succnode) for succnode in sorted(succnodes))
-nodes = fm.formatlist(shortsnodes, 'succnodes', sep=', ')
+nodes = fm.formatlist(shortsnodes, b'succnodes', sep=b', ')
-fm.write('succnodes', '%s', nodes,
+fm.write(b'succnodes', b'%s', nodes,
-label="evolve.node")
+label=b"evolve.node")
 # Operations
 operations = compat.markersoperations(markers)
 if operations:
-fm.plain(' using ')
+fm.plain(b' using ')
-fm.write('operation', '%s', ", ".join(operations), label="evolve.operation")
+fm.write(b'operation', b'%s', b", ".join(operations), label=b"evolve.operation")
-fm.plain(' by ')
+fm.plain(b' by ')
 # Users
 users = compat.markersusers(markers)
-fm.write('user', '%s', ", ".join(users),
+fm.write(b'user', b'%s', b", ".join(users),
-label="evolve.user")
+label=b"evolve.user")
-fm.plain(' ')
+fm.plain(b' ')
 # Dates
 dates = compat.markersdates(markers)
 if dates:
 min_date = min(dates)
 max_date = max(dates)
 if min_date == max_date:
-fm.write("date", "(at %s)", fm.formatdate(min_date), label="evolve.date")
+fm.write(b"date", b"(at %s)", fm.formatdate(min_date), label=b"evolve.date")
 else:
-fm.write("date", "(between %s and %s)", fm.formatdate(min_date),
+fm.write(b"date", b"(between %s and %s)", fm.formatdate(min_date),
-fm.formatdate(max_date), label="evolve.date")
+fm.formatdate(max_date), label=b"evolve.date")
 # initial support for showing note
 # if metadata.get('note'):
 #     fm.plain('\n    note: ')
 #     fm.write('note', "%s", metadata['note'], label="evolve.note")
 basectx.description(),
 succctx.description())
 if descriptionpatch:
 # add the diffheader
-diffheader = "diff -r %s -r %s changeset-description\n" % \
+diffheader = b"diff -r %s -r %s changeset-description\n" %\
 (basectx, succctx)
 descriptionpatch = diffheader + descriptionpatch
 def tolist(text):
 return [text]
-fm.plain("\n")
+fm.plain(b"\n")
 for chunk, label in patch.difflabel(tolist, descriptionpatch):
-chunk = chunk.strip('\t')
+chunk = chunk.strip(b'\t')
-if chunk and chunk != '\n':
+if chunk and chunk != b'\n':
-fm.plain('    ')
+fm.plain(b'    ')
-fm.write('desc-diff', '%s', chunk, label=label)
+fm.write(b'desc-diff', b'%s', chunk, label=label)
 # Content patch
 diffopts = patch.diffallopts(repo.ui, {})
 matchfn = scmutil.matchall(repo)
 firstline = True
 for chunk, label in patch.diffui(repo, node, succ, matchfn,
 opts=diffopts):
 if firstline:
-fm.plain('\n')
+fm.plain(b'\n')
 firstline = False
-if chunk and chunk != '\n':
+if chunk and chunk != b'\n':
-fm.plain('    ')
+fm.plain(b'    ')
-fm.write('patch', '%s', chunk, label=label)
+fm.write(b'patch', b'%s', chunk, label=label)
 else:
-nopatch = "    (No patch available, %s)" % _patchavailable[1]
+nopatch = b"    (No patch available, %s)" % _patchavailable[1]
-fm.plain("\n")
+fm.plain(b"\n")
 # TODO: should be in json too
 fm.plain(nopatch)
-fm.plain("\n")
+fm.plain(b"\n")
 # logic around storing and using effect flags
 DESCCHANGED = 1 << 0 # action changed the description
 METACHANGED = 1 << 1 # action change the meta
 PARENTCHANGED = 1 << 2 # action change the parent
 - superseed_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 'superseed'
+return b'superseed'
 else:
-return 'superseed_split'
+return b'superseed_split'
 def _getobsfateandsuccs(repo, revnode, successorssets=None):
 """ Return a tuple containing:
 - the reason a revision is obsolete (diverged, pruned or superseed)
 - the list of successors short node if the revision is neither pruned
 return {}
 dates = [m[4] for m in markers]
 return {
-'min_date': min(dates),
+b'min_date': min(dates),
-'max_date': max(dates)
+b'max_date': max(dates)
 }
 def _successorsetusers(successorset, markers):
 """ Returns a sorted list of markers users without duplicates
 """
 if not markers:
 return {}
 # Check that user is present in meta
 markersmeta = [dict(m[3]) for m in markers]
-users = set(meta.get('user') for meta in markersmeta if meta.get('user'))
+users = set(meta.get(b'user') for meta in markersmeta if meta.get(b'user'))
-return {'users': sorted(users)}
+return {b'users': sorted(users)}
 VERBMAPPING = {
-DESCCHANGED: "reworded",
+DESCCHANGED: b"reworded",
-METACHANGED: "meta-changed",
+METACHANGED: b"meta-changed",
-USERCHANGED: "reauthored",
+USERCHANGED: b"reauthored",
-DATECHANGED: "date-changed",
+DATECHANGED: b"date-changed",
-BRANCHCHANGED: "branch-changed",
+BRANCHCHANGED: b"branch-changed",
-PARENTCHANGED: "rebased",
+PARENTCHANGED: b"rebased",
-DIFFCHANGED: "amended"
+DIFFCHANGED: b"amended"
 }
 def _successorsetverb(successorset, markers):
 """ Return the verb summarizing the successorset
 """
 verb = None
 if not successorset:
-verb = 'pruned'
+verb = b'pruned'
 elif len(successorset) == 1:
 # Check for effect flag
 metadata = [dict(marker[3]) for marker in markers]
-ef1 = [data.get('ef1') for data in metadata]
+ef1 = [data.get(b'ef1') for data in metadata]
 if all(ef1):
 combined = 0
 for ef in ef1:
 combined |= int(ef)
 # Combined will be in VERBMAPPING only of one bit is set
 if combined in VERBMAPPING:
 verb = VERBMAPPING[combined]
 if verb is None:
-verb = 'rewritten'
+verb = b'rewritten'
 else:
-verb = 'split'
+verb = b'split'
-return {'verb': verb}
+return {b'verb': verb}
 # Use a more advanced version of obsfateverb that uses effect-flag
 if util.safehasattr(obsutil, 'obsfateverb'):
 @eh.wrapfunction(obsutil, 'obsfateverb')
 def obsfateverb(orig, *args, **kwargs):
-return _successorsetverb(*args, **kwargs)['verb']
+return _successorsetverb(*args, **kwargs)[b'verb']
 # Hijack callers of successorsetverb
 elif util.safehasattr(obsutil, 'obsfateprinter'):
 @eh.wrapfunction(obsutil, 'obsfateprinter')
 def obsfateprinter(orig, successors, markers, ui):
 def closure(successors):
-return _successorsetverb(successors, markers)['verb']
+return _successorsetverb(successors, markers)[b'verb']
 if not util.safehasattr(obsutil, 'successorsetverb'):
 return orig(successors, markers, ui)
 # Save the old value
 newmarker = (hexprec, hexsucs) + m[2:5] + (hexparents,) + m[6:]
 markers.append(newmarker)
 # Format basic data
 data = {
-"successors": sorted(successorset),
+b"successors": sorted(successorset),
-"markers": sorted(markers)
+b"markers": sorted(markers)
 }
 # Call an extensible list of functions to override or add new data
 for function in FORMATSSETSFUNCTIONS:
 data.update(function(successorset, markers))

changeset 4814	48b30ff742cb
parent 4801	16c1398b0063
child 4827	4c6dd20e8cc2