@@ -89,96 +89,97 @@ def wrapped_diff(filenode_old, filenode_
if not diff:
submodules = filter(lambda o: isinstance(o, SubModuleNode),
[filenode_new, filenode_old])
if submodules:
diff = wrap_to_table(escape('Submodule %r' % submodules[0]))
else:
diff = wrap_to_table(_('No changes detected'))
cs1 = filenode_old.changeset.raw_id
cs2 = filenode_new.changeset.raw_id
return size, cs1, cs2, diff, stats
def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):
"""
Returns git style diff between given ``filenode_old`` and ``filenode_new``.
:param ignore_whitespace: ignore whitespaces in diff
# make sure we pass in default context
context = context or 3
return ''
for filenode in (filenode_old, filenode_new):
if not isinstance(filenode, FileNode):
raise VCSError("Given object should be FileNode object, not %s"
% filenode.__class__)
repo = filenode_new.changeset.repository
old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)
new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)
vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,
ignore_whitespace, context)
return vcs_gitdiff
class DiffProcessor(object):
Give it a unified diff and it returns a list of the files that were
mentioned in the diff together with a dict of meta information that
can be used to render it in a HTML template.
_chunk_re = re.compile(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')
_newline_marker = '\\ No newline at end of file\n'
def __init__(self, diff, differ='diff', format='gitdiff'):
:param diff: a text in diff format or generator
:param format: format of diff passed, `udiff` or `gitdiff`
if isinstance(diff, basestring):
diff = [diff]
self.__udiff = diff
self.__format = format
self.adds = 0
self.removes = 0
if isinstance(self.__udiff, basestring):
self.lines = iter(self.__udiff.splitlines(1))
elif self.__format == 'gitdiff':
udiff_copy = self.copy_iterator()
self.lines = imap(self.escaper, self._parse_gitdiff(udiff_copy))
self.lines = imap(self.escaper, udiff_copy)
# Select a differ.
if differ == 'difflib':
self.differ = self._highlight_line_difflib
self.differ = self._highlight_line_udiff
def escaper(self, string):
return markupsafe.escape(string)
def copy_iterator(self):
make a fresh copy of generator, we should not iterate thru
an original as it's needed for repeating operations on
this instance of DiffProcessor
self.__udiff, iterator_copy = tee(self.__udiff)
return iterator_copy
def _extract_rev(self, line1, line2):
Extract the operation (A/M/D), filename and revision hint from a line.
try:
@@ -300,137 +301,144 @@ class DiffProcessor(object):
while 1:
# continue until we found the old file
if not line.startswith('--- '):
line = lineiter.next()
continue
chunks = []
stats = [0, 0]
operation, filename, old_rev, new_rev = \
self._extract_rev(line, lineiter.next())
files.append({
'filename': filename,
'old_revision': old_rev,
'new_revision': new_rev,
'chunks': chunks,
'operation': operation,
'stats': stats,
})
while line:
match = self._chunk_re.match(line)
if not match:
break
lines = []
chunks.append(lines)
old_line, old_end, new_line, new_end = \
[int(x or 1) for x in match.groups()[:-1]]
old_line -= 1
new_line -= 1
gr = match.groups()
context = len(gr) == 5
old_end += old_line
new_end += new_line
if context:
# skip context only if it's first line
if int(gr[0]) > 1:
lines.append({
'old_lineno': '...',
'new_lineno': '...',
'action': 'context',
'line': line,
while old_line < old_end or new_line < new_end:
if line:
command, line = line[0], line[1:]
command = line[0]
if command in ['+', '-', ' ']:
#only modify the line if it's actually a diff
# thing
line = line[1:]
command = ' '
affects_old = affects_new = False
# ignore those if we don't expect them
if command in '#@':
elif command == '+':
affects_new = True
action = 'add'
stats[0] += 1
elif command == '-':
affects_old = True
action = 'del'
stats[1] += 1
affects_old = affects_new = True
action = 'unmod'
if line.find('No newline at end of file') != -1:
'line': line
if line != self._newline_marker:
old_line += affects_old
new_line += affects_new
'old_lineno': affects_old and old_line or '',
'new_lineno': affects_new and new_line or '',
'action': action,
if line == self._newline_marker:
# we need to append to lines, since this is not
# counted in the line specs of diff
except StopIteration:
pass
sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])
if inline_diff is False:
return sorted(files, key=sorter)
# highlight inline changes
for diff_data in files:
for chunk in diff_data['chunks']:
lineiter = iter(chunk)
if line['action'] not in ['unmod', 'context']:
nextline = lineiter.next()
if nextline['action'] in ['unmod', 'context'] or \
nextline['action'] == line['action']:
self.differ(line, nextline)
def prepare(self, inline_diff=True):
Prepare the passed udiff for HTML rendering. It'l return a list
of dicts
return self._parse_udiff(inline_diff=inline_diff)
def _safe_id(self, idstring):
"""Make a string safe for including in an id attribute.
The HTML spec says that id attributes 'must begin with
a letter ([A-Za-z]) and may be followed by any number
of letters, digits ([0-9]), hyphens ("-"), underscores
("_"), colons (":"), and periods (".")'. These regexps
are slightly over-zealous, in that they remove colons
and periods unnecessarily.
Whitespace is transformed into underscores, and then
anything which is not a hyphen or a character that
matches \w (alphanumerics and underscore) is removed.
Status change: