diffs: inline prepare() into __init__ and make the result available as .parsed

Make it more clear what the DiffProcessor is: Something that works on a raw
diff as input, mainly compute when initialized, and returns an object where the
result is available in different ways.

kallithea/controllers/changeset.py

@@ -279,11 +279,10 b' class ChangesetController(BaseRepoContro'
                 diff_processor = diffs.DiffProcessor(raw_diff,
                                                      vcs=c.db_repo_scm_instance.alias,
                                                      diff_limit=diff_limit)
-                _parsed = diff_processor.prepare()
                 c.limited_diff = False
-                if isinstance(_parsed, LimitedDiffContainer):
+                if isinstance(diff_processor.parsed, LimitedDiffContainer):
                     c.limited_diff = True
-                for f in _parsed:
+                for f in diff_processor.parsed:
                     st = f['stats']
                     c.lines_added += st['added']
                     c.lines_deleted += st['deleted']

kallithea/controllers/compare.py

@@ -267,21 +267,20 b' class CompareController(BaseRepoControll'
 
         log.debug('running diff between %s and %s in %s',
                   rev1, c.cs_rev, org_repo.scm_instance.path)
-        txtdiff = org_repo.scm_instance.get_diff(rev1=rev1, rev2=c.cs_rev,
+        raw_diff = org_repo.scm_instance.get_diff(rev1=rev1, rev2=c.cs_rev,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
 
-        diff_processor = diffs.DiffProcessor(txtdiff or '', diff_limit=diff_limit)
-        _parsed = diff_processor.prepare()
+        diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit)
 
         c.limited_diff = False
-        if isinstance(_parsed, LimitedDiffContainer):
+        if isinstance(diff_processor.parsed, LimitedDiffContainer):
             c.limited_diff = True
 
         c.file_diff_data = []
         c.lines_added = 0
         c.lines_deleted = 0
-        for f in _parsed:
+        for f in diff_processor.parsed:
             st = f['stats']
             c.lines_added += st['added']
             c.lines_deleted += st['deleted']

kallithea/controllers/feed.py

@@ -74,13 +74,13 b' class FeedController(BaseRepoController)'
         diff_limit = safe_int(CONFIG.get('rss_cut_off_limit', 32 * 1024))
         raw_diff = cs.diff()
         diff_processor = DiffProcessor(raw_diff,
-                                       diff_limit=diff_limit)
-        _parsed = diff_processor.prepare(inline_diff=False)
+                                       diff_limit=diff_limit,
+                                       inline_diff=False)
         limited_diff = False
-        if isinstance(_parsed, LimitedDiffContainer):
+        if isinstance(diff_processor.parsed, LimitedDiffContainer):
             limited_diff = True
 
-        for st in _parsed:
+        for st in diff_processor.parsed:
             st.update({'added': st['stats']['added'],
                        'removed': st['stats']['deleted']})
             changes.append('\n %(operation)s %(filename)s '

kallithea/controllers/pullrequests.py

@@ -592,23 +592,22 b' class PullrequestsController(BaseRepoCon'
         log.debug('running diff between %s and %s in %s',
                   c.a_rev, c.cs_rev, org_scm_instance.path)
         try:
-            txtdiff = org_scm_instance.get_diff(rev1=safe_str(c.a_rev), rev2=safe_str(c.cs_rev),
+            raw_diff = org_scm_instance.get_diff(rev1=safe_str(c.a_rev), rev2=safe_str(c.cs_rev),
                                                 ignore_whitespace=ignore_whitespace,
                                                 context=line_context)
         except ChangesetDoesNotExistError:
-            txtdiff = _("The diff can't be shown - the PR revisions could not be found.")
-        diff_processor = diffs.DiffProcessor(txtdiff or '', diff_limit=diff_limit)
-        _parsed = diff_processor.prepare()
+            raw_diff = _("The diff can't be shown - the PR revisions could not be found.")
+        diff_processor = diffs.DiffProcessor(raw_diff or '', diff_limit=diff_limit)
 
         c.limited_diff = False
-        if isinstance(_parsed, LimitedDiffContainer):
+        if isinstance(diff_processor.parsed, LimitedDiffContainer):
             c.limited_diff = True
 
         c.file_diff_data = []
         c.lines_added = 0
         c.lines_deleted = 0
 
-        for f in _parsed:
+        for f in diff_processor.parsed:
             st = f['stats']
             c.lines_added += st['added']
             c.lines_deleted += st['deleted']

kallithea/lib/diffs.py

@@ -72,13 +72,12 b' def wrapped_diff(filenode_old, filenode_'
             diff_limit is None or
             (filenode_old.size < diff_limit and filenode_new.size < diff_limit)):
 
-        f_gitdiff = get_gitdiff(filenode_old, filenode_new,
+        raw_diff = get_gitdiff(filenode_old, filenode_new,
                                 ignore_whitespace=ignore_whitespace,
                                 context=line_context)
-        diff_processor = DiffProcessor(f_gitdiff)
-        _parsed = diff_processor.prepare()
-        if _parsed: # there should be exactly one element, for the specified file
-            f = _parsed[0]
+        diff_processor = DiffProcessor(raw_diff)
+        if diff_processor.parsed: # there should be exactly one element, for the specified file
+            f = diff_processor.parsed[0]
             op = f['operation']
             a_path = f['old_filename']
 
@@ -203,7 +202,7 b' class DiffProcessor(object):'
 
     _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)')
 
-    def __init__(self, diff, vcs='hg', diff_limit=None):
+    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):
         """
         :param diff:   a text in diff format
         :param vcs: type of version control hg or git
@@ -218,12 +217,10 b' class DiffProcessor(object):'
         self.adds = 0
         self.removes = 0
         # calculate diff size
-        self.diff_size = len(diff)
         self.diff_limit = diff_limit
         self.cur_diff_size = 0
-        self.parsed = False
-        self.parsed_diff = []
         self.vcs = vcs
+        self.parsed = self._parse_gitdiff(inline_diff=inline_diff)
 
     def _escaper(self, string):
         """
