Merge branch 'master' into next

Author: kaste

.flake8

@@ -8,5 +8,6 @@ max-line-length = 120
 # D104  Missing docstring in public package
 # D107  Missing docstring in __init__
 # W503  line break before binary operator
+# W504  line break after binary operator
 # W606  'async' and 'await' are reserved keywords starting with Python 3.7
-ignore = D100, D101, D102, D103, D104, D107, W503, W606
+ignore = D100, D101, D102, D103, D104, D107, W503, W504, W606

unittesting/mixin.py

@@ -36,11 +36,11 @@ def casedpath(path):
 
 def relative_to_spp(path):
     spp = sublime.packages_path()
-    path = os.path.realpath(path)
-    for f in os.listdir(spp):
-        f2 = os.path.realpath(os.path.join(spp, f))
-        if path.startswith(f2 + os.sep):
-            return os.sep + os.path.join(f, os.path.relpath(path, f2))
+    spp_real = casedpath(os.path.realpath(spp))
+    for p in [path, casedpath(os.path.realpath(path))]:
+        for sp in [spp, spp_real]:
+            if p.startswith(sp + os.sep):
+                return p[len(sp):]
     return None
 
 

unittesting/utils/output_panel.py

@@ -1,5 +1,8 @@
-import sublime
+import collections
 import os
+import threading
+
+import sublime
 
 
 class OutputPanel:
