This is an archive of the discontinued Mercurial Phabricator instance.

Differential D898

annotate: introduce attr for storing per-line annotate data
ClosedPublic

Authored by sid0 on Oct 2 2017, 5:35 AM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG2e32c6a31cc7: annotate: introduce attr for storing per-line annotate data
Summary

We're going to extend this a bit -- at first by simply adding whether this was
a skipped child. We're well on our way to outgrowing tuples, though -- adding
more and more fields to tuples becomes annoying very quickly.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

sid0 created this revision.Oct 2 2017, 5:35 AM
indygreg accepted this revision.Oct 2 2017, 6:29 AM
indygreg added a subscriber: indygreg.

The new code is so much easier to read!

This revision is now accepted and ready to land.Oct 2 2017, 6:29 AM
sid0 updated this revision to Diff 2328.Oct 2 2017, 11:05 AM
indygreg accepted this revision.Oct 2 2017, 1:12 PM
Closed by commit rHG2e32c6a31cc7: annotate: introduce attr for storing per-line annotate data (authored by sid0). · Explain WhyOct 2 2017, 1:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 2340

mercurial/commands.py

if hex is None: if hex is None:
return '%s+' % rootfm.hexfunc(ctx.p1().node()) return '%s+' % rootfm.hexfunc(ctx.p1().node())
else: else:
return '%s ' % hex return '%s ' % hex
else: else:
hexfn = rootfm.hexfunc hexfn = rootfm.hexfunc
formatrev = formathex = pycompat.bytestr formatrev = formathex = pycompat.bytestr
opmap = [('user', ' ', lambda x: x[0].user(), ui.shortuser), opmap = [('user', ' ', lambda x: x.fctx.user(), ui.shortuser),
('number', ' ', lambda x: x[0].rev(), formatrev), ('number', ' ', lambda x: x.fctx.rev(), formatrev),
('changeset', ' ', lambda x: hexfn(x[0].node()), formathex), ('changeset', ' ', lambda x: hexfn(x.fctx.node()), formathex),
('date', ' ', lambda x: x[0].date(), util.cachefunc(datefunc)), ('date', ' ', lambda x: x.fctx.date(), util.cachefunc(datefunc)),
('file', ' ', lambda x: x[0].path(), str), ('file', ' ', lambda x: x.fctx.path(), str),
('line_number', ':', lambda x: x[1], str), ('line_number', ':', lambda x: x.lineno, str),
] ]
fieldnamemap = {'number': 'rev', 'changeset': 'node'} fieldnamemap = {'number': 'rev', 'changeset': 'node'}
if (not opts.get('user') and not opts.get('changeset') if (not opts.get('user') and not opts.get('changeset')
and not opts.get('date') and not opts.get('file')): and not opts.get('date') and not opts.get('file')):
opts['number'] = True opts['number'] = True
linenumber = opts.get('line_number') is not None linenumber = opts.get('line_number') is not None

mercurial/context.py

