( )⚙ D4997 absorb: use a formatter to generate output

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4997

absorb: use a formatter to generate output
ClosedPublic

Authored by mbthomas on Oct 12 2018, 11:49 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGdcda50856843: absorb: use a formatter to generate output
Summary

Change absorb to use a formatter to generate its output. This allows the use
of templates to customize the output.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

mbthomas created this revision.Oct 12 2018, 11:49 AM
indygreg accepted this revision.Oct 12 2018, 1:35 PM
This revision is now accepted and ready to land.Oct 12 2018, 1:35 PM
Closed by commit rHGdcda50856843: absorb: use a formatter to generate output (authored by mbthomas). · Explain WhyOct 12 2018, 1:42 PM
This revision was automatically updated to reflect the committed changes.
yuja added a subscriber: yuja.Oct 13 2018, 1:43 AM

+ fm.startitem()
+ fm.write('hunk', ' %s\n',
+ '@@ -%d,%d +%d,%d @@'
+ % (a1, a2 - a1, b1, b2 - b1), label='diff.hunk')
+ fm.data(path=self.path, linetype='hunk')
+
+ def writeline(idx, diffchar, line, linetype, linelabel):
+ fm.startitem()
+ node = ''
+ if idx:
+ ctx = self.fctxs[idx]
+ fm.context(fctx=ctx)
+ node = ctx.hex()
+ fm.write('node', '%-7.7s ', node, label='absorb.node')
+ fm.write('diffchar ' + linetype, '%s%s\n', diffchar, line,
+ label=linelabel)

Nit: maybe rename "diffchar" to "change"? It's called as such in "hg grep".
https://www.mercurial-scm.org/wiki/GenericTemplatingPlan#Dictionary

+ fm.data(path=self.path, linetype=linetype)
+
+ for i in pycompat.xrange(a1, a2):
+ writeline(aidxs[i - a1], '-', trim(alines[i]), 'deleted',
+ 'diff.deleted')
+ for i in pycompat.xrange(b1, b2):
+ writeline(bidxs[i - b1], '+', trim(blines[i]), 'inserted',
+ 'diff.inserted')

Perhaps, it's better to make deleted/inserted lines nested to preserve the
original data structure.

{"hunk", ...,
 "deletedlines": [{"line": ...}, ...]
 "insertedlines": ...}

or

{"hunk", ...,
 "lines": [{"line": ..., "deleted": True}, ...]}

instead of

{"hunk", ...},
{"deleted": ...},
{"inserted": ...},

Revision Contents
Changeset List

PathPackages
Mhgext/absorb.py (75 lines)
Mtests/test-absorb-filefixupstate.py (3 lines)

Diff 11901

hgext/absorb.py

