python · CoolCat467 · Oct 3, 2021 · Oct 3, 2021 · Oct 4, 2021 · Oct 4, 2021
@@ -28,6 +28,7 @@
 from configparser import ConfigParser
 import os
 import sys
+from collections import ChainMap
 
 from tkinter.font import Font
 import idlelib
@@ -469,61 +470,95 @@ def GetExtnNameForEvent(self, virtualEvent):
                     extName = extn  # TODO return here?
         return extName
 
-    def GetExtensionKeys(self, extensionName):
+    def GetExtensionKeys(self, extension_name):
         """Return dict: {configurable extensionName event : active keybinding}.
 
         Events come from default config extension_cfgBindings section.
         Keybindings come from GetCurrentKeySet() active key dict,
         where previously used bindings are disabled.
         """
-        keysName = extensionName + '_cfgBindings'
-        activeKeys = self.GetCurrentKeySet()
-        extKeys = {}
-        if self.defaultCfg['extensions'].has_section(keysName):
-            eventNames = self.defaultCfg['extensions'].GetOptionList(keysName)
-            for eventName in eventNames:
-                event = '<<' + eventName + '>>'
-                binding = activeKeys[event]
-                extKeys[event] = binding
-        return extKeys
-
-    def __GetRawExtensionKeys(self,extensionName):
+        bindings_section = f'{extension_name}_cfgBindings'
+        current_keyset = idleConf.GetCurrentKeySet()
+        extension_keys = {}
+
+        event_names = set()
+        if self.userCfg['extensions'].has_section(bindings_section):
+            event_names |= set(
+                self.userCfg['extensions'].GetOptionList(bindings_section)
+            )
+        if self.defaultCfg['extensions'].has_section(bindings_section):
+            event_names |= set(
+                self.defaultCfg['extensions'].GetOptionList(bindings_section)
+            )
+
+        for event_name in event_names:
+            event = f'<<{event_name}>>'
+            binding = current_keyset.get(event, None)
+            if binding is None:
+                continue
+            extension_keys[event] = binding
+        return extension_keys
+
+    def __GetRawExtensionKeys(self, extension_name):
         """Return dict {configurable extensionName event : keybinding list}.
 
         Events come from default config extension_cfgBindings section.
         Keybindings list come from the splitting of GetOption, which
         tries user config before default config.
         """
-        keysName = extensionName+'_cfgBindings'
-        extKeys = {}
-        if self.defaultCfg['extensions'].has_section(keysName):
-            eventNames = self.defaultCfg['extensions'].GetOptionList(keysName)
-            for eventName in eventNames:
-                binding = self.GetOption(
-                        'extensions', keysName, eventName, default='').split()
-                event = '<<' + eventName + '>>'
-                extKeys[event] = binding
-        return extKeys
-
-    def GetExtensionBindings(self, extensionName):
+        bindings_section = f'{extension_name}_cfgBindings'
+        extension_keys = {}
+
+        event_names = []
+        if self.userCfg['extensions'].has_section(bindings_section):
+            event_names.append(self.userCfg['extensions'].GetOptionList(bindings_section))
+        if self.defaultCfg['extensions'].has_section(bindings_section):
+            event_names.append(self.defaultCfg['extensions'].GetOptionList(bindings_section))
+
+        # Because chain map, favors user bindings over default bindings
+        for event_name in ChainMap(*event_names):
+            binding = self.GetOption(
+                'extensions',
+                bindings_section,
+                event_name,
+                default='',
+            ).split()
+            event = f'<<{event_name}>>'
+            extension_keys[event] = binding
+        return extension_keys
+
+    def GetExtensionBindings(self, extension_name):
         """Return dict {extensionName event : active or defined keybinding}.
 
         Augment self.GetExtensionKeys(extensionName) with mapping of non-
         configurable events (from default config) to GetOption splits,
         as in self.__GetRawExtensionKeys.
         """
