update reloader code

Author: randy3k

unittesting/utils/reloader.py

@@ -11,30 +11,75 @@
 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', ' '))
         caption = sep.join(args)
         args = "{0:{fill}<{width}}".format(caption and caption + sep,
                                            fill=fill, width=fill_width),
-    print("[UnitTesting]", *args, **kwargs)
+    print("[Package Reloader]", *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,27 @@ def reload_package(pkg_name, dummy=True, verbose=True):
         dprint("end", fill='-')
 
 
+def reload_dependency(dependency_name, dummy=True, verbose=True):
+    """
+    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 +133,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 +183,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)