a typical use is like: a typical use is like:
1. call diffwith, to calculate self.fixups 1. call diffwith, to calculate self.fixups
2. (optionally), present self.fixups to the user, or change it 2. (optionally), present self.fixups to the user, or change it
3. call apply, to apply changes 3. call apply, to apply changes
4. read results from "finalcontents", or call getfinalcontent 4. read results from "finalcontents", or call getfinalcontent
""" """
def __init__(self, fctxs, ui=None, opts=None): def __init__(self, fctxs, path, ui=None, opts=None):
"""([fctx], ui or None) -> None """([fctx], ui or None) -> None
fctxs should be linear, and sorted by topo order - oldest first. fctxs should be linear, and sorted by topo order - oldest first.
fctxs[0] will be considered as "immutable" and will not be changed. fctxs[0] will be considered as "immutable" and will not be changed.
""" """
self.fctxs = fctxs self.fctxs = fctxs
self.path = path
self.ui = ui or nullui() self.ui = ui or nullui()
self.opts = opts or {} self.opts = opts or {}
# following fields are built from fctxs. they exist for perf reason # following fields are built from fctxs. they exist for perf reason
self.contents = [f.data() for f in fctxs] self.contents = [f.data() for f in fctxs]
self.contentlines = pycompat.maplist(mdiff.splitnewlines, self.contents) self.contentlines = pycompat.maplist(mdiff.splitnewlines, self.contents)
self.linelog = self._buildlinelog() self.linelog = self._buildlinelog()
if self.ui.debugflag: if self.ui.debugflag:
assert self._checkoutlinelog() == self.contents assert self._checkoutlinelog() == self.contents
# following fields will be filled later # following fields will be filled later
self.chunkstats = [0, 0] # [adopted, total : int] self.chunkstats = [0, 0] # [adopted, total : int]
self.targetlines = [] # [str] self.targetlines = [] # [str]
self.fixups = [] # [(linelog rev, a1, a2, b1, b2)] self.fixups = [] # [(linelog rev, a1, a2, b1, b2)]
self.finalcontents = [] # [str] self.finalcontents = [] # [str]
def diffwith(self, targetfctx, showchanges=False): def diffwith(self, targetfctx, fm=None):
"""calculate fixups needed by examining the differences between """calculate fixups needed by examining the differences between
self.fctxs[-1] and targetfctx, chunk by chunk. self.fctxs[-1] and targetfctx, chunk by chunk.
targetfctx is the target state we move towards. we may or may not be targetfctx is the target state we move towards. we may or may not be
able to get there because not all modified chunks can be amended into able to get there because not all modified chunks can be amended into
a non-public fctx unambiguously. a non-public fctx unambiguously.
call this only once, before apply(). call this only once, before apply().
annotated.append(dummyendline) annotated.append(dummyendline)
# analyse diff blocks # analyse diff blocks
for chunk in self._alldiffchunks(a, b, alines, blines): for chunk in self._alldiffchunks(a, b, alines, blines):
newfixups = self._analysediffchunk(chunk, annotated) newfixups = self._analysediffchunk(chunk, annotated)
self.chunkstats[0] += bool(newfixups) # 1 or 0 self.chunkstats[0] += bool(newfixups) # 1 or 0
self.chunkstats[1] += 1 self.chunkstats[1] += 1
self.fixups += newfixups self.fixups += newfixups
if showchanges: if fm is not None:
self._showchanges(alines, blines, chunk, newfixups) self._showchanges(fm, alines, blines, chunk, newfixups)
def apply(self): def apply(self):
"""apply self.fixups. update self.linelog, self.finalcontents. """apply self.fixups. update self.linelog, self.finalcontents.
call this only once, before getfinalcontent(), after diffwith(). call this only once, before getfinalcontent(), after diffwith().
""" """
# the following is unnecessary, as it's done by "diffwith": # the following is unnecessary, as it's done by "diffwith":
# self.linelog.annotate(self.linelog.maxrev) # self.linelog.annotate(self.linelog.maxrev)
pcurrentchunk[0][2] = a2 pcurrentchunk[0][2] = a2
pcurrentchunk[0][4] = b2 pcurrentchunk[0][4] = b2
else: else:
pushchunk() pushchunk()
pcurrentchunk[0] = list(chunk) pcurrentchunk[0] = list(chunk)
pushchunk() pushchunk()
return result return result
def _showchanges(self, alines, blines, chunk, fixups): def _showchanges(self, fm, alines, blines, chunk, fixups):
ui = self.ui
def label(line, label): def trim(line):
if line.endswith('\n'): if line.endswith('\n'):
line = line[:-1] line = line[:-1]
return ui.label(line, label) return line
# this is not optimized for perf but _showchanges only gets executed # this is not optimized for perf but _showchanges only gets executed
# with an extra command-line flag. # with an extra command-line flag.
a1, a2, b1, b2 = chunk a1, a2, b1, b2 = chunk
aidxs, bidxs = [0] * (a2 - a1), [0] * (b2 - b1) aidxs, bidxs = [0] * (a2 - a1), [0] * (b2 - b1)
for idx, fa1, fa2, fb1, fb2 in fixups: for idx, fa1, fa2, fb1, fb2 in fixups:
for i in pycompat.xrange(fa1, fa2): for i in pycompat.xrange(fa1, fa2):
aidxs[i - a1] = (max(idx, 1) - 1) // 2 aidxs[i - a1] = (max(idx, 1) - 1) // 2
for i in pycompat.xrange(fb1, fb2): for i in pycompat.xrange(fb1, fb2):
bidxs[i - b1] = (max(idx, 1) - 1) // 2 bidxs[i - b1] = (max(idx, 1) - 1) // 2
buf = [] # [(idx, content)] fm.startitem()
buf.append((0, label('@@ -%d,%d +%d,%d @@' fm.write('hunk', ' %s\n',
% (a1, a2 - a1, b1, b2 - b1), 'diff.hunk'))) '@@ -%d,%d +%d,%d @@'
buf += [(aidxs[i - a1], label('-' + alines[i], 'diff.deleted')) % (a1, a2 - a1, b1, b2 - b1), label='diff.hunk')
for i in pycompat.xrange(a1, a2)] fm.data(path=self.path, linetype='hunk')
buf += [(bidxs[i - b1], label('+' + blines[i], 'diff.inserted'))
for i in pycompat.xrange(b1, b2)] def writeline(idx, diffchar, line, linetype, linelabel):
for idx, line in buf: fm.startitem()
shortnode = idx and node.short(self.fctxs[idx].node()) or '' node = ''
ui.write(ui.label(shortnode[0:7].ljust(8), 'absorb.node') + if idx:
line + '\n') ctx = self.fctxs[idx]
fm.context(fctx=ctx)
node = ctx.hex()
fm.write('node', '%-7.7s ', node, label='absorb.node')
fm.write('diffchar ' + linetype, '%s%s\n', diffchar, line,
label=linelabel)
fm.data(path=self.path, linetype=linetype)
for i in pycompat.xrange(a1, a2):
writeline(aidxs[i - a1], '-', trim(alines[i]), 'deleted',
'diff.deleted')
for i in pycompat.xrange(b1, b2):
writeline(bidxs[i - b1], '+', trim(blines[i]), 'inserted',
'diff.inserted')
class fixupstate(object): class fixupstate(object):
"""state needed to run absorb """state needed to run absorb
internally, it keeps paths and filefixupstates. internally, it keeps paths and filefixupstates.
a typical use is like filefixupstates: a typical use is like filefixupstates:
# following fields will be filled later # following fields will be filled later
self.paths = [] # [str] self.paths = [] # [str]
self.status = None # ctx.status output self.status = None # ctx.status output
self.fctxmap = {} # {path: {ctx: fctx}} self.fctxmap = {} # {path: {ctx: fctx}}
self.fixupmap = {} # {path: filefixupstate} self.fixupmap = {} # {path: filefixupstate}
self.replacemap = {} # {oldnode: newnode or None} self.replacemap = {} # {oldnode: newnode or None}
self.finalnode = None # head after all fixups self.finalnode = None # head after all fixups
def diffwith(self, targetctx, match=None, showchanges=False): def diffwith(self, targetctx, match=None, fm=None):
"""diff and prepare fixups. update self.fixupmap, self.paths""" """diff and prepare fixups. update self.fixupmap, self.paths"""
# only care about modified files # only care about modified files
self.status = self.stack[-1].status(targetctx, match) self.status = self.stack[-1].status(targetctx, match)
self.paths = [] self.paths = []
# but if --edit-lines is used, the user may want to edit files # but if --edit-lines is used, the user may want to edit files
# even if they are not modified # even if they are not modified
editopt = self.opts.get('edit_lines') editopt = self.opts.get('edit_lines')
if not self.status.modified and editopt and match: if not self.status.modified and editopt and match:
if any(f.islink() or stringutil.binary(f.data()) if any(f.islink() or stringutil.binary(f.data())
for f in [targetfctx] + fctxs for f in [targetfctx] + fctxs
if not isinstance(f, emptyfilecontext)): if not isinstance(f, emptyfilecontext)):
continue continue
if targetfctx.data() == fctxs[-1].data() and not editopt: if targetfctx.data() == fctxs[-1].data() and not editopt:
continue continue
seenfctxs.update(fctxs[1:]) seenfctxs.update(fctxs[1:])
self.fctxmap[path] = ctx2fctx self.fctxmap[path] = ctx2fctx
fstate = filefixupstate(fctxs, ui=self.ui, opts=self.opts) fstate = filefixupstate(fctxs, path, ui=self.ui, opts=self.opts)
if showchanges: if fm is not None:
colorpath = self.ui.label(path, 'absorb.path') fm.startitem()
header = 'showing changes for ' + colorpath fm.plain('showing changes for ')
self.ui.write(header + '\n') fm.write('path', '%s\n', path, label='absorb.path')
fstate.diffwith(targetfctx, showchanges=showchanges) fm.data(linetype='path')
fstate.diffwith(targetfctx, fm)
self.fixupmap[path] = fstate self.fixupmap[path] = fstate
self.paths.append(path) self.paths.append(path)
def apply(self): def apply(self):
"""apply fixups to individual filefixupstates""" """apply fixups to individual filefixupstates"""
for path, state in self.fixupmap.iteritems(): for path, state in self.fixupmap.iteritems():
if self.ui.debugflag: if self.ui.debugflag:
self.ui.write(_('applying fixups to %s\n') % path) self.ui.write(_('applying fixups to %s\n') % path)
opts = {} opts = {}
state = fixupstate(stack, ui=ui, opts=opts) state = fixupstate(stack, ui=ui, opts=opts)
matcher = scmutil.match(targetctx, pats, opts) matcher = scmutil.match(targetctx, pats, opts)
if opts.get('interactive'): if opts.get('interactive'):
diff = patch.diff(repo, stack[-1].node(), targetctx.node(), matcher) diff = patch.diff(repo, stack[-1].node(), targetctx.node(), matcher)
origchunks = patch.parsepatch(diff) origchunks = patch.parsepatch(diff)
chunks = cmdutil.recordfilter(ui, origchunks)[0] chunks = cmdutil.recordfilter(ui, origchunks)[0]
targetctx = overlaydiffcontext(stack[-1], chunks) targetctx = overlaydiffcontext(stack[-1], chunks)
state.diffwith(targetctx, matcher, showchanges=opts.get('print_changes')) fm = None
if opts.get('print_changes'):
fm = ui.formatter('absorb', opts)
state.diffwith(targetctx, matcher, fm)
if fm is not None:
fm.end()
if not opts.get('dry_run'): if not opts.get('dry_run'):
state.apply() state.apply()
if state.commit(): if state.commit():
state.printchunkstats() state.printchunkstats()
elif not ui.quiet: elif not ui.quiet:
ui.write(_('nothing applied\n')) ui.write(_('nothing applied\n'))
return state return state
@command('^absorb', @command('^absorb',
[('p', 'print-changes', None, [('p', 'print-changes', None,
_('print which changesets are modified by which changes')), _('print which changesets are modified by which changes')),
('i', 'interactive', None, ('i', 'interactive', None,
_('interactively select which chunks to apply (EXPERIMENTAL)')), _('interactively select which chunks to apply (EXPERIMENTAL)')),
('e', 'edit-lines', None, ('e', 'edit-lines', None,
_('edit what lines belong to which changesets before commit ' _('edit what lines belong to which changesets before commit '
'(EXPERIMENTAL)')), '(EXPERIMENTAL)')),
] + commands.dryrunopts + commands.walkopts, ] + commands.dryrunopts + commands.templateopts + commands.walkopts,
_('hg absorb [OPTION] [FILE]...')) _('hg absorb [OPTION] [FILE]...'))
def absorbcmd(ui, repo, *pats, **opts): def absorbcmd(ui, repo, *pats, **opts):
"""incorporate corrections into the stack of draft changesets """incorporate corrections into the stack of draft changesets
absorb analyzes each change in your working directory and attempts to absorb analyzes each change in your working directory and attempts to
amend the changed lines into the changesets in your stack that first amend the changed lines into the changesets in your stack that first
introduced those lines. introduced those lines.

