- Naming enhancement for unified diff

cdiff.py

         return colorize(line, base_color)
 
 
-class Udiff(Diff):
+class UnifiedDiff(Diff):
 
     def is_old_path(self, line):
         return line.startswith('--- ')
 
     def is_hunk_meta(self, line):
         """Minimal valid hunk meta is like '@@ -1 +1 @@', note extra chars
-        might occur after the ending @@, e.g. in git log
+        might occur after the ending @@, e.g. in git log.  '## ' uaually
+        indicates svn property changes in output from `svn log --diff`
         """
         return (line.startswith('@@ -') and line.find(' @@') >= 8) or \
                (line.startswith('## -') and line.find(' ##') >= 8)
 class DiffParser(object):
 
     def __init__(self, stream):
-        """Detect Udiff with 3 conditions, '## ' uaually indicates svn property
-        changes in output from `svn log --diff`
-        """
         self._stream = stream
 
-        header = self._stream.read_stream_header(100)
+        header = [decode(line) for line in
+                  self._stream.read_stream_header(100)]
         size = len(header)
+
         for n in range(size):
-            if decode(header[n]).startswith('--- ') and (n < size - 1) and \
-                    decode(header[n+1]).startswith('+++ '):
-                self._type = 'udiff'
+            if header[n].startswith('--- ') and (n < size - 1) and \
+                    header[n+1].startswith('+++ '):
+                self._type = 'unified'
                 break
         else:
             if size < 4:
                 # more than 3 lines, happens with `git diff` on a file that
                 # only has perm bits changes
                 #
-                self._type = 'udiff'
+                self._type = 'unified'
             else:
                 raise RuntimeError('unknown diff type')
 
     def get_diff_generator(self):
         """parse all diff lines, construct a list of Diff objects"""
-        if self._type == 'udiff':
-            difflet = Udiff(None, None, None, None)
+        if self._type == 'unified':
+            difflet = UnifiedDiff(None, None, None, None)
         else:
             raise RuntimeError('unsupported diff format')
 

tests/test_cdiff.py

         return item
 
 
-class TestPatchStream(unittest.TestCase):
+class PatchStreamTest(unittest.TestCase):
 
     def test_is_empty(self):
         stream = cdiff.PatchStream(Sequential([]))
         self.assertEqual(out, items)
 
 
-class TestHunk(unittest.TestCase):
+class HunkTest(unittest.TestCase):
 
     def test_get_old_text(self):
         hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@', (1, 2), (1, 2))
         self.assertEqual(hunk._get_new_text(), ['bar\n', 'common\n'])
 
 
-class TestDiff(unittest.TestCase):
+class DiffTest(unittest.TestCase):
 
     def _init_diff(self):
         """Return a minimal diff contains all required samples
             '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
 
 
-class TestUdiff(unittest.TestCase):
+class UnifiedDiffTest(unittest.TestCase):
 
-    diff = cdiff.Udiff(None, None, None, None)
+    diff = cdiff.UnifiedDiff(None, None, None, None)
 
     def test_is_hunk_meta_normal(self):
         self.assertTrue(self.diff.is_hunk_meta('@@ -1 +1 @@'))
         self.assertFalse(self.diff.is_new('+++ considered as new path'))
 
 
-class TestDiffParser(unittest.TestCase):
+class DiffParserTest(unittest.TestCase):
 
     def test_type_detect(self):
-        patch = r"""\
+        patch = """\
 spam
 --- a
 +++ b
         items = patch.splitlines(True)
         stream = cdiff.PatchStream(Sequential(items))
         parser = cdiff.DiffParser(stream)
-        self.assertEqual(parser._type, 'udiff')
+        self.assertEqual(parser._type, 'unified')
 
     def test_type_detect_neg(self):
-        patch = r"""\
+        patch = """\
 spam
 --- a
 spam
         self.assertRaises(RuntimeError, cdiff.DiffParser, stream)
 
     def test_parse_invalid_hunk_meta(self):
-        patch = r"""\
+        patch = """\
 spam
 --- a
 +++ b
         self.assertRaises(RuntimeError, list, parser.get_diff_generator())
 
     def test_parse_dangling_header(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertEqual(len(out[1]._hunks), 0)
 
     def test_parse_missing_new_path(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertRaises(AssertionError, list, parser.get_diff_generator())
 
     def test_parse_missing_hunk_meta(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertEqual(len(out[1]._hunks), 0)
 
     def test_parse_missing_hunk_list(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertRaises(AssertionError, list, parser.get_diff_generator())
 
     def test_parse_only_in_dir(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertEqual(len(out[2]._hunks[0]._hunk_list), 3)
 
     def test_parse_only_in_dir_at_last(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertEqual(out[1]._headers, ['Only in foo: foo\n'])
 
     def test_parse_binary_differ_diff_ru(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 @@ -1,2 +1,2 @@
         self.assertEqual(len(out[2]._hunks[0]._hunk_list), 3)
 
     def test_parse_binary_differ_git(self):
-        patch = r"""\
+        patch = """\
 diff --git a/foo b/foo
 index 529d8a3..ad71911 100755
 --- a/foo
         self.assertEqual(len(out[2]._hunks[0]._hunk_list), 3)
 
     def test_parse_svn_prop(self):
-        patch = r"""\
+        patch = """\
 --- a
 +++ b
 Added: svn:executable
 ## -0,0 +1 ##
 +*
-\ No newline at end of property
+\\ No newline at end of property
 Added: svn:keywords
 ## -0,0 +1 ##
 +Id
         self.assertEqual(hunk._hunk_list, [('+', 'Id\n')])
 
 
-class TestMain(unittest.TestCase):
+class MainTest(unittest.TestCase):
 
     def setUp(self):
         self._cwd = os.getcwd()