Merge pull request #63 from leeor/master

added an argument to control tab expansion

cdiff.py

 
 class DiffMarker(object):
 
-    def markup(self, diffs, side_by_side=False, width=0):
+    def markup(self, diffs, side_by_side=False, width=0, tab_width=8):
         """Returns a generator"""
         if side_by_side:
             for diff in diffs:
-                for line in self._markup_side_by_side(diff, width):
+                for line in self._markup_side_by_side(diff, width, tab_width):
                     yield line
         else:
             for diff in diffs:
                 else:
                     yield self._markup_common(' ' + old[1])
 
-    def _markup_side_by_side(self, diff, width):
+    def _markup_side_by_side(self, diff, width, tab_width):
         """Returns a generator"""
         wrap_char = colorize('>', 'lightmagenta')
 
         def _normalize(line):
             return line.replace(
-                '\t', ' ' * 8).replace('\n', '').replace('\r', '')
+                '\t', ' ' * tab_width).replace('\n', '').replace('\r', '')
 
         def _fit_with_marker(text, markup_fn, width, pad=False):
             """Wrap or pad input pure text, then markup"""
     diffs = DiffParser(stream).get_diff_generator()
     marker = DiffMarker()
     color_diff = marker.markup(diffs, side_by_side=opts.side_by_side,
-                               width=opts.width)
+                               width=opts.width, tab_width=opts.tab_width)
 
     for line in color_diff:
         pager.stdin.write(line.encode('utf-8'))
     parser.add_option(
         '-c', '--color', default='auto', metavar='M',
         help="""colorize mode 'auto' (default), 'always', or 'never'""")