tests/test-absorb-filefixupstate.py

oldcontents, expectedcontents are lists of strings, every character of oldcontents, expectedcontents are lists of strings, every character of
every string denots a single line. every string denots a single line.
if fixups is not None, it's the expected fixups list and will be checked. if fixups is not None, it's the expected fixups list and will be checked.
""" """
expectedcontents = insertreturns(expectedcontents) expectedcontents = insertreturns(expectedcontents)
oldcontents = insertreturns(oldcontents) oldcontents = insertreturns(oldcontents)
workingcopy = insertreturns(workingcopy) workingcopy = insertreturns(workingcopy)
state = absorb.filefixupstate(pycompat.maplist(simplefctx, oldcontents)) state = absorb.filefixupstate(pycompat.maplist(simplefctx, oldcontents),
'path')
state.diffwith(simplefctx(workingcopy)) state.diffwith(simplefctx(workingcopy))
if fixups is not None: if fixups is not None:
assertlistequal(state.fixups, fixups) assertlistequal(state.fixups, fixups)
state.apply() state.apply()
assertlistequal(state.finalcontents, expectedcontents, removereturns) assertlistequal(state.finalcontents, expectedcontents, removereturns)
def buildcontents(linesrevs): def buildcontents(linesrevs):
# linesrevs: [(linecontent : str, revs : [int])] # linesrevs: [(linecontent : str, revs : [int])]