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
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)
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)
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 chain_update(remove_packages,
install_packages,
processes,
on_complete=None):
manager = PackageManager()
remove_queue = remove_packages[:]
install_queue = install_packages[:]
processes_queue = processes[:]
def launch_next():
if remove_queue:
package = remove_queue.pop(0)
time.sleep(0.2)
remove(manager, package, on_complete=launch_next)
elif install_queue:
package = install_queue.pop(0)
time.sleep(0.2)
install(manager, package, on_complete=launch_next)
elif processes_queue:
process = processes_queue.pop(0)
time.sleep(0.2)
process.update(on_complete=launch_next)
elif on_complete:
sublime.set_timeout(on_complete, 1000)
launch_next()
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.")
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 __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 _try_uninstall_package_control():
silence_error_message_box(63.0)
g_settings.disable_package_control_uninstaller()
# Keeps it running continually because something is setting it back, enabling Package Control again
g_settings.setup_packages_ignored_list(
package_disabler, packages_to_add=packages_to_ignore)
# Wait some time until `Package Control` finally get ignored
for interval in range(0, 10):
safe_remove(g_package_control_package)
safe_remove(g_package_control_loader_file)
safe_remove(g_package_control_loader_file + "-new")
time.sleep(0.1)
time.sleep(IGNORE_PACKAGE_MINIMUM_WAIT_TIME)
package_manager = PackageManager()
package_manager.remove_package(PACKAGE_CONTROL_NAME, False)
package_manager.remove_package(PACKAGE_CONTROL_LOADER_NAME, False)
safe_remove(g_package_control_package)
safe_remove(g_package_control_loader_file)
safe_remove(g_package_control_loader_file + "-new")
_remove_package_control_from_installed_packages_setting(
g_settings.packagesmanager_setting_path())
_remove_package_control_from_installed_packages_setting(
g_settings.package_control_setting_path())
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)
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)
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 plugin_loaded():
global g_main_directory
g_main_directory = g_settings.main_directory()
global g_package_control_directory
g_package_control_directory = os.path.join(g_main_directory, "Packages",
PACKAGE_CONTROL_NAME)
global g_package_control_package
g_package_control_package = os.path.join(
g_main_directory, "Installed Packages",
"%s.sublime-package" % PACKAGE_CONTROL_NAME)
global g_package_control_loader_file
g_package_control_loader_file = os.path.join(
g_main_directory, "Installed Packages",
"%s.sublime-package" % PACKAGE_CONTROL_LOADER_NAME)
manager = PackageManager()
settings = manager.settings.copy()
threading.Thread(target=_background_bootstrap, args=(settings, )).start()
threading.Thread(target=configure_package_control_uninstaller).start()
def __init__(self):
self.manager = PackageManager()
threading.Thread.__init__(self)
def is_dependency(pkg_name):
return PackageManager()._is_dependency(pkg_name)
def plugin_loaded():
manager = PackageManager()
settings = manager.settings.copy()
if not loader.exists('package_control'):
base_loader_code = """
import sys
import os
from os.path import dirname
# This file adds the package_control subdirectory of Package Control
# to first in the sys.path so that all other packages may rely on
# PC for utility functions, such as event helpers, adding things to
# sys.path, downloading files from the internet, etc
if sys.version_info >= (3,):
def decode(path):
return path
def encode(path):
return path
loader_dir = dirname(__file__)
else:
def decode(path):
if not isinstance(path, unicode):
path = path.decode(sys.getfilesystemencoding())
return path
def encode(path):
if isinstance(path, unicode):
path = path.encode(sys.getfilesystemencoding())
return path
loader_dir = decode(os.getcwd())
st_dir = dirname(dirname(loader_dir))
found = False
if sys.version_info >= (3,):
installed_packages_dir = os.path.join(st_dir, u'Installed Packages')
pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package')
if os.path.exists(encode(pc_package_path)):
found = True
if not found:
packages_dir = os.path.join(st_dir, u'Packages')
pc_package_path = os.path.join(packages_dir, u'Package Control')
if os.path.exists(encode(pc_package_path)):
found = True
if found:
if os.name == 'nt':
from ctypes import windll, create_unicode_buffer
buf = create_unicode_buffer(512)
if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)):
pc_package_path = buf.value
sys.path.insert(0, encode(pc_package_path))
import package_control
# We remove the import path right away so as not to screw up
# Sublime Text and its import machinery
sys.path.remove(encode(pc_package_path))
else:
print(u'Package Control: Error finding main directory from loader')
"""
base_loader_code = dedent(base_loader_code).lstrip()
loader.add('00', 'package_control', base_loader_code)
# SSL support fo Linux
if sublime.platform() == 'linux':
linux_ssl_url = u'http://packagecontrol.io/ssl/1.0.1/ssl-linux.sublime-package'
linux_ssl_hash = u'862d061cbe666777cd1e9cd1cbc7c82f48ad8897dbb68332975f3edf5ce0f38d'
linux_ssl_priority = u'01'
linux_ssl_version = '1.0.1'
def linux_ssl_show_restart():
sublime.message_dialog(text.format(
u'''
Package Control
Package Control just installed or upgraded the missing Python
_ssl module for Linux since Sublime Text does not include it.
Please restart Sublime Text to make SSL available to all
packages.
'''
))
linux_ssl_args = (settings, linux_ssl_url, linux_ssl_hash,
linux_ssl_priority, linux_ssl_version, linux_ssl_show_restart)
threading.Thread(target=bootstrap_dependency, args=linux_ssl_args).start()
# SSL support for SHA-2 certificates with ST2 on Windows
if sublime.platform() == 'windows' and sys.version_info < (3,):
win_ssl_url = u'http://packagecontrol.io/ssl/1.0.0/ssl-windows.sublime-package'
win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030'
win_ssl_priority = u'01'
win_ssl_version = u'1.0.0'
def win_ssl_show_restart():
sublime.message_dialog(text.format(
u'''
Package Control
Package Control just upgraded the Python _ssl module for ST2 on
Windows because the bundled one does not include support for
modern SSL certificates.
Please restart Sublime Text to complete the upgrade.
'''
))
win_ssl_args = (settings, win_ssl_url, win_ssl_hash, win_ssl_priority,
win_ssl_version, win_ssl_show_restart)
threading.Thread(target=bootstrap_dependency, args=win_ssl_args).start()
pc_settings = sublime.load_settings(pc_settings_filename())
# Make sure we are track Package Control itself
installed_packages = load_list_setting(pc_settings, 'installed_packages')
if 'Package Control' not in installed_packages:
params = {
'package': 'Package Control',
'operation': 'install',
'version': package_control.__version__
}
manager.record_usage(params)
installed_packages.append('Package Control')
save_list_setting(pc_settings, pc_settings_filename(), 'installed_packages', installed_packages)
# We no longer use the installed_dependencies setting because it is not
# necessary and created issues with settings shared across operating systems
if pc_settings.get('installed_dependencies'):
pc_settings.erase('installed_dependencies')
sublime.save_settings(pc_settings_filename())
from .typing import List, Tuple
try:
from package_control.package_manager import PackageManager # type: ignore
manager = PackageManager()
def get_dependency_relationships() -> List[Tuple[str, str]]:
return [
(name, dep)
for name in (manager.list_packages() + manager.list_dependencies())
for dep in manager.get_dependencies(name)
]
except ImportError: # pragma: nocoverage
def get_dependency_relationships() -> List[Tuple[str, str]]:
return []
def ensure_dependencies_loaded() -> None:
for dependency in PackageManager().get_dependencies(PACKAGE_NAME):
add_dependency(dependency)
def plugin_loaded():
manager = PackageManager()
settings = manager.settings.copy()
if not os.path.exists(loader.loader_package_path):
base_loader_code = """
import sys
import os
from os.path import dirname
# This file adds the package_control subdirectory of Package Control
# to first in the sys.path so that all other packages may rely on
# PC for utility functions, such as event helpers, adding things to
# sys.path, downloading files from the internet, etc
if sys.version_info >= (3,):
def decode(path):
return path
def encode(path):
return path
loader_dir = dirname(__file__)
else:
def decode(path):
if not isinstance(path, unicode):
path = path.decode(sys.getfilesystemencoding())
return path
def encode(path):
if isinstance(path, unicode):
path = path.encode(sys.getfilesystemencoding())
return path
loader_dir = decode(os.getcwd())
st_dir = dirname(dirname(loader_dir))
found = False
if sys.version_info >= (3,):
installed_packages_dir = os.path.join(st_dir, u'Installed Packages')
pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package')
if os.path.exists(encode(pc_package_path)):
found = True
if not found:
packages_dir = os.path.join(st_dir, u'Packages')
pc_package_path = os.path.join(packages_dir, u'Package Control')
if os.path.exists(encode(pc_package_path)):
found = True
if found:
if os.name == 'nt':
from ctypes import windll, create_unicode_buffer
buf = create_unicode_buffer(512)
if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)):
pc_package_path = buf.value
sys.path.insert(0, encode(pc_package_path))
import package_control
# We remove the import path right away so as not to screw up
# Sublime Text and its import machinery
sys.path.remove(encode(pc_package_path))
else:
print(u'Package Control: Error finding main directory from loader')
"""
base_loader_code = dedent(base_loader_code)
loader.add('00', 'package_control', base_loader_code)
pc_settings = sublime.load_settings(pc_settings_filename())
# Make sure we are track Package Control itself
installed_packages = load_list_setting(pc_settings, 'installed_packages')
if 'Package Control' not in installed_packages:
installed_packages.append('Package Control')
save_list_setting(pc_settings, pc_settings_filename(),
'installed_packages', installed_packages)
orig_installed_dependencies = load_list_setting(pc_settings,
'installed_dependencies')
installed_dependencies = list(orig_installed_dependencies)
# Record that the loader itself is installed
if loader.loader_package_name not in installed_dependencies:
installed_dependencies.append(loader.loader_package_name)
# Queue up installation of bz2
if 'bz2' not in installed_dependencies:
installed_dependencies.append('bz2')
# Queue up installation of select module for ST2/Windows
if sublime.platform() == 'windows' and sys.version_info < (
3, ) and 'select-windows' not in installed_dependencies:
installed_dependencies.append('select-windows')
save_list_setting(pc_settings, pc_settings_filename(),
'installed_dependencies', installed_dependencies,
orig_installed_dependencies)
# SSL support fo Linux
if sublime.platform() == 'linux':
linux_ssl_url = u'http://packagecontrol.io/ssl-linux.sublime-package'
linux_ssl_hash = u'bd107e93065aa8520749fe37d9d15afc40af75c5ccbdcdb14966b7db162032d2'
linux_ssl_priority = u'01'
def linux_ssl_show_restart():
sublime.message_dialog(u'Package Control\n\n'
u'Package Control just installed the missing Python _ssl ' + \
u'module for Linux since Sublime Text does not include it.\n\n' + \
u'Please restart Sublime Text to make SSL available to all ' + \
u'packages.')
linux_ssl_args = (settings, linux_ssl_url, linux_ssl_hash,
linux_ssl_priority, linux_ssl_show_restart)
threading.Thread(target=bootstrap_dependency,
args=linux_ssl_args).start()
# SSL support for SHA-2 certificates with ST2 on Windows
if sublime.platform() == 'windows' and sys.version_info < (3, ):
win_ssl_url = u'http://packagecontrol.io/ssl-windows.sublime-package'
win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030'
win_ssl_priority = u'01'
def win_ssl_show_restart():
sublime.message_dialog(u'Package Control\n\n'
u'Package Control just upgraded the Python _ssl module for ' + \
u'ST2 on Windows because the bundled one does not include ' + \
u'support for modern SSL certificates.\n\n' + \
u'Please restart Sublime Text to complete the upgrade.')
win_ssl_args = (settings, win_ssl_url, win_ssl_hash, win_ssl_priority,
win_ssl_show_restart)
threading.Thread(target=bootstrap_dependency,
args=win_ssl_args).start()
def plugin_loaded():
manager = PackageManager()
settings = manager.settings.copy()
if not loader.exists('package_control'):
base_loader_code = """
import sys
import os
from os.path import dirname
# This file adds the package_control subdirectory of Package Control
# to first in the sys.path so that all other packages may rely on
# PC for utility functions, such as event helpers, adding things to
# sys.path, downloading files from the internet, etc
if sys.version_info >= (3,):
def decode(path):
return path
def encode(path):
return path
loader_dir = dirname(__file__)
else:
def decode(path):
if not isinstance(path, unicode):
path = path.decode(sys.getfilesystemencoding())
return path
def encode(path):
if isinstance(path, unicode):
path = path.encode(sys.getfilesystemencoding())
return path
loader_dir = decode(os.getcwd())
st_dir = dirname(dirname(loader_dir))
found = False
if sys.version_info >= (3,):
installed_packages_dir = os.path.join(st_dir, u'Installed Packages')
pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package')
if os.path.exists(encode(pc_package_path)):
found = True
if not found:
packages_dir = os.path.join(st_dir, u'Packages')
pc_package_path = os.path.join(packages_dir, u'Package Control')
if os.path.exists(encode(pc_package_path)):
found = True
if found:
if os.name == 'nt':
from ctypes import windll, create_unicode_buffer
buf = create_unicode_buffer(512)
if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)):
pc_package_path = buf.value
sys.path.insert(0, encode(pc_package_path))
import package_control
# We remove the import path right away so as not to screw up
# Sublime Text and its import machinery
sys.path.remove(encode(pc_package_path))
else:
print(u'Package Control: Error finding main directory from loader')
"""
base_loader_code = dedent(base_loader_code).lstrip()
loader.add('00', 'package_control', base_loader_code)
# SSL support fo Linux
if sublime.platform() == 'linux':
linux_ssl_url = u'http://packagecontrol.io/ssl/1.0.1/ssl-linux.sublime-package'
linux_ssl_hash = u'862d061cbe666777cd1e9cd1cbc7c82f48ad8897dbb68332975f3edf5ce0f38d'
linux_ssl_priority = u'01'
linux_ssl_version = '1.0.1'
def linux_ssl_show_restart():
sublime.message_dialog(
text.format(u'''
Package Control
Package Control just installed or upgraded the missing Python
_ssl module for Linux since Sublime Text does not include it.
Please restart Sublime Text to make SSL available to all
packages.
'''))
threading.Thread(target=bootstrap_dependency,
args=(
settings,
linux_ssl_url,
linux_ssl_hash,
linux_ssl_priority,
linux_ssl_version,
linux_ssl_show_restart,
)).start()
# SSL support for SHA-2 certificates with ST2 on Windows
elif sublime.platform() == 'windows' and sys.version_info < (3, ):
win_ssl_url = u'http://packagecontrol.io/ssl/1.0.0/ssl-windows.sublime-package'
win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030'
win_ssl_priority = u'01'
win_ssl_version = u'1.0.0'
def win_ssl_show_restart():
sublime.message_dialog(
text.format(u'''
Package Control
Package Control just upgraded the Python _ssl module for ST2 on
Windows because the bundled one does not include support for
modern SSL certificates.
Please restart Sublime Text to complete the upgrade.
'''))
threading.Thread(target=bootstrap_dependency,
args=(
settings,
win_ssl_url,
win_ssl_hash,
win_ssl_priority,
win_ssl_version,
win_ssl_show_restart,
)).start()
else:
mark_bootstrapped()
def plugin_loaded():
# tool_settings = sublime.load_settings('RansTool.sublime-settings')
# previous_version = tuple_ver(tool_settings.get("previous_version", "0.0.0"))
# if tool_settings.get('bootstrapped') is True and previous_version == (0, 0, 0):
# previous_version = (0, 0, 1)
# current_version = tuple_ver(tool_settings.get("current_version"))
progress_memory = ToolProgressMemory()
previous_version, current_version = progress_memory.load_progress_version()
candidate_remove = []
candidate_install = []
for since, removes, installs in pakages_since:
since = tuple_ver(since)
if previous_version < since <= current_version:
for rm in removes:
if rm in candidate_install:
candidate_install.remove(rm)
elif rm not in candidate_remove:
candidate_remove.append(rm)
for ins in installs:
if ins in candidate_remove:
candidate_remove.remove(ins)
elif ins not in candidate_install:
candidate_install.append(ins)
confighome = os.environ.get('XDG_CONFIG_HOME',
os.path.expanduser('~/.config'))
configpath = os.environ.get('ST_LIFE_USERCONFIG_PATH',
os.path.join(confighome, 'sublime-life'))
extra_packages_file = os.path.join(configpath, 'extra-packages.ini')
if os.path.exists(extra_packages_file):
with open(extra_packages_file) as f:
extra_packages = [
pkg.strip() for pkg in f.readlines() if pkg.strip()
]
for expkg in extra_packages:
if expkg in candidate_remove:
candidate_remove.remove(expkg)
elif expkg not in candidate_install:
candidate_install.append(expkg)
installed_packages = PackageManager().list_packages()
remove_packages = []
install_packages = []
for inspkg in candidate_install:
if inspkg in installed_packages:
print(
'RanTool install {} (Skip, already installed)'.format(inspkg))
else:
print('RanTool install {}'.format(inspkg))
install_packages.append(inspkg)
for rmpkg in candidate_remove:
if rmpkg not in installed_packages:
print('RanTool remove {} (Skip, not exist)'.format(rmpkg))
else:
print('RanTool remove {}'.format(rmpkg))
remove_packages.append(rmpkg)
processes = []
for p in UpdateProcess.update_processes:
if previous_version < p.since <= current_version:
processes.append(p)
def on_complete():
progress_memory.save_progress_version(current_version)
# tool_settings.set('previous_version', string_ver(current_version))
# sublime.save_settings('RansTool.sublime-settings')
if remove_packages or install_packages or processes:
if previous_version == (0, 0, 0):
sublime.active_window().status_message(
"Sublime Life is successful installed")
else:
sublime.active_window().status_message(
"Sublime Life is successful updated")
else:
sublime.active_window().status_message(
"Sublime Life is nothing to update")
chain_update(remove_packages,
install_packages,
processes,
on_complete=on_complete)
def install_sublime_linter(self):
from package_control.package_manager import PackageManager
manager = PackageManager()
manager.install_package("SublimeLinter")
def plugin_loaded():
manager = PackageManager()
settings = manager.settings.copy()
threading.Thread(target=_background_bootstrap, args=(settings, )).start()
