config: Create config.format and switch to just serialize on schemas

mopidy/__main__.py

@@ -177,33 +177,18 @@ def show_config_callback(option, opt, value, parser):
 
     config, errors = config_lib.load(files, extensions, overrides)
 
+    # Clear out any config for disabled extensions.
     for extension in extensions:
-        enabled = config[extension.ext_name]['enabled']
+        if not ext.validate_extension(extension):
-        if ext.validate_extension(extension) and enabled:
+            config[extension.ext_name] = {b'enabled': False}
-            enabled_extensions.append(extension)
+            errors[extension.ext_name] = {
-        elif extension.ext_name in errors:
+                b'enabled': b'extension disabled its self.'}
-            del errors[extension.ext_name]
+        elif not config[extension.ext_name]['enabled']:
+            config[extension.ext_name] = {b'enabled': False}
+            errors[extension.ext_name] = {
+                b'enabled': b'extension disabled by config.'}
 
-    # TODO: create mopidy.config.format?
+    print config_lib.format(config, extensions, errors)
-    output = []
-    for schema in config_lib._schemas:
-        options = config.get(schema.name, {})
-        if not options:
-            continue
-        output.append(schema.format(options))
-
-    for extension in extensions:
-        schema = extension.get_config_schema()
-
-        if extension in enabled_extensions:
-            options = config.get(schema.name, {})
-            output.append(schema.format(options))
-        else:
-            lines = ['[%s]' % schema.name,
-                     '# Config hidden as extension is disabled']
-            output.append('\n'.join(lines))
-
-    print '\n\n'.join(output)
     sys.exit(0)
 
 

mopidy/config/__init__.py

@@ -54,6 +54,14 @@ def load(files, extensions, overrides):
     return _validate(raw_config, schemas)
 
 
+def format(config, extensions, comments=None, display=True):
+    # Helper to format configs, as the rest of our config system should not
+    # need to know about extensions.
+    schemas = _schemas[:]
+    schemas.extend(e.get_config_schema() for e in extensions)
+    return _format(config, comments or {}, schemas, display)
+
+
 def _load(files, defaults, overrides):
     parser = configparser.RawConfigParser()
 
@@ -100,6 +108,22 @@ def _validate(raw_config, schemas):
     return config, errors
 
 
+def _format(config, comments, schemas, display):
+    output = []
+    for schema in schemas:
+        serialized = schema.serialize(config.get(schema.name, {}), display=display)
+        output.append(b'[%s]' % schema.name)
+        for key, value in serialized.items():
+            comment = comments.get(schema.name, {}).get(key, b'')
+            output.append(b'%s =' % key)
+            if value is not None:
+                output[-1] += b' ' + value
+            if comment:
+                output[-1] += b'  # ' + comment.capitalize()
+        output.append(b'')
+    return b'\n'.join(output)
+
+
 def parse_override(override):
     """Parse ``section/key=value`` command line overrides"""
     section, remainder = override.split('/', 1)

mopidy/config/schemas.py

@@ -1,5 +1,7 @@
 from __future__ import unicode_literals
 
+import collections
+
 from mopidy.config import types
 
 
@@ -85,21 +87,12 @@ class ConfigSchema(object):
 
         return result, errors
 
-    def serialize(self, values):
+    def serialize(self, values, display=False):
-        pass
+        result = getattr(collections, 'OrderedDict', dict)() # TODO: 2.6 cleanup
-
-    def format(self, values):
-        """Returns the schema as a config section with the given ``values``
-        filled in"""
-        # TODO: should the output be encoded utf-8 since we use that in
-        # serialize for strings?
-        lines = ['[%s]' % self.name]
         for key in self._order:
-            value = values.get(key)
+            if key in values:
-            if value is not None:
+                result[key] = self._schema[key].serialize(values[key], display)
-                lines.append('%s = %s' % (
+        return result
-                    key, self._schema[key].serialize(value, display=True)))
-        return '\n'.join(lines)
 
 
 class ExtensionConfigSchema(ConfigSchema):
@@ -137,13 +130,8 @@ class LogLevelConfigSchema(object):
                 errors[key] = str(e)
         return result, errors
 
-    def serialize(self, values):
+    def serialize(self, values, display=False):
-        pass
+        result = getattr(collections, 'OrderedDict', dict)() # TODO: 2.6 cleanup
-
+        for key in sorted(values.keys()):
-    def format(self, values):
+            result[key] = self._config_value.serialize(values[key], display)
-        lines = ['[%s]' % self.name]
+        return result
-        for key, value in sorted(values.items()):
-            if value is not None:
-                lines.append('%s = %s' % (
-                    key, self._config_value.serialize(value, display=True)))
-        return '\n'.join(lines)

tests/config/schemas_test.py

@@ -16,24 +16,6 @@ class ConfigSchemaTest(unittest.TestCase):
         self.schema['baz'] = mock.Mock()
         self.values = {'bar': '123', 'foo': '456', 'baz': '678'}
 
-    def test_format(self):
-        self.schema['foo'].serialize.return_value = 'qwe'
-        self.schema['bar'].serialize.return_value = 'asd'
-        self.schema['baz'].serialize.return_value = 'zxc'
-
-        expected = ['[test]', 'foo = qwe', 'bar = asd', 'baz = zxc']
-        result = self.schema.format(self.values)
-        self.assertEqual('\n'.join(expected), result)
-
-    def test_format_unkwown_value(self):
-        self.schema['foo'].serialize.return_value = 'qwe'
-        self.schema['bar'].serialize.return_value = 'asd'
-        self.schema['baz'].serialize.return_value = 'zxc'
-        self.values['unknown'] = 'rty'
-
-        result = self.schema.format(self.values)
-        self.assertNotIn('unknown = rty', result)
-
     def test_deserialize(self):
         self.schema.deserialize(self.values)
 
@@ -109,13 +91,6 @@ class LogLevelConfigSchemaTest(unittest.TestCase):
         self.assertEqual(logging.DEBUG, result['foo.bar'])
         self.assertEqual(logging.INFO, result['baz'])
 
-    def test_format(self):
-        schema = schemas.LogLevelConfigSchema('test')
-        values = {'foo.bar': logging.DEBUG, 'baz': logging.INFO}
-        expected = ['[test]', 'baz = info', 'foo.bar = debug']
-        result = schema.format(values)
-        self.assertEqual('\n'.join(expected), result)
-
 
 class DidYouMeanTest(unittest.TestCase):
     def testSuggestoins(self):