Simplify section handling.

dulwich/config.py

@@ -30,11 +30,11 @@ from dulwich.file import GitFile
 class Config(object):
     """A Git configuration."""
 
-    def get(self, name):
+    def get(self, section, name):
         """Retrieve the contents of a configuration setting.
         
-        :param name: Name of the setting, including section and 
-            possible subsection.
+        :param section: Tuple with section name and optional subsection namee
+        :param subsection: Subsection name
         :return: Contents of the setting
         :raise KeyError: if the value is not set
         """
@@ -50,7 +50,7 @@ class Config(object):
         """
         return bool(self.get(name))
 
-    def set(self, name, value):
+    def set(self, section, name, value):
         """Set a configuration value.
         
         :param name: Name of the configuration value, including section
@@ -85,19 +85,20 @@ class ConfigDict(Config):
         else:
             return (parts[0], None, parts[1])
 
-    def get(self, name):
-        (section, subsection, variable) = self._parse_setting(name)
-        if subsection is not None:
+    def get(self, section, name):
+        if isinstance(section, basestring):
+            section = (section, )
+        if len(section) > 1:
             try:
-                return self._values[section][subsection][variable]
+                return self._values[section][name]
             except KeyError:
                 pass
-        return self._values[section][None][variable]
+        return self._values[(section[0],)][name]
 
-    def set(self, name, value):
-        (section_name, subsection_name, variable) = self._parse_setting(name)
-        section = self._values.setdefault(section_name, {})
-        section.setdefault(subsection_name, {})[variable] = value
+    def set(self, section, name, value):
+        if isinstance(section, basestring):
+            section = (section, )
+        self._values.setdefault(section, {})[name] = value
 
 
 def _format_string(value):
@@ -155,16 +156,19 @@ class ConfigFile(ConfigDict):
                     key = line.strip()
                     pts = key[1:-1].split(" ", 1)
                     if len(pts) == 2:
-                        if pts[1][0] == "\"":
-                            if pts[1][-1] != "\"":
-                                raise ValueError(
-                                    "Invalid subsection " + pts[1])
-                            else:
-                                pts[1] = pts[1][1:-1]
+                        if pts[1][0] != "\"" or pts[1][-1] != "\"":
+                            raise ValueError(
+                                "Invalid subsection " + pts[1])
+                        else:
+                            pts[1] = pts[1][1:-1]
                         section = (pts[0], pts[1])
                     else:
-                        section = (pts[0], None)
-                    ret._values[section[0]] = {section[1]: {}}
+                        pts = pts[0].split(".", 1)
+                        if len(pts) == 2:
+                            section = (pts[0], pts[1])
+                        else:
+                            section = (pts[0], )
+                    ret._values[section] = {}
                 elif "=" in line:
                     setting, value = line.split("=", 1)
                     if section is None:
@@ -176,14 +180,14 @@ class ConfigFile(ConfigDict):
                     else:
                         continuation = True
                     value = _parse_string(value)
-                    ret._values[section[0]][section[1]][setting] = value
+                    ret._values[section][setting] = value
                     if not continuation:
                         setting = None
                 else:
                     setting = line.strip()
                     if section is None:
                         raise ValueError("setting %r without section" % line)
-                    ret._values[section[0]][section[1]][setting] = ""
+                    ret._values[section][setting] = ""
                     setting = None
             else:
                 if line.endswith("\\\n"):
@@ -192,7 +196,7 @@ class ConfigFile(ConfigDict):
                 else:
                     continuation = True
                 value = _parse_string(line)
-                ret._values[section[0]][section[1]][setting] += value
+                ret._values[section][setting] += value
                 if not continuation:
                     setting = None
         return ret
@@ -220,14 +224,18 @@ class ConfigFile(ConfigDict):
 
     def write_to_file(self, f):
         """Write configuration to a file-like object."""
-        for section_name, section in self._values.iteritems():
-            for subsection_name, subsection in section.iteritems():
-                if subsection_name is None:
-                    f.write("[%s]\n" % section_name)
-                else:
-                    f.write("[%s \"%s\"]\n" % (section_name, subsection_name))
-                for key, value in subsection.iteritems():
-                    f.write("%s = %s\n" % (key, _escape_value(value)))
+        for section, values in self._values.iteritems():
+            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)
+            else:
+                f.write("[%s \"%s\"]\n" % (section_name, subsection_name))
+            for key, value in values.iteritems():
+                f.write("%s = %s\n" % (key, _escape_value(value)))
 
 
 class StackedConfig(Config):
@@ -262,13 +270,13 @@ class StackedConfig(Config):
             backends.append(cf)
         return backends
 
-    def get(self, name):
+    def get(self, section, name):
         for backend in self._backends:
             try:
-                return backend.get(name)
+                return backend.get(section, name)
             except KeyError:
                 pass
         raise KeyError(name)
 
-    def set(self, name, value):
+    def set(self, section, name, value):
         raise NotImplementedError(self.set)

dulwich/repo.py

@@ -804,10 +804,10 @@ class BaseRepo(object):
         self._put_named_file('description', "Unnamed repository")
         f = StringIO()
         cf = ConfigFile()
-        cf.set("core.repositoryformatversion", "0")
-        cf.set("core.filemode", "true")
-        cf.set("core.bare", str(bare).lower())
-        cf.set("core.logallrefupdates", "true")
+        cf.set("core", "repositoryformatversion", "0")
+        cf.set("core", "filemode", "true")
+        cf.set("core", "bare", str(bare).lower())
+        cf.set("core", "logallrefupdates", "true")
         cf.write_to_file(f)
         self._put_named_file('config', f.getvalue())
         self._put_named_file(os.path.join('info', 'exclude'), '')

dulwich/tests/test_config.py

@@ -48,7 +48,7 @@ class ConfigFileTests(TestCase):
 
     def test_empty_line_before_section(self):
         cf = self.from_file("\n[section]\n")
-        self.assertEquals(ConfigFile({"section": {None: {}}}), cf)
+        self.assertEquals(ConfigFile({("section", ): {}}), cf)
 
     def test_comment_before_section(self):
         cf = self.from_file("# foo\n[section]\n")
@@ -60,33 +60,33 @@ class ConfigFileTests(TestCase):
 
     def test_from_file_section(self):
         cf = self.from_file("[core]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get("core.foo"))
-        self.assertEquals("bar", cf.get("core.foo.foo"))
+        self.assertEquals("bar", cf.get(("core", ), "foo"))
+        self.assertEquals("bar", cf.get(("core", "foo"), "foo"))
 
     def test_from_file_with_quotes(self):
         cf = self.from_file(
             "[core]\n"
             'foo = " bar"\n')
-        self.assertEquals(" bar", cf.get("core.foo"))
+        self.assertEquals(" bar", cf.get(("core", ), "foo"))
 
     def test_from_file_with_interrupted_line(self):
         cf = self.from_file(
             "[core]\n"
             'foo = bar\\\n'
             ' la\n')
-        self.assertEquals("barla", cf.get("core.foo"))
+        self.assertEquals("barla", cf.get(("core", ), "foo"))
 
     def test_from_file_subsection(self):
         cf = self.from_file("[branch \"foo\"]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get("branch.foo.foo"))
+        self.assertEquals("bar", cf.get(("branch", "foo"), "foo"))
 
     def test_from_file_subsection_invalid(self):
         self.assertRaises(ValueError,
             self.from_file, "[branch \"foo]\nfoo = bar\n")
 
     def test_from_file_subsection_not_quoted(self):
-        cf = self.from_file("[branch foo]\nfoo = bar\n")
-        self.assertEquals("bar", cf.get("branch.foo.foo"))
+        cf = self.from_file("[branch.foo]\nfoo = bar\n")
+        self.assertEquals("bar", cf.get(("branch", "foo"), "foo"))
 
     def test_write_to_file_empty(self):
         c = ConfigFile()
@@ -96,14 +96,14 @@ class ConfigFileTests(TestCase):
 
     def test_write_to_file_section(self):
         c = ConfigFile()
-        c.set("core.foo", "bar")
+        c.set(("core", ), "foo", "bar")
         f = StringIO()
         c.write_to_file(f)
         self.assertEquals("[core]\nfoo = bar\n", f.getvalue())
 
     def test_write_to_file_subsection(self):
         c = ConfigFile()
-        c.set("branch.blie.foo", "bar")
+        c.set(("branch", "blie"), "foo", "bar")
         f = StringIO()
         c.write_to_file(f)
         self.assertEquals("[branch \"blie\"]\nfoo = bar\n", f.getvalue())
@@ -113,11 +113,11 @@ class ConfigDictTests(TestCase):
 
     def test_get_set(self):
         cd = ConfigDict()
-        self.assertRaises(KeyError, cd.get, "core.foo")
-        cd.set("core.foo", "bla")
-        self.assertEquals("bla", cd.get("core.foo"))
-        cd.set("core.foo", "bloe")
-        self.assertEquals("bloe", cd.get("core.foo"))
+        self.assertRaises(KeyError, cd.get, "foo", "core")
+        cd.set(("core", ), "foo", "bla")
+        self.assertEquals("bla", cd.get(("core", ), "foo"))
+        cd.set(("core", ), "foo", "bloe")
+        self.assertEquals("bloe", cd.get(("core", ), "foo"))
 
 
 class StackedConfigTests(TestCase):