modifiednodeid, modifiednodeid,
nullid, nullid,
nullrev, nullrev,
short, short,
wdirid, wdirid,
wdirnodes, wdirnodes,
wdirrev, wdirrev,
) )
from .thirdparty import (
attr,
)
from . import ( from . import (
encoding, encoding,
error, error,
fileset, fileset,
match as matchmod, match as matchmod,
mdiff, mdiff,
obsolete as obsmod, obsolete as obsmod,
patch, patch,
def lines(text): def lines(text):
if text.endswith("\n"): if text.endswith("\n"):
return text.count("\n") return text.count("\n")
return text.count("\n") + int(bool(text)) return text.count("\n") + int(bool(text))
if linenumber: if linenumber:
def decorate(text, rev): def decorate(text, rev):
return ([(rev, i) for i in xrange(1, lines(text) + 1)], text) return ([annotateline(fctx=rev, lineno=i)
for i in xrange(1, lines(text) + 1)], text)
else: else:
def decorate(text, rev): def decorate(text, rev):
return ([(rev, False)] * lines(text), text) return ([annotateline(fctx=rev)] * lines(text), text)
getlog = util.lrucachefunc(lambda x: self._repo.file(x)) getlog = util.lrucachefunc(lambda x: self._repo.file(x))
def parents(f): def parents(f):
# Cut _descendantrev here to mitigate the penalty of lazy linkrev # Cut _descendantrev here to mitigate the penalty of lazy linkrev
# adjustment. Otherwise, p._adjustlinkrev() would walk changelog # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
# from the topmost introrev (= srcrev) down to p.linkrev() if it # from the topmost introrev (= srcrev) down to p.linkrev() if it
# isn't an ancestor of the srcrev. # isn't an ancestor of the srcrev.
def decodeddata(self): def decodeddata(self):
"""Returns `data()` after running repository decoding filters. """Returns `data()` after running repository decoding filters.
This is often equivalent to how the data would be expressed on disk. This is often equivalent to how the data would be expressed on disk.
""" """
return self._repo.wwritedata(self.path(), self.data()) return self._repo.wwritedata(self.path(), self.data())
@attr.s(slots=True, frozen=True)
class annotateline(object):
fctx = attr.ib()
lineno = attr.ib(default=False)
def _annotatepair(parents, childfctx, child, skipchild, diffopts): def _annotatepair(parents, childfctx, child, skipchild, diffopts):
r''' r'''
Given parent and child fctxes and annotate data for parents, for all lines Given parent and child fctxes and annotate data for parents, for all lines
in either parent that match the child, annotate the child with the parent's in either parent that match the child, annotate the child with the parent's
data. data.
Additionally, if `skipchild` is True, replace all other lines with parent Additionally, if `skipchild` is True, replace all other lines with parent
annotate data as well such that child is never blamed for any lines. annotate data as well such that child is never blamed for any lines.
# * Repeat the last line as a last resort. # * Repeat the last line as a last resort.
# First, replace as much as possible without repeating the last line. # First, replace as much as possible without repeating the last line.
remaining = [(parent, []) for parent, _blocks in pblocks] remaining = [(parent, []) for parent, _blocks in pblocks]
for idx, (parent, blocks) in enumerate(pblocks): for idx, (parent, blocks) in enumerate(pblocks):
for (a1, a2, b1, b2), _t in blocks: for (a1, a2, b1, b2), _t in blocks:
if a2 - a1 >= b2 - b1: if a2 - a1 >= b2 - b1:
for bk in xrange(b1, b2): for bk in xrange(b1, b2):
if child[0][bk][0] == childfctx: if child[0][bk].fctx == childfctx:
ak = min(a1 + (bk - b1), a2 - 1) ak = min(a1 + (bk - b1), a2 - 1)
child[0][bk] = parent[0][ak] child[0][bk] = parent[0][ak]
else: else:
remaining[idx][1].append((a1, a2, b1, b2)) remaining[idx][1].append((a1, a2, b1, b2))
# Then, look at anything left, which might involve repeating the last # Then, look at anything left, which might involve repeating the last
# line. # line.
for parent, blocks in remaining: for parent, blocks in remaining:
for a1, a2, b1, b2 in blocks: for a1, a2, b1, b2 in blocks:
for bk in xrange(b1, b2): for bk in xrange(b1, b2):
if child[0][bk][0] == childfctx: if child[0][bk].fctx == childfctx:
ak = min(a1 + (bk - b1), a2 - 1) ak = min(a1 + (bk - b1), a2 - 1)
child[0][bk] = parent[0][ak] child[0][bk] = parent[0][ak]
return child return child
class filectx(basefilectx): class filectx(basefilectx):
"""A filecontext object makes access to data related to a particular """A filecontext object makes access to data related to a particular
filerevision convenient.""" filerevision convenient."""
def __init__(self, repo, path, changeid=None, fileid=None, def __init__(self, repo, path, changeid=None, fileid=None,

mercurial/hgweb/webcommands.py

mt = (mimetypes.guess_type(fctx.path())[0] mt = (mimetypes.guess_type(fctx.path())[0]
or 'application/octet-stream') or 'application/octet-stream')
lines = [((fctx.filectx(fctx.filerev()), 1), '(binary:%s)' % mt)] lines = [((fctx.filectx(fctx.filerev()), 1), '(binary:%s)' % mt)]
else: else:
lines = webutil.annotate(req, fctx, web.repo.ui) lines = webutil.annotate(req, fctx, web.repo.ui)
previousrev = None previousrev = None
blockparitygen = paritygen(1) blockparitygen = paritygen(1)
for lineno, ((f, targetline), l) in enumerate(lines): for lineno, (aline, l) in enumerate(lines):
f = aline.fctx
rev = f.rev() rev = f.rev()
if rev != previousrev: if rev != previousrev:
blockhead = True blockhead = True
blockparity = next(blockparitygen) blockparity = next(blockparitygen)
else: else:
blockhead = None blockhead = None
previousrev = rev previousrev = rev
yield {"parity": next(parity), yield {"parity": next(parity),
"node": f.hex(), "node": f.hex(),
"rev": rev, "rev": rev,
"author": f.user(), "author": f.user(),
"parents": parents(f), "parents": parents(f),
"desc": f.description(), "desc": f.description(),
"extra": f.extra(), "extra": f.extra(),
"file": f.path(), "file": f.path(),
"blockhead": blockhead, "blockhead": blockhead,
"blockparity": blockparity, "blockparity": blockparity,
"targetline": targetline, "targetline": aline.lineno,
"line": l, "line": l,
"lineno": lineno + 1, "lineno": lineno + 1,
"lineid": "l%d" % (lineno + 1), "lineid": "l%d" % (lineno + 1),
"linenumber": "% 6d" % (lineno + 1), "linenumber": "% 6d" % (lineno + 1),
"revdate": f.date()} "revdate": f.date()}
diffopts = webutil.difffeatureopts(req, web.repo.ui, 'annotate') diffopts = webutil.difffeatureopts(req, web.repo.ui, 'annotate')
diffopts = {k: getattr(diffopts, k) for k in diffopts.defaults} diffopts = {k: getattr(diffopts, k) for k in diffopts.defaults}

tests/test-annotate.py

from __future__ import absolute_import from __future__ import absolute_import
from __future__ import print_function from __future__ import print_function
import unittest import unittest
from mercurial import ( from mercurial import (
mdiff, mdiff,
) )
from mercurial.context import ( from mercurial.context import (
annotateline,
_annotatepair, _annotatepair,
) )
class AnnotateTests(unittest.TestCase): class AnnotateTests(unittest.TestCase):
"""Unit tests for annotate code.""" """Unit tests for annotate code."""
def testannotatepair(self): def testannotatepair(self):
self.maxDiff = None # camelcase-required self.maxDiff = None # camelcase-required
oldfctx = b'old' oldfctx = b'old'
p1fctx, p2fctx, childfctx = b'p1', b'p2', b'c' p1fctx, p2fctx, childfctx = b'p1', b'p2', b'c'
olddata = b'a\nb\n' olddata = b'a\nb\n'
p1data = b'a\nb\nc\n' p1data = b'a\nb\nc\n'
p2data = b'a\nc\nd\n' p2data = b'a\nc\nd\n'
childdata = b'a\nb2\nc\nc2\nd\n' childdata = b'a\nb2\nc\nc2\nd\n'
diffopts = mdiff.diffopts() diffopts = mdiff.diffopts()
def decorate(text, rev): def decorate(text, rev):
return ([(rev, i) for i in xrange(1, text.count(b'\n') + 1)], text) return ([annotateline(fctx=rev, lineno=i)
for i in xrange(1, text.count(b'\n') + 1)],
text)
# Basic usage # Basic usage
oldann = decorate(olddata, oldfctx) oldann = decorate(olddata, oldfctx)
p1ann = decorate(p1data, p1fctx) p1ann = decorate(p1data, p1fctx)
p1ann = _annotatepair([oldann], p1fctx, p1ann, False, diffopts) p1ann = _annotatepair([oldann], p1fctx, p1ann, False, diffopts)
self.assertEqual(p1ann[0], [('old', 1), ('old', 2), ('p1', 3)]) self.assertEqual(p1ann[0], [
annotateline('old', 1),
annotateline('old', 2),
annotateline('p1', 3),
])
p2ann = decorate(p2data, p2fctx) p2ann = decorate(p2data, p2fctx)
p2ann = _annotatepair([oldann], p2fctx, p2ann, False, diffopts) p2ann = _annotatepair([oldann], p2fctx, p2ann, False, diffopts)
self.assertEqual(p2ann[0], [('old', 1), ('p2', 2), ('p2', 3)]) self.assertEqual(p2ann[0], [
annotateline('old', 1),
annotateline('p2', 2),
annotateline('p2', 3),
])
# Test with multiple parents (note the difference caused by ordering) # Test with multiple parents (note the difference caused by ordering)
childann = decorate(childdata, childfctx) childann = decorate(childdata, childfctx)
childann = _annotatepair([p1ann, p2ann], childfctx, childann, False, childann = _annotatepair([p1ann, p2ann], childfctx, childann, False,
diffopts) diffopts)
self.assertEqual(childann[0], self.assertEqual(childann[0], [
[('old', 1), ('c', 2), ('p2', 2), ('c', 4), ('p2', 3)] annotateline('old', 1),
) annotateline('c', 2),
annotateline('p2', 2),
annotateline('c', 4),
annotateline('p2', 3),
])
childann = decorate(childdata, childfctx) childann = decorate(childdata, childfctx)
childann = _annotatepair([p2ann, p1ann], childfctx, childann, False, childann = _annotatepair([p2ann, p1ann], childfctx, childann, False,
diffopts) diffopts)
self.assertEqual(childann[0], self.assertEqual(childann[0], [
[('old', 1), ('c', 2), ('p1', 3), ('c', 4), ('p2', 3)] annotateline('old', 1),
) annotateline('c', 2),
annotateline('p1', 3),
annotateline('c', 4),
annotateline('p2', 3),
])
# Test with skipchild (note the difference caused by ordering) # Test with skipchild (note the difference caused by ordering)
childann = decorate(childdata, childfctx) childann = decorate(childdata, childfctx)
childann = _annotatepair([p1ann, p2ann], childfctx, childann, True, childann = _annotatepair([p1ann, p2ann], childfctx, childann, True,
diffopts) diffopts)
self.assertEqual(childann[0], self.assertEqual(childann[0], [
[('old', 1), ('old', 2), ('p2', 2), ('p2', 2), ('p2', 3)] annotateline('old', 1),
) annotateline('old', 2),
annotateline('p2', 2),
annotateline('p2', 2),
annotateline('p2', 3),
])
childann = decorate(childdata, childfctx) childann = decorate(childdata, childfctx)
childann = _annotatepair([p2ann, p1ann], childfctx, childann, True, childann = _annotatepair([p2ann, p1ann], childfctx, childann, True,
diffopts) diffopts)
self.assertEqual(childann[0], self.assertEqual(childann[0], [
[('old', 1), ('old', 2), ('p1', 3), ('p1', 3), ('p2', 3)] annotateline('old', 1),
) annotateline('old', 2),
annotateline('p1', 3),
annotateline('p1', 3),
annotateline('p2', 3),
])
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)