Issue 6552 - Support arbitrary manifest values

chainedconfigparser.py

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import os
 import io
 import ConfigParser
 from StringIO import StringIO
-from collections import OrderedDict
 
 
 class Item(tuple):
     def __new__(cls, name, value, source):
         result = super(Item, cls).__new__(cls, (name, value))
         result.source = source
         return result
 
 
 class DiffForUnknownOptionError(ConfigParser.Error):
@@ skipping 67 matching lines @@
         is_addition = option.endswith('+')
         is_diff = is_addition or option.endswith('-')
 
         if is_diff:
             option = option[:-1].rstrip()
             try:
                 orig_value = self.get(section, option)
             except ConfigParser.NoOptionError:
                 raise DiffForUnknownOptionError(option, section)
 
-            orig_values = orig_value.split()
-            diff_values = value.split()
+            orig_values = orig_value.splitlines()
+            diff_values = value.splitlines()
 
             if is_addition:
                 new_values = orig_values + [v for v in diff_values if v not in orig_values]
             else:
                 new_values = [v for v in orig_values if v not in diff_values]
 
-            value = ' '.join(new_values)
+            value = '\n'.join(new_values)
 
         return is_diff, option, value
 
     def _process_parsers(self, parsers):
         for parser, filename in parsers:
             for section in parser.sections():
                 if not self.has_section(section):
                     try:
                         ConfigParser.SafeConfigParser.add_section(self, section)
                     except ValueError:
@@ skipping 35 matching lines @@
 
     def option_source(self, section, option):
         option = self.optionxform(option)
         try:
             return self._origin[(section, option)]
         except KeyError:
             if not self.has_section(section):
                 raise ConfigParser.NoSectionError(section)
             raise ConfigParser.NoOptionError(option, section)
 
-    def as_json_object(self, section):
-        r"""Parse a given section into a JSON object.
+    def serialize_section_if_present(self, section, base):

[Vasily Kuznetsov, 2018/04/19 14:40:10]

What this method does seems more like parsing than serialization. Perhaps it
should be called "parse_section_if_present".

[Sebastian Noack, 2018/04/19 15:02:59]

In the end it gets serialized (as JSON). But you might be right that what we do
here is parsing it from the config. I guess, its too late now. Though, if
anybody feeling strong about this and submits a Noissue patch, I would take it.

+        """Serialize a given section as a dictionary into `base`.
 
         Parse arbitrary key/value pairs from 'section' of the current
-        configuration into a nested JSON object.
+        configuration into a dictionary and deep merge it into `base`.
 
         The following rules need to be considered:
 
         * An option's key may be declared as a series of nested dictionary keys,
           seperated by '.'.
-        * An option's key must end with '[]', to mark this option as an array
-        * When an option is marked as an array, no other nested objects may
-          follow
-        * An array is expandable by the ConfigParser's '+=' token.
-        * Values may be marked as special types by appending '\{code}':
-          * \b - boolean
-          * \i - integer
-          * \f - float
+        * Declaring an option's value in a new line (even if only one is given)
+          will define the option's value as a list.
+        * When an option's value is defined as a list, no other nested
+          objects may follow.
+        * A list is expandable by the ConfigParser's '+=' token (Note: A
+          previously declared string will be converted into a list).
+        * Values may be marked as `number` or `bool` by prefixing them
+          accordingly (this also applies to values in a list):
+          * bool:<value>
+          * number:<value>
 
         Example:
-
-                                        {
-                                          "good": false,
-                                          "bar": {
-                                            "baz": ["bar", "bazinga"]
-        foo = foo                         },
-        bar.baz[] = bar                   "is": {
-        baz.foo = a                         "integer": 1,
-        baz.z[] = b                         "float": 1.4
-        bar.baz[] += bazinga    ==>       },
-        bad = true\b                      "baz": {
-        good = f\b                          "foo": "a",
-        is.integer = 1\i                    "z": ["b"]
-        is.float = 1.4\f                  },
-                                          "bad": true
-                                          "foo": "foo"
-                                        }
+                                    {
+        foo = foo                     "foo": "foo",
+        asd =                         "asd": ["asd"],
+          asd                         "bar": {
+        bar.baz = a                     "baz": ["a", "c", "d"]
+        baz.foo = a                   },
+        baz.z =                       "baz": {
+          bar                           "foo": "a",
+          bool:true             ===>    "z": ["bar", true]
+        bar.baz +=                    },
+          c                           "bad": true,
+          d                           "good": false,
+        bad = bool:true               "is": {
+        good = bool:false               "integer": 1,
+        is.integer = number:1           "float": 1.4
+        is.float = number:1.4         }
+                                    }
         """
-        def parse_values(v):
-            import distutils
-            if isinstance(v, list):
-                return [parse_values(x) for x in v]
-
-            mapping = {
-                '\\b': lambda x: bool(distutils.util.strtobool(x)),
-                '\\i': int,
-                '\\f': float,
-            }
-            if '\\' in v:
-                return mapping[v[-2:]](v[:-2])
+        def parse_value(v):
+            if v.startswith('number:'):
+                v = v.split(':', 1)[1]
+                try:
+                    return int(v)
+                except ValueError:
+                    return float(v)
+            if v == 'bool:true':
+                return True
+            if v == 'bool:false':
+                return False
             return v
 
-        def setdefault_recursive(target, arr):
-            if len(arr) == 2:
-                target.setdefault(arr[0], parse_values(arr[1]))
-            else:
-                current = target.setdefault(arr[0], OrderedDict())
-                setdefault_recursive(current, arr[1:])
-
-        data = self.items(section)
-        result = OrderedDict()
-
-        for k, v in data:
-            if k.endswith('[]'):
-                k = k[:-2]
-                v = v.split()
-
-            setdefault_recursive(result, k.split('.') + [v])
-
-        return result
+        if self.has_section(section):
+            for k, v in self.items(section):
+                parents = k.split('.')
+                tail = parents.pop()
+                current = base
+                for name in parents:
+                    current = base.setdefault(name, {})
+
+                if '\n' in v:
+                    current[tail] = [parse_value(x) for x in v.splitlines() if x]
+                else:
+                    current[tail] = parse_value(v)
 
     def readfp(self, fp, filename=None):
         raise NotImplementedError
 
     def set(self, section, option, value=None):
         raise NotImplementedError
 
     def add_section(self, section):
         raise NotImplementedError
 
     def remove_option(self, section, option):
         raise NotImplementedError
 
     def remove_section(self, section):
         raise NotImplementedError