@@ -307,7 +304,7 b' class DiffProcessor(object):'
         diff_lines = (self._escaper(m.group(0)) for m in re.finditer(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do
         return meta_info, diff_lines
 
-    def _parse_gitdiff(self, inline_diff=True):
+    def _parse_gitdiff(self, inline_diff):
         """Parse self._diff and return a list of dicts with meta info and chunks for each file.
         If diff is truncated, wrap it in LimitedDiffContainer.
         Optionally, do an extra pass and to extra markup of one-liner changes.
@@ -575,16 +572,6 b' class DiffProcessor(object):'
         idstring = re.sub(r'(?!-)\W', "", idstring).lower()
         return idstring
 
-    def prepare(self, inline_diff=True):
-        """
-        Prepare the passed udiff for HTML rendering. It'll return a list
-        of dicts with diff information
-        """
-        parsed = self._parse_gitdiff(inline_diff=inline_diff)
-        self.parsed = True
-        self.parsed_diff = parsed
-        return parsed
-
     def as_html(self, table_class='code-difftable', line_class='line',
                 old_lineno_class='lineno old', new_lineno_class='lineno new',
                 no_lineno_class='lineno',
@@ -604,10 +591,8 b' class DiffProcessor(object):'
                 }
             else:
                 return label
-        if not self.parsed:
-            self.prepare()
 
-        diff_lines = self.parsed_diff
+        diff_lines = self.parsed
         if parsed_lines:
             diff_lines = parsed_lines
 

kallithea/tests/models/test_diff_parsers.py

@@ -275,21 +275,19 b' class TestDiffLib(TestController):'
 
     @parametrize('diff_fixture', DIFF_FIXTURES)
     def test_diff(self, diff_fixture):
-        diff = fixture.load_resource(diff_fixture, strip=False)
+        raw_diff = fixture.load_resource(diff_fixture, strip=False)
         vcs = 'hg'
         if diff_fixture.startswith('git_'):
             vcs = 'git'
-        diff_proc = DiffProcessor(diff, vcs=vcs)
-        diff_proc_d = diff_proc.prepare()
-        data = [(x['filename'], x['operation'], x['stats']) for x in diff_proc_d]
+        diff_processor = DiffProcessor(raw_diff, vcs=vcs)
+        data = [(x['filename'], x['operation'], x['stats']) for x in diff_processor.parsed]
         expected_data = DIFF_FIXTURES[diff_fixture]
         assert expected_data == data
 
     def test_diff_markup(self):
-        diff = fixture.load_resource('markuptest.diff', strip=False)
-        diff_proc = DiffProcessor(diff)
-        diff_proc_d = diff_proc.prepare()
-        chunks = diff_proc_d[0]['chunks']
+        raw_diff = fixture.load_resource('markuptest.diff', strip=False)
+        diff_processor = DiffProcessor(raw_diff)
+        chunks = diff_processor.parsed[0]['chunks']
         assert not chunks[0]
         #from pprint import pprint; pprint(chunks[1])
         l = ['\n']