def resolve_dependencies(root_name):
"""Given the name of a dependency, return all dependencies and packages
that require that dependency, directly or indirectly.
"""
manager = PackageManager()
all_packages = manager.list_packages()
all_dependencies = manager.list_dependencies()
recursive_dependencies = set()
dependent_packages = set()
dependency_relationships = {
name: manager.get_dependencies(name)
for name in all_packages + all_dependencies
}
def rec(name):
if name in recursive_dependencies:
return
recursive_dependencies.add(name)
for dep_name in all_dependencies:
if name in dependency_relationships[dep_name]:
rec(dep_name)
for pkg_name in all_packages:
if name in dependency_relationships[pkg_name]:
dependent_packages.add(pkg_name)
rec(root_name)
return (recursive_dependencies, dependent_packages)
def resolve_dependencies(root_name):
"""Given the name of a dependency, return all dependencies and packages
that require that dependency, directly or indirectly.
"""
manager = PackageManager()
all_packages = manager.list_packages()
all_dependencies = manager.list_dependencies()
recursive_dependencies = set()
dependent_packages = set()
dependency_relationships = {
name: manager.get_dependencies(name)
for name in all_packages + all_dependencies
}
def rec(name):
if name in recursive_dependencies:
return
recursive_dependencies.add(name)
for dep_name in all_dependencies:
if name in dependency_relationships[dep_name]:
rec(dep_name)
for pkg_name in all_packages:
if name in dependency_relationships[pkg_name]:
dependent_packages.add(pkg_name)
rec(root_name)
return (recursive_dependencies, dependent_packages)
def resolve_parents(root_name):
"""Given the name of a dependency, return all dependencies and packages
that require that dependency, directly or indirectly.
"""
manager = PackageManager()
everything = manager.list_packages() + manager.list_dependencies()
recursive_dependencies = set()
dependency_relationships = {
name: manager.get_dependencies(name)
for name in everything
}
def rec(name):
if name in recursive_dependencies:
return
recursive_dependencies.add(name)
for pkg_name in everything:
if name in dependency_relationships[pkg_name]:
rec(pkg_name)
rec(root_name)
recursive_dependencies.remove(root_name)
return recursive_dependencies
class PHPIDE(threading.Thread):
def __init__(self):
self.manager = PackageManager()
threading.Thread.__init__(self)
def run(self):
installed_packages = self.manager.list_packages()
for plugin in Prefs.plugins:
print "- checking plugin " + plugin
if not plugin in installed_packages:
self.manager.install_package(plugin)
class PackageController:
user_dir = None
def __init__(self):
sublime_dir = os.path.dirname(sublime.packages_path())
installed_packages_dir = os.path.join(sublime_dir,
'Installed Packages')
packages_dir = os.path.join(sublime_dir, 'Packages')
self.user_dir = os.path.join(packages_dir, 'User')
package_control = os.path.join(installed_packages_dir,
"Package Control.sublime-package")
sys.path.append(package_control)
from package_control.package_manager import PackageManager
self.package_control = PackageManager()
def install_packages(self,
packages,
callback=lambda: True,
wipe_others=True):
if wipe_others:
installed_packages = self.package_control.list_packages()
to_remove = []
for pkg in installed_packages:
if pkg not in packages:
to_remove.append(pkg)
to_install = []
for pkg in packages:
if pkg in installed_packages:
continue
to_install.append(pkg)
PackageResolver(self.package_control, to_install, to_remove,
callback).start()
def reload(self):
# We have to delete `Package Control.last-run` to not run into the cache
last_run_file = os.path.join(self.user_dir, "Package Control.last-run")
if os.path.isfile(last_run_file):
os.remove(last_run_file)
from package_control.package_cleanup import PackageCleanup
sublime.set_timeout(lambda: PackageCleanup().start(), 2000)
def install_amxx_editor_menu_on_first_run():
# https://packagecontrol.io/docs/events
from package_control import events
if events.install(CURRENT_PACKAGE_NAME):
log(1, 'Installed %s!', events.install(CURRENT_PACKAGE_NAME))
from package_control.package_manager import PackageManager
package_manager = PackageManager()
all_packages = set(package_manager.list_packages())
if AMXX_CHANNEL in all_packages:
amxx_channel_path = os.path.join(PACKAGE_ROOT_DIRECTORY,
AMXX_CHANNEL)
if not os.path.exists(amxx_channel_path):
add_main_menu()
def get_installed_packages(exclusion_list=[],
list_default_packages=False,
list_dependencies=False):
if PackageManager:
packages = []
package_manager = PackageManager()
if list_default_packages:
packages.extend(package_manager.list_default_packages())
if list_dependencies:
packages.extend(package_manager.list_dependencies())
packages.extend(package_manager.list_packages())
return list(set(packages) - set(exclusion_list))
else:
raise ImportError(
"You can only use the Sublime Text API inside Sublime Text.")
class PackageController:
user_dir = None
def __init__(self):
sublime_dir = os.path.dirname(sublime.packages_path())
installed_packages_dir = os.path.join(sublime_dir, 'Installed Packages')
packages_dir = os.path.join(sublime_dir, 'Packages')
self.user_dir = os.path.join(packages_dir, 'User')
package_control = os.path.join(installed_packages_dir, "Package Control.sublime-package")
sys.path.append(package_control)
from package_control.package_manager import PackageManager
self.package_control = PackageManager()
def install_packages(self, packages, callback=lambda: True, wipe_others=True):
if wipe_others:
installed_packages = self.package_control.list_packages()
to_remove = []
for pkg in installed_packages:
if pkg not in packages:
to_remove.append(pkg)
to_install = []
for pkg in packages:
if pkg in installed_packages:
continue
to_install.append(pkg)
PackageResolver(self.package_control, to_install, to_remove, callback).start()
def reload(self):
# We have to delete `Package Control.last-run` to not run into the cache
last_run_file = os.path.join(self.user_dir, "Package Control.last-run")
if os.path.isfile(last_run_file):
os.remove(last_run_file)
from package_control.package_cleanup import PackageCleanup
sublime.set_timeout(lambda: PackageCleanup().start(), 2000)
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 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.)
"""
dependency_base = os.path.join(sublime.packages_path(),
dependency_name) + os.sep
for module in list(sys.modules.values()):
if getattr(module, '__file__', '').startswith(dependency_base):
del sys.modules[module.__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)
