Refactor: init DiffMarker object with flags.

Do not test internal methods.

cdiff.py

 
 class DiffMarker(object):
 
-    def markup(self, diffs, side_by_side=False, width=0, tab_width=8,
-               wrap=False):
+    def __init__(self, side_by_side=False, width=0, tab_width=8, wrap=False):
+        self._side_by_side = side_by_side
+        self._width = width
+        self._tab_width = tab_width
+        self._wrap = wrap
+
+    def markup(self, diff):
         """Returns a generator"""
-        if side_by_side:
-            for diff in diffs:
-                for line in self._markup_side_by_side(diff, width, tab_width,
-                                                      wrap):
-                    yield line
+        if self._side_by_side:
+            for line in self._markup_side_by_side(diff):
+                yield line
         else:
-            for diff in diffs:
-                for line in self._markup_traditional(diff):
-                    yield line
+            for line in self._markup_traditional(diff):
+                yield line
 
     def _markup_traditional(self, diff):
         """Returns a generator"""
                 else:
                     yield self._markup_common(' ' + old[1])
 
-    def _markup_side_by_side(self, diff, width, tab_width, wrap):
+    def _markup_side_by_side(self, diff):
         """Returns a generator"""
 
         def _normalize(line):
-            return line.replace(
-                '\t', ' ' * tab_width).replace('\n', '').replace('\r', '')
+            return (line
+                    .replace('\t', ' ' * self._tab_width)
+                    .replace('\n', '')
+                    .replace('\r', ''))
 
-        def _fit_with_marker_mix(text, base_color, width):
+        def _fit_with_marker_mix(text, base_color):
             """Wrap input text which contains mdiff tags, markup at the
             meantime
             """
         num_width = max(len(str(max1)), len(str(max2)))
 
         # Set up line width
+        width = self._width
         if width <= 0:
             # Autodetection of text width according to terminal size
             try:
                         left = self._markup_old(left)
                         right = ''
                     else:
-                        left = _fit_with_marker_mix(left, 'red', width)
-                        right = _fit_with_marker_mix(right, 'green', width)
+                        left = _fit_with_marker_mix(left, 'red')
+                        right = _fit_with_marker_mix(right, 'green')
                 else:
                     left = self._markup_common(left)
                     right = self._markup_common(right)
 
-                if wrap:
+                if self._wrap:
                     # Need to wrap long lines, so here we'll iterate,
                     # shaving off `width` chars from both left and right
                     # strings, until both are empty. Also, line number needs to
         pager_cmd, stdin=subprocess.PIPE, stdout=sys.stdout)
 
     diffs = DiffParser(stream).get_diff_generator()
-    marker = DiffMarker()
-    color_diff = marker.markup(diffs, side_by_side=opts.side_by_side,
-                               width=opts.width, tab_width=opts.tab_width,
-                               wrap=opts.wrap)
-
-    for line in color_diff:
-        pager.stdin.write(line.encode('utf-8'))
+    for diff in diffs:
+        marker = DiffMarker(side_by_side=opts.side_by_side, width=opts.width,
+                            tab_width=opts.tab_width, wrap=opts.wrap)
+        color_diff = marker.markup(diff)
+        for line in color_diff:
+            pager.stdin.write(line.encode('utf-8'))
 
     pager.stdin.close()
     pager.wait()

tests/test_cdiff.py

             ['header\n'], '--- old\n', '+++ new\n', [hunk])
         return diff
 
-    def test_markup_mix(self):
-        marker = cdiff.DiffMarker()
-        line = 'foo \x00-del\x01 \x00+add\x01 \x00^chg\x01 bar'
-        base_color = 'red'
-        self.assertEqual(
-            marker._markup_mix(line, base_color),
-            '\x1b[31mfoo \x1b[7m\x1b[31mdel\x1b[0m\x1b[31m '
-            '\x1b[7m\x1b[31madd\x1b[0m\x1b[31m '
-            '\x1b[4m\x1b[31mchg\x1b[0m\x1b[31m bar\x1b[0m')
-
     def test_markup_traditional_hunk_header(self):
         hunk = cdiff.Hunk(['hunk header\n'], '@@ -0 +0 @@\n', (0, 0), (0, 0))
         diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
         marker = cdiff.DiffMarker()
 
-        out = list(marker._markup_traditional(diff))
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
 
         self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
         diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
         marker = cdiff.DiffMarker()
 
-        out = list(marker._markup_traditional(diff))
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
 
         self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
         diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
         marker = cdiff.DiffMarker()
 
-        out = list(marker._markup_traditional(diff))
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 4)
 
         self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
         diff = cdiff.UnifiedDiff([], '--- old\n', '+++ new\n', [hunk])
         marker = cdiff.DiffMarker()
 
-        out = list(marker._markup_traditional(diff))
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 6)
 
         self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
 
     def test_markup_side_by_side_padded(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker()
+        marker = cdiff.DiffMarker(side_by_side=True, width=7)
 
-        out = list(marker._markup_side_by_side(diff, 7, 8, False))
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
     # This test is not valid anymore
     def __test_markup_side_by_side_neg_width(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker()
-        out = list(marker._markup_side_by_side(diff, -1, 8, False))
+        marker = cdiff.DiffMarker(side_by_side=True, width=-1)
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m')
 
     def test_markup_side_by_side_off_by_one(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker()
-        out = list(marker._markup_side_by_side(diff, 6, 8, False))
+        marker = cdiff.DiffMarker(side_by_side=True, width=6)
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
 
     def test_markup_side_by_side_wrapped(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker()
-        out = list(marker._markup_side_by_side(diff, 5, 8, False))
+        marker = cdiff.DiffMarker(side_by_side=True, width=5)
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
 
     def test_markup_side_by_side_tabbed(self):
         diff = self._init_diff()
-        marker = cdiff.DiffMarker()
-        out = list(marker._markup_side_by_side(diff, 8, 2, False))
+        marker = cdiff.DiffMarker(side_by_side=True, width=8, tab_width=2)
+        out = list(marker.markup(diff))
         self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')