Merge branch 'develop'

Author: deathaxe

core/aliases.py

@@ -61,47 +61,48 @@
     ).lstrip()
 
 
-def check(desired_state):
+def check(desired_state, on_demand=False):
     if desired_state:
-        enable()
+        enable(on_demand)
     else:
         disable()
 
 
 def disable():
     log("Disabling aliases")
 
+    real_syntaxes = get_real_syntaxes()
+
     def delete_alias_files(syntaxes):
-        base_syntaxes = None
         for syntax in syntaxes:
-            if HAS_FIND_SYNTAX:
-                base_syntaxes = sublime.find_syntax_by_scope(
-                    syntax.get("base", "text.plain")
-                )
-            if base_syntaxes:
-                delete_alias_file(syntax, base_syntaxes[0].path)
-            else:
-                delete_alias_file(syntax, "Plain text.tmLanguage")
+            delete_alias_file(
+                syntax,
+                real_syntaxes.get(
+                    syntax.get("base", "text.plain"),
+                    "Packages/Text/Plain text.tmLanguage",
+                ),
+            )
 
     for file_type in icons_json_content().values():
         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():
-    if HAS_FIND_SYNTAX:
-        # Built a dict of { scope: syntax } from visible/real syntaxes.
-        # Note: Existing aliases in the overlay are hidden and thus excluded
-        #       by default. Also ignore possible aliases or special purpose
-        #       syntaxes from 3rd-party packages.
-        real_syntaxes = {
-            s.scope: s.path for s in sublime.list_syntaxes() if not s.hidden
-        }
-    else:
-        real_syntaxes = {}
+
+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(","):
@@ -145,7 +146,7 @@ def create_alias_file(alias):
             else:
                 out.write(EMPTY_TEMPLATE.format(name, scope, exts, base))
     except FileExistsError:
-        pass
+        dump("■ {}.sublime-syntax".format(name))
     except Exception as error:
         dump("+ {}.sublime-syntax | {}".format(name, error))
     else:
@@ -156,6 +157,7 @@ def delete_alias_file(alias, real_syntax):
     alias_name = alias["name"] + ".sublime-syntax"
     alias_path = path.overlay_aliases_path(alias_name)
     if not os.path.exists(alias_path):
+        dump("□ " + alias_name)
         return
 
     # reassign real syntax to any open view, which uses the alias
@@ -166,10 +168,25 @@ 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():
+    # Built a dict of { scope: syntax } from visible/real syntaxes.
+    # Note: Existing aliases in the overlay are hidden and thus excluded
+    #       by default. Also ignore possible aliases or special purpose
+    #       syntaxes from 3rd-party packages.
+    return (
+        {s.scope: s.path for s in sublime.list_syntaxes() if not s.hidden}
+        if HAS_FIND_SYNTAX
+        else {}
+    )

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

icons/icons.json

@@ -850,7 +850,7 @@
 					".Dockerfile"
 				],
 				"name": "Plain Text (Dockerfile)",
-				"scope": "source.dockerfile"
+				"scope": "source.containerfile, source.dockerfile"
 			}
 		]
 	},