Port dulwich.config to python3.

dulwich/config.py

@@ -26,7 +26,6 @@ TODO:
 
 import errno
 import os
-import re
 
 try:
     from collections import (
@@ -69,9 +68,9 @@ class Config(object):
             value = self.get(section, name)
         except KeyError:
             return default
-        if value.lower() == "true":
+        if value.lower() == b"true":
             return True
-        elif value.lower() == "false":
+        elif value.lower() == b"false":
             return False
         raise ValueError("not a valid boolean string: %r" % value)
 
@@ -142,7 +141,7 @@ class ConfigDict(Config, MutableMapping):
             return (parts[0], None, parts[1])
 
     def get(self, section, name):
-        if isinstance(section, basestring):
+        if not isinstance(section, tuple):
             section = (section, )
         if len(section) > 1:
             try:
@@ -152,37 +151,37 @@ class ConfigDict(Config, MutableMapping):
         return self._values[(section[0],)][name]
 
     def set(self, section, name, value):
-        if isinstance(section, basestring):
+        if not isinstance(section, tuple):
             section = (section, )
         self._values.setdefault(section, OrderedDict())[name] = value
 
     def iteritems(self, section):
-        return self._values.get(section, OrderedDict()).iteritems()
+        return self._values.get(section, OrderedDict()).items()
 
     def itersections(self):
         return self._values.keys()
 
 
 def _format_string(value):
-    if (value.startswith(" ") or
-        value.startswith("\t") or
-        value.endswith(" ") or
-        value.endswith("\t")):
-        return '"%s"' % _escape_value(value)
+    if (value.startswith(b" ") or
+        value.startswith(b"\t") or
+        value.endswith(b" ") or
+        value.endswith(b"\t")):
+        return b'"' + _escape_value(value) + b'"'
     return _escape_value(value)
 
 
 def _parse_string(value):
-    value = value.strip()
-    ret = []
-    block = []
+    value = bytearray(value.strip())
+    ret = bytearray()
+    block = bytearray()
     in_quotes = False
     for c in value:
-        if c == "\"":
+        if c == ord(b"\""):
             in_quotes = (not in_quotes)
-            ret.append(_unescape_value("".join(block)))
-            block = []
-        elif c in ("#", ";") and not in_quotes:
+            ret.extend(_unescape_value(block))
+            block = bytearray()
+        elif c in (ord(b"#"), ord(b";")) and not in_quotes:
             # the rest of the line is a comment
             break
         else:
@@ -191,46 +190,58 @@ def _parse_string(value):
     if in_quotes:
         raise ValueError("value starts with quote but lacks end quote")
 
-    ret.append(_unescape_value("".join(block)).rstrip())
+    ret.extend(_unescape_value(block).rstrip())
 
-    return "".join(ret)
+    return bytes(ret)
 
 
 def _unescape_value(value):
     """Unescape a value."""
-    def unescape(c):
-        return {
-            "\\\\": "\\",
-            "\\\"": "\"",
-            "\\n": "\n",
-            "\\t": "\t",
-            "\\b": "\b",
-            }[c.group(0)]
-    return re.sub(r"(\\.)", unescape, value)
+    if type(value) != bytearray:
+        raise TypeError("expected: bytearray")
+    table = {
+        ord(b"\\"): ord(b"\\"),
+        ord(b"\""): ord(b"\""),
+        ord(b"n"): ord(b"\n"),
+        ord(b"t"): ord(b"\t"),
+        ord(b"b"): ord(b"\b"),
+        }
+    ret = bytearray()
+    i = 0
+    while i < len(value):
+        if value[i] == ord(b"\\"):
+            i += 1
+            ret.append(table[value[i]])
+        else:
+            ret.append(value[i])
+        i += 1
+    return ret
 
 
 def _escape_value(value):
     """Escape a value."""
-    return value.replace("\\", "\\\\").replace("\n", "\\n").replace("\t", "\\t").replace("\"", "\\\"")
+    return value.replace(b"\\", b"\\\\").replace(b"\n", b"\\n").replace(b"\t", b"\\t").replace(b"\"", b"\\\"")
 
 
 def _check_variable_name(name):
-    for c in name:
-        if not c.isalnum() and c != '-':
+    for i in range(len(name)):
+        c = name[i:i+1]
+        if not c.isalnum() and c != b'-':
             return False
     return True
 
 
 def _check_section_name(name):
-    for c in name:
-        if not c.isalnum() and c not in ('-', '.'):
+    for i in range(len(name)):
+        c = name[i:i+1]
+        if not c.isalnum() and c not in (b'-', b'.'):
             return False
     return True
 
 
 def _strip_comments(line):
-    line = line.split("#")[0]
-    line = line.split(";")[0]
+    line = line.split(b"#")[0]
+    line = line.split(b";")[0]
     return line
 
 
@@ -247,47 +258,47 @@ class ConfigFile(ConfigDict):
         for lineno, line in enumerate(f.readlines()):
             line = line.lstrip()
             if setting is None:
-                if len(line) > 0 and line[0] == "[":
+                if len(line) > 0 and line[:1] == b"[":
                     line = _strip_comments(line).rstrip()
-                    last = line.index("]")
+                    last = line.index(b"]")
                     if last == -1:
                         raise ValueError("expected trailing ]")
-                    pts = line[1:last].split(" ", 1)
+                    pts = line[1:last].split(b" ", 1)
                     line = line[last+1:]
                     pts[0] = pts[0].lower()
                     if len(pts) == 2:
-                        if pts[1][0] != "\"" or pts[1][-1] != "\"":
+                        if pts[1][:1] != b"\"" or pts[1][-1:] != b"\"":
                             raise ValueError(
-                                "Invalid subsection " + pts[1])
+                                "Invalid subsection %r" % pts[1])
                         else:
                             pts[1] = pts[1][1:-1]
                         if not _check_section_name(pts[0]):
