From cde84748f70c5d581a2b2ac3de80197f7bc50871 Mon Sep 17 00:00:00 2001 From: Thomas Adamcik Date: Tue, 16 Apr 2013 22:36:58 +0200 Subject: [PATCH] config: Create config.format and switch to just serialize on schemas --- mopidy/__main__.py | 35 ++++++++++------------------------- mopidy/config/__init__.py | 24 ++++++++++++++++++++++++ mopidy/config/schemas.py | 36 ++++++++++++------------------------ tests/config/schemas_test.py | 25 ------------------------- 4 files changed, 46 insertions(+), 74 deletions(-) diff --git a/mopidy/__main__.py b/mopidy/__main__.py index 71e7fb8a..15596c3e 100644 --- a/mopidy/__main__.py +++ b/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 ext.validate_extension(extension) and enabled: - enabled_extensions.append(extension) - elif extension.ext_name in errors: - del errors[extension.ext_name] + if not ext.validate_extension(extension): + config[extension.ext_name] = {b'enabled': False} + errors[extension.ext_name] = { + b'enabled': b'extension disabled its self.'} + 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? - 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) + print config_lib.format(config, extensions, errors) sys.exit(0) diff --git a/mopidy/config/__init__.py b/mopidy/config/__init__.py index 823323f3..1cdcfa9b 100644 --- a/mopidy/config/__init__.py +++ b/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) diff --git a/mopidy/config/schemas.py b/mopidy/config/schemas.py index 66da481b..9f10c41f 100644 --- a/mopidy/config/schemas.py +++ b/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): - pass - - 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] + def serialize(self, values, display=False): + result = getattr(collections, 'OrderedDict', dict)() # TODO: 2.6 cleanup for key in self._order: - value = values.get(key) - if value is not None: - lines.append('%s = %s' % ( - key, self._schema[key].serialize(value, display=True))) - return '\n'.join(lines) + if key in values: + result[key] = self._schema[key].serialize(values[key], display) + return result class ExtensionConfigSchema(ConfigSchema): @@ -137,13 +130,8 @@ class LogLevelConfigSchema(object): errors[key] = str(e) return result, errors - def serialize(self, values): - pass - - def format(self, values): - lines = ['[%s]' % self.name] - 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) + def serialize(self, values, display=False): + result = getattr(collections, 'OrderedDict', dict)() # TODO: 2.6 cleanup + for key in sorted(values.keys()): + result[key] = self._config_value.serialize(values[key], display) + return result diff --git a/tests/config/schemas_test.py b/tests/config/schemas_test.py index c3ce2f4d..a0c519f4 100644 --- a/tests/config/schemas_test.py +++ b/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):