Update aliases and theme patches after ignored_packages change

Help prevent confusion with alias syntaxes overriding real syntaxes,
directly after installation of new packages.

Author: deathaxe

core/aliases.py

@@ -61,9 +61,9 @@
     ).lstrip()
 
 
-def check(desired_state):
+def check(desired_state, on_demand=False):
     if desired_state:
-        enable()
+        enable(on_demand)
     else:
         disable()
 
@@ -87,12 +87,22 @@ def delete_alias_files(syntaxes):
         delete_alias_files(file_type.get("aliases", []))
         delete_alias_files(file_type.get("syntaxes", []))
 
-    shutil.rmtree(path.overlay_aliases_path(), ignore_errors=True)
-    shutil.rmtree(path.overlay_cache_path(), ignore_errors=True)
+    def remove():
+        shutil.rmtree(path.overlay_aliases_path(), ignore_errors=True)
+        shutil.rmtree(path.overlay_cache_path(), ignore_errors=True)
 
+    sublime.set_timeout_async(remove)
 
-def enable():
+
+def enable(on_demand=False):
     real_syntaxes = get_real_syntaxes()
+    syntax_names = real_syntaxes.keys()
+    try:
+        if on_demand and enable.syntax_names == syntax_names:
+            return
+    except Exception:
+        pass
+    enable.syntax_names = syntax_names
 
     def real_syntax_for(selector):
         for scope in selector.split(","):
@@ -158,13 +168,16 @@ def delete_alias_file(alias, real_syntax):
             if syntax and syntax == alias_resource:
                 view.assign_syntax(real_syntax)
 
-    # actually delete the alias syntax
-    try:
-        os.remove(alias_path)
-    except Exception as error:
-        dump("- {} | {}".format(alias_name, error))
-    else:
-        dump("- {}".format(alias_name))
+    # delete the alias syntax asynchronously, after ST applied real syntax
+    def remove():
+        try:
+            os.remove(alias_path)
+        except Exception as error:
+            dump("- {} | {}".format(alias_name, error))
+        else:
+            dump("- {}".format(alias_name))
+
+    sublime.set_timeout_async(remove)
 
 
 def get_real_syntaxes():

core/settings.py

@@ -5,34 +5,43 @@
 from . import themes
 
 from .overlay import with_ignored_overlay
+from .utils.decorators import debounce
 from .utils.logging import log
 from .utils.path import PACKAGE_NAME
 
 PACKAGE_SETTINGS = "A File Icon.sublime-settings"
+USER_SETTINGS = "Preferences.sublime-settings"
 
+_cached_packages = []
 _cached_settings = {}
 _uuid = "9ebcce78-4cac-4089-8bd7-d551c634b052"
 
 
 def add_listener():
     log("Initializing settings")
     path = "Packages/{0}/{1}".format(PACKAGE_NAME, PACKAGE_SETTINGS)
-    settings = sublime.load_settings(PACKAGE_SETTINGS)
+    package_settings = sublime.load_settings(PACKAGE_SETTINGS)
     for key in sublime.decode_value(sublime.load_resource(path)).keys():
         if key not in ("dev_mode", "dev_trace"):
-            _cached_settings[key] = settings.get(key)
+            _cached_settings[key] = package_settings.get(key)
+
+    user_settings = sublime.load_settings(USER_SETTINGS)
+    _cached_packages = user_settings.get("ignored_packages")
 
     icons.init()
     themes.patch(_cached_settings)
     aliases.check(_cached_settings["aliases"])
-    sublime.load_settings(PACKAGE_SETTINGS).add_on_change(_uuid, _on_change)
+
+    package_settings.add_on_change(_uuid, _on_change_package)
+    user_settings.add_on_change(_uuid, _on_change_user)
 
 
 def clear_listener():
     sublime.load_settings(PACKAGE_SETTINGS).clear_on_change(_uuid)
+    sublime.load_settings(USER_SETTINGS).clear_on_change(_uuid)
 
 
-def _on_change():
+def _on_change_package():
     is_aliases_changed = False
     is_icons_changed = False
     is_force_mode_changed = False
@@ -55,12 +64,18 @@ def _on_change():
         aliases.check(_cached_settings["aliases"])
     if is_icons_changed:
         log("Icons settings changed")
-        _patch_theme(True)
+        themes.patch(_cached_settings, overwrite=True)
     elif is_force_mode_changed:
         log("Force mode settings changed")
-        _patch_theme(False)
-
-
-@with_ignored_overlay
-def _patch_theme(overwrite):
-    themes.patch(_cached_settings, overwrite)
+        themes.patch(_cached_settings)
+
+
+@debounce(2000)
+def _on_change_user():
+    global _cached_packages
+    settings = sublime.load_settings(USER_SETTINGS)
+    packages = settings.get("ignored_packages")
+    if packages != _cached_packages:
+        _cached_packages = packages
+        themes.patch(_cached_settings, on_demand=True)
+        aliases.check(_cached_settings["aliases"], on_demand=True)

core/themes.py

@@ -4,15 +4,25 @@
 
 import sublime
 
+from itertools import chain
+
 from .utils import path
 from .utils.colors import convert_color_value
 from .utils.logging import log, dump
 
 from . import icons
 
 
-def patch(settings, overwrite=False):
+def patch(settings, overwrite=False, on_demand=False):
     theme_packages = _installed_themes()
+    themes = set((theme for theme in chain(*theme_packages.values())))
+    try:
+        if on_demand and patch.themes == themes:
+            return
+    except Exception:
+        pass
+    patch.themes = themes
+
     supported = [] if settings.get("force_mode") else _customizable_themes()
 
     general_patch = _create_general_patch(settings)

core/utils/decorators.py

@@ -0,0 +1,38 @@
+from functools import partial, wraps
+from timeit import default_timer
+
+import sublime
+
+
+def debounce(delay_in_ms, sync=False):
+    """Delay calls to functions until they weren't triggered for n ms."""
+
+    # We assume that locking is not necessary because each function will be called
+    # from either the ui or the async thread only.
+    set_timeout = sublime.set_timeout if sync else sublime.set_timeout_async
+
+    def decorator(func):
+        call_at = 0
+
+        def _debounced_callback(callback):
+            nonlocal call_at
+            diff = call_at - int(default_timer() * 1000)
+            if diff > 0:
+                set_timeout(partial(_debounced_callback, callback), diff)
+            else:
+                call_at = 0
+                callback()
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            nonlocal call_at
+            pending = call_at > 0
+            call_at = int(default_timer() * 1000) + delay_in_ms
+            if pending:
+                return
+            callback = partial(func, *args, **kwargs)
+            set_timeout(partial(_debounced_callback, callback), delay_in_ms)
+
+        return wrapper
+
+    return decorator