-                            raise ValueError("invalid section name %s" %
+                            raise ValueError("invalid section name %r" %
                                              pts[0])
                         section = (pts[0], pts[1])
                     else:
                         if not _check_section_name(pts[0]):
-                            raise ValueError("invalid section name %s" %
+                            raise ValueError("invalid section name %r" %
                                     pts[0])
-                        pts = pts[0].split(".", 1)
+                        pts = pts[0].split(b".", 1)
                         if len(pts) == 2:
                             section = (pts[0], pts[1])
                         else:
                             section = (pts[0], )
                     ret._values[section] = OrderedDict()
-                if _strip_comments(line).strip() == "":
+                if _strip_comments(line).strip() == b"":
                     continue
                 if section is None:
                     raise ValueError("setting %r without section" % line)
                 try:
-                    setting, value = line.split("=", 1)
+                    setting, value = line.split(b"=", 1)
                 except ValueError:
                     setting = line
-                    value = "true"
+                    value = b"true"
                 setting = setting.strip().lower()
                 if not _check_variable_name(setting):
                     raise ValueError("invalid variable name %s" % setting)
-                if value.endswith("\\\n"):
+                if value.endswith(b"\\\n"):
                     value = value[:-2]
                     continuation = True
                 else:
@@ -297,7 +308,7 @@ class ConfigFile(ConfigDict):
                 if not continuation:
                     setting = None
             else:  # continuation line
-                if line.endswith("\\\n"):
+                if line.endswith(b"\\\n"):
                     line = line[:-2]
                     continuation = True
                 else:
@@ -325,18 +336,18 @@ class ConfigFile(ConfigDict):
 
     def write_to_file(self, f):
         """Write configuration to a file-like object."""
-        for section, values in self._values.iteritems():
+        for section, values in self._values.items():
             try:
                 section_name, subsection_name = section
             except ValueError:
                 (section_name, ) = section
                 subsection_name = None
             if subsection_name is None:
-                f.write("[%s]\n" % section_name)
+                f.write(b"[" + section_name + b"]\n")
             else:
-                f.write("[%s \"%s\"]\n" % (section_name, subsection_name))
-            for key, value in values.iteritems():
-                f.write("\t%s = %s\n" % (key, _escape_value(value)))
+                f.write(b"[" + section_name + b" \"" + subsection_name + b"\"]\n")
+            for key, value in values.items():
+                f.write(b"\t" + key + b" = " + _escape_value(value) + b"\n")
 
 
 class StackedConfig(Config):

dulwich/tests/test_config.py

@@ -31,10 +31,8 @@ from dulwich.config import (
     _unescape_value,
     )
 from dulwich.tests import TestCase
-from dulwich.tests.utils import skipIfPY3
 
 
-@skipIfPY3
 class ConfigFileTests(TestCase):
 
     def from_file(self, text):
@@ -47,251 +45,243 @@ class ConfigFileTests(TestCase):
         self.assertEqual(ConfigFile(), ConfigFile())
 
     def test_default_config(self):
-        cf = self.from_file("""[core]
+        cf = self.from_file(b"""[core]
 	repositoryformatversion = 0
 	filemode = true
 	bare = false
 	logallrefupdates = true
 """)
-        self.assertEqual(ConfigFile({("core", ): {
-            "repositoryformatversion": "0",
-            "filemode": "true",
-            "bare": "false",
-            "logallrefupdates": "true"}}), cf)
+        self.assertEqual(ConfigFile({(b"core", ): {
+            b"repositoryformatversion": b"0",
+            b"filemode": b"true",
+            b"bare": b"false",
+            b"logallrefupdates": b"true"}}), cf)
 
     def test_from_file_empty(self):
-        cf = self.from_file("")
+        cf = self.from_file(b"")
         self.assertEqual(ConfigFile(), cf)
 
     def test_empty_line_before_section(self):
-        cf = self.from_file("\n[section]\n")
-        self.assertEqual(ConfigFile({("section", ): {}}), cf)
+        cf = self.from_file(b"\n[section]\n")
+        self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
 
     def test_comment_before_section(self):
-        cf = self.from_file("# foo\n[section]\n")
-        self.assertEqual(ConfigFile({("section", ): {}}), cf)
+        cf = self.from_file(b"# foo\n[section]\n")
+        self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
 
     def test_comment_after_section(self):
-        cf = self.from_file("[section] # foo\n")
-        self.assertEqual(ConfigFile({("section", ): {}}), cf)
+        cf = self.from_file(b"[section] # foo\n")
+        self.assertEqual(ConfigFile({(b"section", ): {}}), cf)
 
     def test_comment_after_variable(self):
-        cf = self.from_file("[section]\nbar= foo # a comment\n")
-        self.assertEqual(ConfigFile({("section", ): {"bar": "foo"}}), cf)
+        cf = self.from_file(b"[section]\nbar= foo # a comment\n")
+        self.assertEqual(ConfigFile({(b"section", ): {b"bar": b"foo"}}), cf)
 
     def test_from_file_section(self):
-        cf = self.from_file("[core]\nfoo = bar\n")
-        self.assertEqual("bar", cf.get(("core", ), "foo"))
-        self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
+        cf = self.from_file(b"[core]\nfoo = bar\n")
+        self.assertEqual(b"bar", cf.get((b"core", ), b"foo"))
+        self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
 
     def test_from_file_section_case_insensitive(self):
-        cf = self.from_file("[cOre]\nfOo = bar\n")
-        self.assertEqual("bar", cf.get(("core", ), "foo"))
-        self.assertEqual("bar", cf.get(("core", "foo"), "foo"))
+        cf = self.from_file(b"[cOre]\nfOo = bar\n")
+        self.assertEqual(b"bar", cf.get((b"core", ), b"foo"))
+        self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
 
     def test_from_file_with_mixed_quoted(self):
-        cf = self.from_file("[core]\nfoo = \"bar\"la\n")
-        self.assertEqual("barla", cf.get(("core", ), "foo"))
+        cf = self.from_file(b"[core]\nfoo = \"bar\"la\n")
+        self.assertEqual(b"barla", cf.get((b"core", ), b"foo"))
 
     def test_from_file_with_open_quoted(self):
         self.assertRaises(ValueError,
-            self.from_file, "[core]\nfoo = \"bar\n")
+            self.from_file, b"[core]\nfoo = \"bar\n")
 
     def test_from_file_with_quotes(self):
         cf = self.from_file(
-            "[core]\n"
-            'foo = " bar"\n')
-        self.assertEqual(" bar", cf.get(("core", ), "foo"))
+            b"[core]\n"
+            b'foo = " bar"\n')
+        self.assertEqual(b" bar", cf.get((b"core", ), b"foo"))
 
     def test_from_file_with_interrupted_line(self):
         cf = self.from_file(
-            "[core]\n"
-            'foo = bar\\\n'
-            ' la\n')
-        self.assertEqual("barla", cf.get(("core", ), "foo"))
+            b"[core]\n"
+            b'foo = bar\\\n'
+            b' la\n')
+        self.assertEqual(b"barla", cf.get((b"core", ), b"foo"))
 
     def test_from_file_with_boolean_setting(self):
         cf = self.from_file(
-            "[core]\n"
-            'foo\n')
-        self.assertEqual("true", cf.get(("core", ), "foo"))
+            b"[core]\n"
+            b'foo\n')
+        self.assertEqual(b"true", cf.get((b"core", ), b"foo"))
 
     def test_from_file_subsection(self):
-        cf = self.from_file("[branch \"foo\"]\nfoo = bar\n")
-        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+        cf = self.from_file(b"[branch \"foo\"]\nfoo = bar\n")
+        self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
     def test_from_file_subsection_invalid(self):
         self.assertRaises(ValueError,
-            self.from_file, "[branch \"foo]\nfoo = bar\n")
+            self.from_file, b"[branch \"foo]\nfoo = bar\n")
 
     def test_from_file_subsection_not_quoted(self):
-        cf = self.from_file("[branch.foo]\nfoo = bar\n")
-        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+        cf = self.from_file(b"[branch.foo]\nfoo = bar\n")
+        self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
     def test_write_to_file_empty(self):
         c = ConfigFile()
         f = BytesIO()
         c.write_to_file(f)
-        self.assertEqual("", f.getvalue())
+        self.assertEqual(b"", f.getvalue())
 
     def test_write_to_file_section(self):
         c = ConfigFile()
-        c.set(("core", ), "foo", "bar")
+        c.set((b"core", ), b"foo", b"bar")
         f = BytesIO()
         c.write_to_file(f)
-        self.assertEqual("[core]\n\tfoo = bar\n", f.getvalue())
+        self.assertEqual(b"[core]\n\tfoo = bar\n", f.getvalue())
 
     def test_write_to_file_subsection(self):
         c = ConfigFile()
-        c.set(("branch", "blie"), "foo", "bar")
+        c.set((b"branch", b"blie"), b"foo", b"bar")
         f = BytesIO()
         c.write_to_file(f)
-        self.assertEqual("[branch \"blie\"]\n\tfoo = bar\n", f.getvalue())
+        self.assertEqual(b"[branch \"blie\"]\n\tfoo = bar\n", f.getvalue())
 
     def test_same_line(self):
-        cf = self.from_file("[branch.foo] foo = bar\n")
-        self.assertEqual("bar", cf.get(("branch", "foo"), "foo"))
+        cf = self.from_file(b"[branch.foo] foo = bar\n")
+        self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
 
-@skipIfPY3
 class ConfigDictTests(TestCase):
 
     def test_get_set(self):
         cd = ConfigDict()
-        self.assertRaises(KeyError, cd.get, "foo", "core")
-        cd.set(("core", ), "foo", "bla")
-        self.assertEqual("bla", cd.get(("core", ), "foo"))
-        cd.set(("core", ), "foo", "bloe")
-        self.assertEqual("bloe", cd.get(("core", ), "foo"))
+        self.assertRaises(KeyError, cd.get, b"foo", b"core")
+        cd.set((b"core", ), b"foo", b"bla")
+        self.assertEqual(b"bla", cd.get((b"core", ), b"foo"))
+        cd.set((b"core", ), b"foo", b"bloe")
+        self.assertEqual(b"bloe", cd.get((b"core", ), b"foo"))
 
     def test_get_boolean(self):
         cd = ConfigDict()
-        cd.set(("core", ), "foo", "true")
-        self.assertTrue(cd.get_boolean(("core", ), "foo"))
-        cd.set(("core", ), "foo", "false")
-        self.assertFalse(cd.get_boolean(("core", ), "foo"))
-        cd.set(("core", ), "foo", "invalid")
-        self.assertRaises(ValueError, cd.get_boolean, ("core", ), "foo")
+        cd.set((b"core", ), b"foo", b"true")
+        self.assertTrue(cd.get_boolean((b"core", ), b"foo"))
+        cd.set((b"core", ), b"foo", b"false")
+        self.assertFalse(cd.get_boolean((b"core", ), b"foo"))
+        cd.set((b"core", ), b"foo", b"invalid")
+        self.assertRaises(ValueError, cd.get_boolean, (b"core", ), b"foo")
 
     def test_dict(self):
         cd = ConfigDict()
-        cd.set(("core", ), "foo", "bla")
-        cd.set(("core2", ), "foo", "bloe")
+        cd.set((b"core", ), b"foo", b"bla")
+        cd.set((b"core2", ), b"foo", b"bloe")
 
-        self.assertEqual([("core", ), ("core2", )], cd.keys())
-        self.assertEqual(cd[("core", )], {'foo': 'bla'})
+        self.assertEqual([(b"core", ), (b"core2", )], list(cd.keys()))
+        self.assertEqual(cd[(b"core", )], {b'foo': b'bla'})
 
-        cd['a'] = 'b'
-        self.assertEqual(cd['a'], 'b')
+        cd[b'a'] = b'b'
+        self.assertEqual(cd[b'a'], b'b')
 
     def test_iteritems(self):
         cd = ConfigDict()
-        cd.set(("core", ), "foo", "bla")
-        cd.set(("core2", ), "foo", "bloe")
+        cd.set((b"core", ), b"foo", b"bla")
+        cd.set((b"core2", ), b"foo", b"bloe")
 
         self.assertEqual(
-            [('foo', 'bla')],
-            list(cd.iteritems(("core", ))))
+            [(b'foo', b'bla')],
+            list(cd.iteritems((b"core", ))))
 
     def test_iteritems_nonexistant(self):
         cd = ConfigDict()
-        cd.set(("core2", ), "foo", "bloe")
+        cd.set((b"core2", ), b"foo", b"bloe")
 
         self.assertEqual([],
-            list(cd.iteritems(("core", ))))
+            list(cd.iteritems((b"core", ))))
 
     def test_itersections(self):
         cd = ConfigDict()
-        cd.set(("core2", ), "foo", "bloe")
+        cd.set((b"core2", ), b"foo", b"bloe")
 
-        self.assertEqual([("core2", )],
+        self.assertEqual([(b"core2", )],
             list(cd.itersections()))
 
 
 
-@skipIfPY3
 class StackedConfigTests(TestCase):
 
     def test_default_backends(self):
         StackedConfig.default_backends()
 
 
-@skipIfPY3
 class UnescapeTests(TestCase):
 
     def test_nothing(self):
-        self.assertEqual("", _unescape_value(""))
+        self.assertEqual(b"", bytes(_unescape_value(bytearray())))
 
     def test_tab(self):
-        self.assertEqual("\tbar\t", _unescape_value("\\tbar\\t"))
+        self.assertEqual(b"\tbar\t", bytes(_unescape_value(bytearray(b"\\tbar\\t"))))
 
     def test_newline(self):
-        self.assertEqual("\nbar\t", _unescape_value("\\nbar\\t"))
+        self.assertEqual(b"\nbar\t", bytes(_unescape_value(bytearray(b"\\nbar\\t"))))
 
     def test_quote(self):
-        self.assertEqual("\"foo\"", _unescape_value("\\\"foo\\\""))
+        self.assertEqual(b"\"foo\"", bytes(_unescape_value(bytearray(b"\\\"foo\\\""))))
 
 
-@skipIfPY3
 class EscapeValueTests(TestCase):
 
     def test_nothing(self):
-        self.assertEqual("foo", _escape_value("foo"))
+        self.assertEqual(b"foo", _escape_value(b"foo"))
 
     def test_backslash(self):
-        self.assertEqual("foo\\\\", _escape_value("foo\\"))
+        self.assertEqual(b"foo\\\\", _escape_value(b"foo\\"))
 
     def test_newline(self):
-        self.assertEqual("foo\\n", _escape_value("foo\n"))
+        self.assertEqual(b"foo\\n", _escape_value(b"foo\n"))
 
 
-@skipIfPY3
 class FormatStringTests(TestCase):
 
     def test_quoted(self):
-        self.assertEqual('" foo"', _format_string(" foo"))
-        self.assertEqual('"\\tfoo"', _format_string("\tfoo"))
+        self.assertEqual(b'" foo"', _format_string(b" foo"))
+        self.assertEqual(b'"\\tfoo"', _format_string(b"\tfoo"))
 
     def test_not_quoted(self):
-        self.assertEqual('foo', _format_string("foo"))
-        self.assertEqual('foo bar', _format_string("foo bar"))
+        self.assertEqual(b'foo', _format_string(b"foo"))
+        self.assertEqual(b'foo bar', _format_string(b"foo bar"))
 
 
-@skipIfPY3
 class ParseStringTests(TestCase):
 
     def test_quoted(self):
-        self.assertEqual(' foo', _parse_string('" foo"'))
-        self.assertEqual('\tfoo', _parse_string('"\\tfoo"'))
+        self.assertEqual(b' foo', _parse_string(b'" foo"'))
+        self.assertEqual(b'\tfoo', _parse_string(b'"\\tfoo"'))
 
     def test_not_quoted(self):
-        self.assertEqual('foo', _parse_string("foo"))
-        self.assertEqual('foo bar', _parse_string("foo bar"))
+        self.assertEqual(b'foo', _parse_string(b"foo"))
+        self.assertEqual(b'foo bar', _parse_string(b"foo bar"))
 
 
-@skipIfPY3
 class CheckVariableNameTests(TestCase):
 
     def test_invalid(self):
-        self.assertFalse(_check_variable_name("foo "))
-        self.assertFalse(_check_variable_name("bar,bar"))
-        self.assertFalse(_check_variable_name("bar.bar"))
+        self.assertFalse(_check_variable_name(b"foo "))
+        self.assertFalse(_check_variable_name(b"bar,bar"))
+        self.assertFalse(_check_variable_name(b"bar.bar"))
 
     def test_valid(self):
-        self.assertTrue(_check_variable_name("FOO"))
-        self.assertTrue(_check_variable_name("foo"))
-        self.assertTrue(_check_variable_name("foo-bar"))
+        self.assertTrue(_check_variable_name(b"FOO"))
+        self.assertTrue(_check_variable_name(b"foo"))
+        self.assertTrue(_check_variable_name(b"foo-bar"))
 
 
-@skipIfPY3
 class CheckSectionNameTests(TestCase):
 
     def test_invalid(self):
-        self.assertFalse(_check_section_name("foo "))
-        self.assertFalse(_check_section_name("bar,bar"))
+        self.assertFalse(_check_section_name(b"foo "))
+        self.assertFalse(_check_section_name(b"bar,bar"))
 
     def test_valid(self):
-        self.assertTrue(_check_section_name("FOO"))
-        self.assertTrue(_check_section_name("foo"))
-        self.assertTrue(_check_section_name("foo-bar"))
-        self.assertTrue(_check_section_name("bar.bar"))
+        self.assertTrue(_check_section_name(b"FOO"))
+        self.assertTrue(_check_section_name(b"foo"))
+        self.assertTrue(_check_section_name(b"foo-bar"))
+        self.assertTrue(_check_section_name(b"bar.bar"))