-        bindsName = extensionName + '_bindings'
-        extBinds = self.GetExtensionKeys(extensionName)
-        #add the non-configurable bindings
-        if self.defaultCfg['extensions'].has_section(bindsName):
-            eventNames = self.defaultCfg['extensions'].GetOptionList(bindsName)
-            for eventName in eventNames:
-                binding = self.GetOption(
-                        'extensions', bindsName, eventName, default='').split()
-                event = '<<' + eventName + '>>'
-                extBinds[event] = binding
-
-        return extBinds
+        bindings_section = f'{extension_name}_bindings'
+        extension_keys = self.GetExtensionKeys(extension_name)
+
+        # add the non-configurable bindings
+        values = []
+        if self.userCfg['extensions'].has_section(bindings_section):
+            values.append(
+                self.userCfg['extensions'].GetOptionList(bindings_section)
+            )
+        if self.defaultCfg['extensions'].has_section(bindings_section):
+            values.append(
+                self.defaultCfg['extensions'].GetOptionList(bindings_section)
+            )
+
+        # Because chain map, favors user bindings over default bindings
+        for event_name in ChainMap(*values):
+            binding = self.GetOption(
+                'extensions',
+                bindings_section,
+                event_name,
+                default=''
+            ).split()
+            event = f'<<{event_name}>>'
+            extension_keys[event] = binding
+        return extension_keys
 
     def GetKeyBinding(self, keySetName, eventStr):
         """Return the keybinding list for keySetName eventStr.
@@ -758,7 +793,8 @@ def LoadCfgFiles(self):
         "Load all configuration files."
         for key in self.defaultCfg:
             self.defaultCfg[key].Load()
-            self.userCfg[key].Load() #same keys
+        for key in self.userCfg:
+            self.userCfg[key].Load()
 
     def SaveUserCfgFiles(self):
         "Write all loaded user configuration files to disk."

@@ -1960,12 +1960,15 @@ def create_page_extensions(self):
     def load_extensions(self):
         "Fill self.extensions with data from the default and user configs."
         self.extensions = {}
+
         for ext_name in idleConf.GetExtensions(active_only=False):
             # Former built-in extensions are already filtered out.
             self.extensions[ext_name] = []
 
         for ext_name in self.extensions:
-            opt_list = sorted(self.ext_defaultCfg.GetOptionList(ext_name))
+            default = set(self.ext_defaultCfg.GetOptionList(ext_name))
+            user = set(self.ext_userCfg.GetOptionList(ext_name))
+            opt_list = sorted(default | user)
 
             # Bring 'enable' options to the beginning of the list.
             enables = [opt_name for opt_name in opt_list
@@ -1975,8 +1978,12 @@ def load_extensions(self):
             opt_list = enables + opt_list
 
             for opt_name in opt_list:
-                def_str = self.ext_defaultCfg.Get(
-                        ext_name, opt_name, raw=True)
+                if opt_name in user:
+                    def_str = self.ext_userCfg.Get(
+                            ext_name, opt_name, raw=True)
+                else:
+                    def_str = self.ext_defaultCfg.Get(
+                            ext_name, opt_name, raw=True)
                 try:
                     def_obj = {'True':True, 'False':False}[def_str]
                     opt_type = 'bool'
@@ -1988,9 +1995,14 @@ def load_extensions(self):
                         def_obj = def_str
                         opt_type = None
                 try:
-                    value = self.ext_userCfg.Get(
-                            ext_name, opt_name, type=opt_type, raw=True,
-                            default=def_obj)
+                    if opt_name in user:
+                        value = self.ext_userCfg.Get(
+                                ext_name, opt_name, type=opt_type, raw=True,
+                                default=def_obj)
+                    else:
+                        value = self.ext_defaultCfg.Get(
+                                ext_name, opt_name, type=opt_type, raw=True,
+                                default=def_obj)
                 except ValueError:  # Need this until .Get fixed.
                     value = def_obj  # Bad values overwritten by entry.
                 var = StringVar(self)
@@ -2054,10 +2066,11 @@ def set_extension_value(self, section, opt):
         default = opt['default']
         value = opt['var'].get().strip() or default
         opt['var'].set(value)
-        # if self.defaultCfg.has_section(section):
-        # Currently, always true; if not, indent to return.
-        if (value == default):
+
+        # Only save option in user config if it differs from the default
+        if self.ext_defaultCfg.has_section(section) and value == default:
             return self.ext_userCfg.RemoveOption(section, name)
+
         # Set the option.
         return self.ext_userCfg.SetOption(section, name, value)
 

@@ -907,9 +907,8 @@ def RemoveKeybindings(self):
             self.text.event_delete(event, *keylist)
         for extensionName in self.get_standard_extension_names():
             xkeydefs = idleConf.GetExtensionBindings(extensionName)
-            if xkeydefs:
-                for event, keylist in xkeydefs.items():
-                    self.text.event_delete(event, *keylist)
+            for event, keylist in xkeydefs.items():
+                self.text.event_delete(event, *keylist)
 
     def ApplyKeybindings(self):
         """Apply the virtual, configurable keybindings.

@@ -82,6 +82,27 @@ def checklines(self, text, value):
             actual.append(txt.startswith(value))
         return actual
 
+    def test_exists(self):
+        self.assertEqual(zzdummy.idleConf.GetSectionList('user', 'extensions'), [])
+        self.assertEqual(zzdummy.idleConf.GetSectionList('default', 'extensions'), ['AutoComplete', 'CodeContext', 'FormatParagraph', 'ParenMatch', 'ZzDummy', 'ZzDummy_cfgBindings', 'ZzDummy_bindings'])
+        self.assertIn("ZzDummy", zzdummy.idleConf.GetExtensions(False))
+        self.assertNotIn("ZzDummy", zzdummy.idleConf.GetExtensions())
+        self.assertEqual(zzdummy.idleConf.GetExtensionKeys("ZzDummy"), {})
+        self.assertEqual(zzdummy.idleConf.GetExtensionBindings("ZzDummy"), {'<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']})
+
+    def test_exists_user(self):
+        zzdummy.idleConf.userCfg["extensions"].read_dict({
+            "ZzDummy": {'enable': 'True'}
+        })
+        self.assertEqual(zzdummy.idleConf.GetSectionList('user', 'extensions'), ["ZzDummy"])
+        self.assertIn("ZzDummy", zzdummy.idleConf.GetExtensions())
+        self.assertEqual(zzdummy.idleConf.GetExtensionKeys("ZzDummy"), {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>']})
+        self.assertEqual(zzdummy.idleConf.GetExtensionBindings("ZzDummy"), {'<<z-in>>': ['<Control-Shift-KeyRelease-Insert>'], '<<z-out>>': ['<Control-Shift-KeyRelease-Delete>']})
+        # Restore
+        zzdummy.idleConf.userCfg["extensions"].read_dict({
+            "ZzDummy": {'enable': 'False'}
+        })
+
     def test_init(self):
         zz = self.zz
         self.assertEqual(zz.editwin, self.editor)