Show More
@@ -279,11 +279,10 b' class ChangesetController(BaseRepoContro' | |||||
279 | diff_processor = diffs.DiffProcessor(raw_diff, |
|
279 | diff_processor = diffs.DiffProcessor(raw_diff, | |
280 | vcs=c.db_repo_scm_instance.alias, |
|
280 | vcs=c.db_repo_scm_instance.alias, | |
281 | diff_limit=diff_limit) |
|
281 | diff_limit=diff_limit) | |
282 | _parsed = diff_processor.prepare() |
|
|||
283 | c.limited_diff = False |
|
282 | c.limited_diff = False | |
284 | if isinstance(_parsed, LimitedDiffContainer): |
|
283 | if isinstance(diff_processor.parsed, LimitedDiffContainer): | |
285 | c.limited_diff = True |
|
284 | c.limited_diff = True | |
286 | for f in _parsed: |
|
285 | for f in diff_processor.parsed: | |
287 | st = f['stats'] |
|
286 | st = f['stats'] | |
288 | c.lines_added += st['added'] |
|
287 | c.lines_added += st['added'] | |
289 | c.lines_deleted += st['deleted'] |
|
288 | c.lines_deleted += st['deleted'] |
@@ -267,21 +267,20 b' class CompareController(BaseRepoControll' | |||||
267 |
|
267 | |||
268 | log.debug('running diff between %s and %s in %s', |
|
268 | log.debug('running diff between %s and %s in %s', | |
269 | rev1, c.cs_rev, org_repo.scm_instance.path) |
|
269 | rev1, c.cs_rev, org_repo.scm_instance.path) | |
270 |
|
|
270 | raw_diff = org_repo.scm_instance.get_diff(rev1=rev1, rev2=c.cs_rev, | |
271 | ignore_whitespace=ignore_whitespace, |
|
271 | ignore_whitespace=ignore_whitespace, | |
272 | context=line_context) |
|
272 | context=line_context) | |
273 |
|
273 | |||
274 |
diff_processor = diffs.DiffProcessor( |
|
274 | diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit) | |
275 | _parsed = diff_processor.prepare() |
|
|||
276 |
|
275 | |||
277 | c.limited_diff = False |
|
276 | c.limited_diff = False | |
278 | if isinstance(_parsed, LimitedDiffContainer): |
|
277 | if isinstance(diff_processor.parsed, LimitedDiffContainer): | |
279 | c.limited_diff = True |
|
278 | c.limited_diff = True | |
280 |
|
279 | |||
281 | c.file_diff_data = [] |
|
280 | c.file_diff_data = [] | |
282 | c.lines_added = 0 |
|
281 | c.lines_added = 0 | |
283 | c.lines_deleted = 0 |
|
282 | c.lines_deleted = 0 | |
284 | for f in _parsed: |
|
283 | for f in diff_processor.parsed: | |
285 | st = f['stats'] |
|
284 | st = f['stats'] | |
286 | c.lines_added += st['added'] |
|
285 | c.lines_added += st['added'] | |
287 | c.lines_deleted += st['deleted'] |
|
286 | c.lines_deleted += st['deleted'] |
@@ -74,13 +74,13 b' class FeedController(BaseRepoController)' | |||||
74 | diff_limit = safe_int(CONFIG.get('rss_cut_off_limit', 32 * 1024)) |
|
74 | diff_limit = safe_int(CONFIG.get('rss_cut_off_limit', 32 * 1024)) | |
75 | raw_diff = cs.diff() |
|
75 | raw_diff = cs.diff() | |
76 | diff_processor = DiffProcessor(raw_diff, |
|
76 | diff_processor = DiffProcessor(raw_diff, | |
77 |
diff_limit=diff_limit |
|
77 | diff_limit=diff_limit, | |
78 | _parsed = diff_processor.prepare(inline_diff=False) |
|
78 | inline_diff=False) | |
79 | limited_diff = False |
|
79 | limited_diff = False | |
80 | if isinstance(_parsed, LimitedDiffContainer): |
|
80 | if isinstance(diff_processor.parsed, LimitedDiffContainer): | |
81 | limited_diff = True |
|
81 | limited_diff = True | |
82 |
|
82 | |||
83 | for st in _parsed: |
|
83 | for st in diff_processor.parsed: | |
84 | st.update({'added': st['stats']['added'], |
|
84 | st.update({'added': st['stats']['added'], | |
85 | 'removed': st['stats']['deleted']}) |
|
85 | 'removed': st['stats']['deleted']}) | |
86 | changes.append('\n %(operation)s %(filename)s ' |
|
86 | changes.append('\n %(operation)s %(filename)s ' |
@@ -592,23 +592,22 b' class PullrequestsController(BaseRepoCon' | |||||
592 | log.debug('running diff between %s and %s in %s', |
|
592 | log.debug('running diff between %s and %s in %s', | |
593 | c.a_rev, c.cs_rev, org_scm_instance.path) |
|
593 | c.a_rev, c.cs_rev, org_scm_instance.path) | |
594 | try: |
|
594 | try: | |
595 |
|
|
595 | raw_diff = org_scm_instance.get_diff(rev1=safe_str(c.a_rev), rev2=safe_str(c.cs_rev), | |
596 | ignore_whitespace=ignore_whitespace, |
|
596 | ignore_whitespace=ignore_whitespace, | |
597 | context=line_context) |
|
597 | context=line_context) | |
598 | except ChangesetDoesNotExistError: |
|
598 | except ChangesetDoesNotExistError: | |
599 |
|
|
599 | raw_diff = _("The diff can't be shown - the PR revisions could not be found.") | |
600 |
diff_processor = diffs.DiffProcessor( |
|
600 | diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit) | |
601 | _parsed = diff_processor.prepare() |
|
|||
602 |
|
601 | |||
603 | c.limited_diff = False |
|
602 | c.limited_diff = False | |
604 | if isinstance(_parsed, LimitedDiffContainer): |
|
603 | if isinstance(diff_processor.parsed, LimitedDiffContainer): | |
605 | c.limited_diff = True |
|
604 | c.limited_diff = True | |
606 |
|
605 | |||
607 | c.file_diff_data = [] |
|
606 | c.file_diff_data = [] | |
608 | c.lines_added = 0 |
|
607 | c.lines_added = 0 | |
609 | c.lines_deleted = 0 |
|
608 | c.lines_deleted = 0 | |
610 |
|
609 | |||
611 | for f in _parsed: |
|
610 | for f in diff_processor.parsed: | |
612 | st = f['stats'] |
|
611 | st = f['stats'] | |
613 | c.lines_added += st['added'] |
|
612 | c.lines_added += st['added'] | |
614 | c.lines_deleted += st['deleted'] |
|
613 | c.lines_deleted += st['deleted'] |
@@ -72,13 +72,12 b' def wrapped_diff(filenode_old, filenode_' | |||||
72 | diff_limit is None or |
|
72 | diff_limit is None or | |
73 | (filenode_old.size < diff_limit and filenode_new.size < diff_limit)): |
|
73 | (filenode_old.size < diff_limit and filenode_new.size < diff_limit)): | |
74 |
|
74 | |||
75 |
|
|
75 | raw_diff = get_gitdiff(filenode_old, filenode_new, | |
76 | ignore_whitespace=ignore_whitespace, |
|
76 | ignore_whitespace=ignore_whitespace, | |
77 | context=line_context) |
|
77 | context=line_context) | |
78 |
diff_processor = DiffProcessor( |
|
78 | diff_processor = DiffProcessor(raw_diff) | |
79 | _parsed = diff_processor.prepare() |
|
79 | if diff_processor.parsed: # there should be exactly one element, for the specified file | |
80 | if _parsed: # there should be exactly one element, for the specified file |
|
80 | f = diff_processor.parsed[0] | |
81 | f = _parsed[0] |
|
|||
82 | op = f['operation'] |
|
81 | op = f['operation'] | |
83 | a_path = f['old_filename'] |
|
82 | a_path = f['old_filename'] | |
84 |
|
83 | |||
@@ -203,7 +202,7 b' class DiffProcessor(object):' | |||||
203 |
|
202 | |||
204 | _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)') |
|
203 | _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)') | |
205 |
|
204 | |||
206 | def __init__(self, diff, vcs='hg', diff_limit=None): |
|
205 | def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True): | |
207 | """ |
|
206 | """ | |
208 | :param diff: a text in diff format |
|
207 | :param diff: a text in diff format | |
209 | :param vcs: type of version control hg or git |
|
208 | :param vcs: type of version control hg or git | |
@@ -218,12 +217,10 b' class DiffProcessor(object):' | |||||
218 | self.adds = 0 |
|
217 | self.adds = 0 | |
219 | self.removes = 0 |
|
218 | self.removes = 0 | |
220 | # calculate diff size |
|
219 | # calculate diff size | |
221 | self.diff_size = len(diff) |
|
|||
222 | self.diff_limit = diff_limit |
|
220 | self.diff_limit = diff_limit | |
223 | self.cur_diff_size = 0 |
|
221 | self.cur_diff_size = 0 | |
224 | self.parsed = False |
|
|||
225 | self.parsed_diff = [] |
|
|||
226 | self.vcs = vcs |
|
222 | self.vcs = vcs | |
|
223 | self.parsed = self._parse_gitdiff(inline_diff=inline_diff) | |||
227 |
|
224 | |||
228 | def _escaper(self, string): |
|
225 | def _escaper(self, string): | |
229 | """ |
|
226 | """ | |
@@ -307,7 +304,7 b' class DiffProcessor(object):' | |||||
307 | diff_lines = (self._escaper(m.group(0)) for m in re.finditer(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do |
|
304 | diff_lines = (self._escaper(m.group(0)) for m in re.finditer(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do | |
308 | return meta_info, diff_lines |
|
305 | return meta_info, diff_lines | |
309 |
|
306 | |||
310 |
def _parse_gitdiff(self, inline_diff |
|
307 | def _parse_gitdiff(self, inline_diff): | |
311 | """Parse self._diff and return a list of dicts with meta info and chunks for each file. |
|
308 | """Parse self._diff and return a list of dicts with meta info and chunks for each file. | |
312 | If diff is truncated, wrap it in LimitedDiffContainer. |
|
309 | If diff is truncated, wrap it in LimitedDiffContainer. | |
313 | Optionally, do an extra pass and to extra markup of one-liner changes. |
|
310 | Optionally, do an extra pass and to extra markup of one-liner changes. | |
@@ -575,16 +572,6 b' class DiffProcessor(object):' | |||||
575 | idstring = re.sub(r'(?!-)\W', "", idstring).lower() |
|
572 | idstring = re.sub(r'(?!-)\W', "", idstring).lower() | |
576 | return idstring |
|
573 | return idstring | |
577 |
|
574 | |||
578 | def prepare(self, inline_diff=True): |
|
|||
579 | """ |
|
|||
580 | Prepare the passed udiff for HTML rendering. It'll return a list |
|
|||
581 | of dicts with diff information |
|
|||
582 | """ |
|
|||
583 | parsed = self._parse_gitdiff(inline_diff=inline_diff) |
|
|||
584 | self.parsed = True |
|
|||
585 | self.parsed_diff = parsed |
|
|||
586 | return parsed |
|
|||
587 |
|
||||
588 | def as_html(self, table_class='code-difftable', line_class='line', |
|
575 | def as_html(self, table_class='code-difftable', line_class='line', | |
589 | old_lineno_class='lineno old', new_lineno_class='lineno new', |
|
576 | old_lineno_class='lineno old', new_lineno_class='lineno new', | |
590 | no_lineno_class='lineno', |
|
577 | no_lineno_class='lineno', | |
@@ -604,10 +591,8 b' class DiffProcessor(object):' | |||||
604 | } |
|
591 | } | |
605 | else: |
|
592 | else: | |
606 | return label |
|
593 | return label | |
607 | if not self.parsed: |
|
|||
608 | self.prepare() |
|
|||
609 |
|
594 | |||
610 |
diff_lines = self.parsed |
|
595 | diff_lines = self.parsed | |
611 | if parsed_lines: |
|
596 | if parsed_lines: | |
612 | diff_lines = parsed_lines |
|
597 | diff_lines = parsed_lines | |
613 |
|
598 |
@@ -275,21 +275,19 b' class TestDiffLib(TestController):' | |||||
275 |
|
275 | |||
276 | @parametrize('diff_fixture', DIFF_FIXTURES) |
|
276 | @parametrize('diff_fixture', DIFF_FIXTURES) | |
277 | def test_diff(self, diff_fixture): |
|
277 | def test_diff(self, diff_fixture): | |
278 | diff = fixture.load_resource(diff_fixture, strip=False) |
|
278 | raw_diff = fixture.load_resource(diff_fixture, strip=False) | |
279 | vcs = 'hg' |
|
279 | vcs = 'hg' | |
280 | if diff_fixture.startswith('git_'): |
|
280 | if diff_fixture.startswith('git_'): | |
281 | vcs = 'git' |
|
281 | vcs = 'git' | |
282 | diff_proc = DiffProcessor(diff, vcs=vcs) |
|
282 | diff_processor = DiffProcessor(raw_diff, vcs=vcs) | |
283 | diff_proc_d = diff_proc.prepare() |
|
283 | data = [(x['filename'], x['operation'], x['stats']) for x in diff_processor.parsed] | |
284 | data = [(x['filename'], x['operation'], x['stats']) for x in diff_proc_d] |
|
|||
285 | expected_data = DIFF_FIXTURES[diff_fixture] |
|
284 | expected_data = DIFF_FIXTURES[diff_fixture] | |
286 | assert expected_data == data |
|
285 | assert expected_data == data | |
287 |
|
286 | |||
288 | def test_diff_markup(self): |
|
287 | def test_diff_markup(self): | |
289 | diff = fixture.load_resource('markuptest.diff', strip=False) |
|
288 | raw_diff = fixture.load_resource('markuptest.diff', strip=False) | |
290 | diff_proc = DiffProcessor(diff) |
|
289 | diff_processor = DiffProcessor(raw_diff) | |
291 | diff_proc_d = diff_proc.prepare() |
|
290 | chunks = diff_processor.parsed[0]['chunks'] | |
292 | chunks = diff_proc_d[0]['chunks'] |
|
|||
293 | assert not chunks[0] |
|
291 | assert not chunks[0] | |
294 | #from pprint import pprint; pprint(chunks[1]) |
|
292 | #from pprint import pprint; pprint(chunks[1]) | |
295 | l = ['\n'] |
|
293 | l = ['\n'] |
General Comments 0
You need to be logged in to leave comments.
Login now