+    parser.add_option(
+        '-t', '--tab-width', type='int', default=8, metavar='N',
+        help="""convert tab characters to this many spcaes (default: 8)""")
 
     # Hack: use OptionGroup text for extra help message after option list
     option_group = OptionGroup(

tests/test_cdiff.py

             --- old
             +++ new
             hunk header
-            @@ -1,4 +1,4 @@
+            @@ -1,5 +1,5 @@
             -hhello
             +helloo
             +spammm
              world
             -garb
             -Again
+            -	tabbed
             +again
+            + spaced
         """
 
-        hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,4 +1,4 @@\n',
-                          (1, 4), (1, 4))
+        hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,5 +1,5 @@\n',
+                          (1, 5), (1, 5))
         hunk.append(('-', 'hhello\n'))
         hunk.append(('+', 'helloo\n'))
         hunk.append(('+', 'spammm\n'))
         hunk.append((' ', 'world\n'))
         hunk.append(('-', 'garb\n'))
         hunk.append(('-', 'Again\n'))
+        hunk.append(('-', '	tabbed\n'))
         hunk.append(('+', 'again\n'))
+        hunk.append(('+', ' spaced\n'))
         diff = cdiff.UnifiedDiff(
             ['header\n'], '--- old\n', '+++ new\n', [hunk])
         return diff
         diff = self._init_diff()
         marker = cdiff.DiffMarker()
 
-        out = list(marker._markup_side_by_side(diff, 7))
-        self.assertEqual(len(out), 10)
+        out = list(marker._markup_side_by_side(diff, 7, 8))
+        self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
         for markup in out:
         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
         self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
-        self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,5 +1,5 @@\n\x1b[0m')
         self.assertEqual(
             out[5],
             '\x1b[33m1\x1b[0m '
             '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m   '
             '\x1b[0m\x1b[33m4\x1b[0m '
             '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
+        self.assertEqual(
+            out[10],
+            '\x1b[33m5\x1b[0m '
+            '\x1b[31m\x1b[7m\x1b[31m      \x1b[0m\x1b[1;35m>\x1b[0m '
+            '\x1b[0m\x1b[33m5\x1b[0m '
+            '\x1b[32m\x1b[7m\x1b[32m spaced\x1b[0m\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))
-        self.assertEqual(len(out), 10)
+        out = list(marker._markup_side_by_side(diff, -1, 8))
+        self.assertEqual(len(out), 11)
 
         self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m')
         self.assertEqual(out[1], '\x1b[33m--- old\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))
-        self.assertEqual(len(out), 10)
+        out = list(marker._markup_side_by_side(diff, 6, 8))
+        self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
         for markup in out:
         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
         self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
-        self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,5 +1,5 @@\n\x1b[0m')
         self.assertEqual(
             out[5],
             '\x1b[33m1\x1b[0m '
             '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m  '
             '\x1b[0m\x1b[33m4\x1b[0m '
             '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
+        self.assertEqual(
+            out[10],
+            '\x1b[33m5\x1b[0m '
+            '\x1b[31m\x1b[7m\x1b[31m     \x1b[0m\x1b[1;35m>\x1b[0m '
+            '\x1b[0m\x1b[33m5\x1b[0m '
+            '\x1b[32m\x1b[7m\x1b[32m spac\x1b[0m\x1b[1;35m>\x1b[0m\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))
-        self.assertEqual(len(out), 10)
+        out = list(marker._markup_side_by_side(diff, 5, 8))
+        self.assertEqual(len(out), 11)
 
         sys.stdout.write('\n')
         for markup in out:
         self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
         self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
         self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
-        self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,5 +1,5 @@\n\x1b[0m')
         self.assertEqual(
             out[5],
             '\x1b[33m1\x1b[0m '
             '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m '
             '\x1b[0m\x1b[33m4\x1b[0m '
             '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
+        self.assertEqual(
+            out[10],
+            '\x1b[33m5\x1b[0m '
+            '\x1b[31m\x1b[7m\x1b[31m    \x1b[0m\x1b[1;35m>\x1b[0m '
+            '\x1b[0m\x1b[33m5\x1b[0m '
+            '\x1b[32m\x1b[7m\x1b[32m spa\x1b[0m\x1b[1;35m>\x1b[0m\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))
+        self.assertEqual(len(out), 11)
+
+        sys.stdout.write('\n')
+        for markup in out:
+            sys.stdout.write(markup)
+
+        self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m')
+        self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
+        self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
+        self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
+        self.assertEqual(out[4], '\x1b[1;34m@@ -1,5 +1,5 @@\n\x1b[0m')
+        self.assertEqual(
+            out[5],
+            '\x1b[33m1\x1b[0m '
+            '\x1b[31m\x1b[7m\x1b[31mh\x1b[0m\x1b[31mhello\x1b[0m   '
+            '\x1b[0m\x1b[33m1\x1b[0m '
+            '\x1b[32mhello\x1b[7m\x1b[32mo\x1b[0m\x1b[32m\x1b[0m\n')
+        self.assertEqual(
+            out[6],
+            '\x1b[33m '
+            '\x1b[0m          '
+            '\x1b[0m\x1b[33m2\x1b[0m '
+            '\x1b[32mspammm\x1b[0m\n')
+        self.assertEqual(
+            out[7],
+            '\x1b[33m2\x1b[0m '
+            '\x1b[0mworld\x1b[0m    '
+            '\x1b[0m\x1b[33m3\x1b[0m '
+            '\x1b[0mworld\x1b[0m\n')
+        self.assertEqual(
+            out[8],
+            '\x1b[33m3\x1b[0m '
+            '\x1b[1;31mgarb\x1b[0m '
+            '\x1b[0m\x1b[33m '
+            '\x1b[0m \n')
+        self.assertEqual(
+            out[9],
+            '\x1b[33m4\x1b[0m '
+            '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m    '
+            '\x1b[0m\x1b[33m4\x1b[0m '
+            '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
+        self.assertEqual(
+            out[10],
+            '\x1b[33m5\x1b[0m '
+            '\x1b[31m\x1b[7m\x1b[31m  tabbed\x1b[0m '
+            '\x1b[0m\x1b[33m5\x1b[0m '
+            '\x1b[32m\x1b[7m\x1b[32m spaced\x1b[0m\x1b[32m\x1b[0m\n')
 
 
 class UnifiedDiffTest(unittest.TestCase):