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 131 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.
+
+        Parse arbitrary key/value pairs from 'section' of the current
+        configuration into a nested JSON object.
+
+        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
+
+        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"
+                                        }
+        """
+        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])
+            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
+
     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