@@ -30,21 +33,35 @@ def __init__(
         self.output_view.assign_syntax("Packages/UnitTesting/res/unit-testing-test-result.sublime-syntax")
         self.closed = False
 
+        self.text_queue_lock = threading.Lock()
+        self.text_queue = collections.deque()
+
     def write(self, s):
-        self.output_view.set_read_only(False)
-        self.output_view.run_command('append', {'characters': s}),
-        self.output_view.set_read_only(True)
-        self.output_view.show(self.output_view.size())
+        with self.text_queue_lock:
+            self.text_queue.append(s)
 
     def writeln(self, s):
         self.write(s + "\n")
 
+    def _write(self):
+        with self.text_queue_lock:
+            text = ''
+            while self.text_queue:
+                text += self.text_queue.popleft()
+
+        self.output_view.set_read_only(False)
+        self.output_view.run_command(
+            'append',
+            {'characters': text, 'force': True, 'scroll_to_end': True}
+        )
+        self.output_view.set_read_only(True)
+
     def flush(self):
-        pass
+        self._write()
 
     def show(self):
         self.window.run_command("show_panel", {"panel": "output." + self.name})
 
     def close(self):
+        self.flush()
         self.closed = True
-        pass

unittesting/utils/reloader.py

@@ -11,6 +11,17 @@
 from .stack_meter import StackMeter
 
 
+try:
+    from package_control.package_manager import PackageManager
+
+    def is_dependency(pkg_name):
+        return PackageManager()._is_dependency(pkg_name)
+
+except ImportError:
+    def is_dependency(pkg_name):
+        return False
+
+
 def dprint(*args, fill=None, fill_width=60, **kwargs):
     if fill is not None:
         sep = str(kwargs.get('sep', ' '))
@@ -20,21 +31,55 @@ def dprint(*args, fill=None, fill_width=60, **kwargs):
     print("[UnitTesting]", *args, **kwargs)
 
 
+def path_contains(a, b):
+    return a == b or b.startswith(a + os.sep)
+
+
+def get_package_modules(pkg_name):
+    in_installed_path = functools.partial(
+        path_contains,
+        os.path.join(
+            sublime.installed_packages_path(),
+            pkg_name + '.sublime-package'
+        )
+    )
+
+    in_package_path = functools.partial(
+        path_contains,
+        os.path.join(sublime.packages_path(), pkg_name)
+    )
+
+    def module_in_package(module):
+        file = getattr(module, '__file__', '')
+        paths = getattr(module, '__path__', ())
+        return (
+            in_installed_path(file) or any(map(in_installed_path, paths)) or
+            in_package_path(file) or any(map(in_package_path, paths))
+        )
+
+    return {
+        name: module
+        for name, module in sys.modules.items()
+        if module_in_package(module)
+    }
+
+
 # check the link for comments
 # https://github.com/divmain/GitSavvy/blob/599ba3cdb539875568a96a53fafb033b01708a67/common/util/reload.py
 def reload_package(pkg_name, dummy=True, verbose=True):
+    if is_dependency(pkg_name):
+        reload_dependency(pkg_name, dummy, verbose)
+        return
+
     if pkg_name not in sys.modules:
         dprint("error:", pkg_name, "is not loaded.")
         return
 
-    main = sys.modules[pkg_name]
-
     if verbose:
         dprint("begin", fill='=')
 
-    modules = {main.__name__: main}
-    modules.update({name: module for name, module in sys.modules.items()
-                    if name.startswith(pkg_name + ".")})
+    modules = get_package_modules(pkg_name)
+
     for m in modules:
         if m in sys.modules:
             sublime_plugin.unload_module(modules[m])
@@ -44,7 +89,7 @@ def reload_package(pkg_name, dummy=True, verbose=True):
         with intercepting_imports(modules, verbose), \
                 importing_fromlist_aggresively(modules):
 
-            reload_plugin(main.__name__)
+            reload_plugin(pkg_name)
     except Exception:
         dprint("reload failed.", fill='-')
         reload_missing(modules, verbose)
@@ -57,6 +102,29 @@ def reload_package(pkg_name, dummy=True, verbose=True):
         dprint("end", fill='-')
 
 
+def reload_dependency(dependency_name, dummy=True, verbose=True):
+    """
+    Reload a Package Control dependency.
+
+    Package Control dependencies aren't regular packages, so we don't want to
+    call `sublime_plugin.unload_module` or `sublime_plugin.reload_plugin`.
+    Instead, we manually unload all of the modules in the dependency and then
+    `reload_package` any packages that use that dependency. (We have to manually
+    unload the dependency's modules because calling `reload_package` on a
+    dependent module will not unload the dependency.)
+    """
+    for name in get_package_modules(dependency_name):
+        del sys.modules[name]
+
+    manager = PackageManager()
+    for package in manager.list_packages():
+        if dependency_name in manager.get_dependencies(package):
+            reload_package(package, dummy=False, verbose=verbose)
+
+    if dummy:
+        load_dummy(verbose)
+
+
 def load_dummy(verbose):
     """
     Hack to trigger automatic "reloading plugins".
@@ -67,20 +135,25 @@ def load_dummy(verbose):
         dprint("installing dummy package")
     dummy = "_dummy_package"
     dummy_py = os.path.join(sublime.packages_path(), "%s.py" % dummy)
-    open(dummy_py, "w").close()
+    with open(dummy_py, "w"):
+        pass
 
     def remove_dummy(trial=0):
         if dummy in sys.modules:
             if verbose:
                 dprint("removing dummy package")
-            if os.path.exists(dummy_py):
+            try:
                 os.unlink(dummy_py)
+            except FileNotFoundError:
+                pass
             after_remove_dummy()
         elif trial < 300:
             threading.Timer(0.1, lambda: remove_dummy(trial + 1)).start()
         else:
-            if os.path.exists(dummy_py):
+            try:
                 os.unlink(dummy_py)
+            except FileNotFoundError:
+                pass
 
     condition = threading.Condition()
 
@@ -112,8 +185,8 @@ def reload_missing(modules, verbose):
 
 def reload_plugin(pkg_name):
     pkg_path = os.path.join(os.path.realpath(sublime.packages_path()), pkg_name)
-    plugins = [pkg_name + "." + os.path.splitext(f)[0]
-               for f in os.listdir(pkg_path) if f.endswith(".py")]
+    plugins = [pkg_name + "." + os.path.splitext(file_path)[0]
+               for file_path in os.listdir(pkg_path) if file_path.endswith(".py")]
     for plugin in plugins:
         sublime_plugin.reload_plugin(plugin)