Use ChainMap for ValueList config section.

This also fixes the problem where no keybindings are loaded on the first
start.

qutebrowser/commands/keys.py

@@ -237,6 +237,8 @@ class KeyParser(QObject):
         Args:
             sect: The section to get the keybindings from.
         """
+        if not sect.items():
+            from qutebrowser.utils.debug import set_trace; set_trace()
         for (key, cmd) in sect.items():
             if key.startswith('@') and key.endswith('@'):
                 # normalize keystring

qutebrowser/config/config.py

@@ -413,7 +413,7 @@ class SectionProxy(MutableMapping):
 
     def _options(self):
         """Get the option keys from this section."""
-        return self._conf.config[self._name].values.keys()
+        return self._conf.config[self._name].keys()
 
     def get(self, option, *, raw=False):
         """Get a value from this section.

qutebrowser/config/sections.py

@@ -18,7 +18,7 @@
 """Setting sections used for qutebrowser."""
 
 import logging
-from collections import OrderedDict
+from collections import OrderedDict, ChainMap
 
 from qutebrowser.config.value import SettingValue
 
@@ -135,25 +135,20 @@ class ValueList:
         #              KeyValue section.
     """
 
-    # FIXME use a ChainMap for this
     # FIXME how to handle value layers here?
 
     def __init__(self, keytype, valtype, *defaults):
         """Wrap types over default values. Take care when overriding this."""
         self.keytype = keytype
         self.valtype = valtype
-        self.values = OrderedDict()
+        self.layers = OrderedDict([
-        self.default = OrderedDict(
+            ('default', OrderedDict([(key, SettingValue(valtype, value))
-            [(key, SettingValue(valtype, value))
+                                     for key, value in defaults])),
-             for key, value in defaults])
+            ('conf', OrderedDict()),
-        self.valdict = OrderedDict()
+            ('temp', OrderedDict()),
-
+        ])
-    def update_valdict(self):
+        self.values = ChainMap(self.layers['temp'], self.layers['conf'],
-        """Update the global "true" value dict."""
+                               self.layers['default'])
-        self.valdict.clear()
-        self.valdict.update(self.default)
-        if self.values is not None:
-            self.valdict.update(self.values)
 
     def __getitem__(self, key):
         """Get the value for key.
@@ -164,10 +159,7 @@ class ValueList:
         Return:
             The value, as value class.
         """
-        try:
         return self.values[key]
-        except KeyError:
-            return self.default[key]
 
     def __setitem__(self, key, value):
         """Set the config value for key.
@@ -181,18 +173,15 @@ class ValueList:
     def __iter__(self):
         """Iterate over all set values."""
         # FIXME using a custon iterator this could be done more efficiently
-        self.update_valdict()
+        return self.values.__iter__()
-        return self.valdict.__iter__()
 
     def __bool__(self):
         """Get boolean state of section."""
-        self.update_valdict()
+        return bool(self.values)
-        return bool(self.valdict)
 
     def __contains__(self, key):
         """Return whether the section contains a given key."""
-        self.update_valdict()
+        return key in self.values
-        return key in self.valdict
 
     def setv(self, layer, key, value):
         """Set the value on a layer.
@@ -203,17 +192,16 @@ class ValueList:
             key: The key of the element to set.
             value: The value to set.
         """
-        if key in self.values:
+        if key in self.layers[layer]:
-            self.values[key].setv(layer, value)
+            self.layers[layer][key].setv(layer, value)
         else:
             val = SettingValue(self.valtype)
             val.setv(layer, value)
-            self.values[key] = val
+            self.layers[layer][key] = val
 
     def items(self):
         """Get dict items."""
-        self.update_valdict()
+        return self.values.items()
-        return self.valdict.items()
 
     def keys(self):
         """Get value keys."""