def _on_select(self, idx):
# selected
if idx > -1:
# get the selected platform
plat = self.plats[idx]
if plat:
plugin.set_option("plat", plat)
# update architecture
arch = None
host = {
"osx": "macosx",
"linux": "linux",
"windows": "windows"
}[sublime.platform()]
if plat == host:
arch = sublime.arch() if sublime.platform(
) == "windows" else {
"x86": "i386",
"x64": "x86_64"
}[sublime.arch()]
else:
arch = {
"windows": "x86",
"macosx": "x86_64",
"linux": "x86_64",
"mingw": "x86_64",
"iphoneos": "arm64",
"watchos": "armv7k",
"android": "armv7-a"
}[plat]
if arch:
plugin.set_option("arch", arch)
def run(self):
if int(self.getLatestVersion()) == int(sublime.version()):
print ("currently on latest version")
else:
print ("new version available")
if sublime.platform() == "windows":
#download the latest installer
s = sublime.load_settings("Preferences.sublime-settings") #get the install path from preferences
install_path = s.get("install_path", "")
f = urllib2.urlopen("http://www.sublimetext.com/2")
format = formatter.NullFormatter()
parser = LinksParser(format)
html = f.read()
parser.feed(html) #get the list of latest installer urls
parser.close()
urls = parser.get_links()
if sublime.arch() == "x32":
download_link = urls[1]
elif sublime.arch() == "x64":
download_link = urls[3]
download_link = quote(download_link, safe="%/:=&?~#+!$,;'@()*[]")
sublime.status_message('SublimeUpdater is downloading update')
thr = BackgroundDownloader(download_link, install_path, download_link) #start the download thread
threads = []
threads.append(thr)
thr.start()
elif sublime.platform() == "linux":
print "linux detected"
elif sublime.platform() == "osx":
print "mac detected"
def env(self):
if self.visual_studio_versions:
vs_versions = self.visual_studio_versions
else:
vs_versions = [15, 14.1, 14, 13, 12, 11, 10, 9, 8]
if self.target_architecture:
arch = self.target_architecture
else:
arch = 'x86'
if sublime.arch() == 'x32':
host = 'x86'
elif sublime.arch() == 'x64':
host = 'amd64'
else:
sublime.error_message('Unknown Sublime architecture: %s' %
sublime.arch())
return
if arch != host:
arch = host + '_' + arch
for version in vs_versions:
try:
vcvars = query_vcvarsall(version, arch)
if vcvars:
print('found vcvarsall for version', version)
return vcvars
except Exception:
print('could not find vsvcarsall for version', version)
continue
print('warning: did not find vcvarsall.bat')
return {}
def run(self, edit, encoding, file_name):
self.view.set_name("ConvertToUTF8 Instructions")
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
msg = "Oops! The file {0} is detected as {1} which is not supported by your Sublime Text.\n\nPlease check whether it is in the list of Python's Standard Encodings (http://docs.python.org/library/codecs.html#standard-encodings) or not.\n\nIf yes, ".format(
file_name, encoding
)
branch = self.get_branch(sublime.platform(), sublime.arch())
if branch:
ver = "33" if ST3 else "26"
msg = (
msg
+ "please install Codecs{0} (https://github.com/seanliang/Codecs{0}/tree/{1}) and restart Sublime Text to make ConvertToUTF8 work properly. If it is still not working, ".format(
ver, branch
)
)
import platform
msg = (
msg
+ "please kindly send the following information to sunlxy#yahoo.com:\n====== Debug Information ======\nVersion: {0}-{1}\nPlatform: {2}\nPath: {3}\nEncoding: {4}\n".format(
sublime.version(), sublime.arch(), platform.platform(), sys.path, encoding
)
)
self.view.insert(edit, 0, msg)
self.view.set_read_only(True)
self.view.window().focus_view(self.view)
def get_cache():
import platform
import os
if cindex.conf == None:
try:
cindex.conf = cindex.Config()
cindex.arch = sublime.arch()
cindex.register_enumerations()
print(cindex.conf.library_file)
except OSError as err:
print(err)
library = cindex.conf.library_file
if os.system == 'Linux':
common.error_message(
"""It looks like '%s' couldn't be loaded. On Linux use your package manager to install clang-3.7.1\n\n \
or alternatively download a pre-built binary from http://www.llvm.org and put it in your ~/bin/\n\n \
Visit https://github.com/ensisoft/SublimeClang for more information.""" % (library))
else:
common.error_message(
"""It looks like '%s' couldn't be loaded.\n\n \
Download a pre-built binary from http://www.llvm.org and install it in your system.\n\n \
Note that the architecture needs to match your SublimeText 2 architecture.\n\n \
Visit https://github.com/ensisoft/SublimeClang for more information.""" % (library))
raise err
if tulib.cachelib == None:
libcache = ""
packages = sublime.packages_path()
package = os.path.join(packages, "SublimeClang")
arch = sublime.arch()
try:
libname = tulib.get_cache_library(arch)
libcache = os.path.join(package, libname)
tulib.init_cache_lib(libcache)
print("Loaded: '%s'" % (libcache))
except OSError as err:
print(err)
if os.system == 'Linux':
common.error_message(
"""It looks like '%s' couldn't be loaded. On Linux you have to compile it yourself.\n\n \
Go to into your ~/.config/sublime-text-2/Packages/SublimeClang and run make.\n\n \
Visit https://github.com/ensisoft/SublimeClang for more information.""" % (libcache))
else:
common.error_message(
"""It looks like '%s' couldn't be loaded.\n\n \
Visit https://github.com/ensisoft/SublimeClang for more information.""" % (libcache))
raise err
if cache.tuCache == None:
number_threads = 4
cache.tuCache = TUCache(number_threads)
return cache.tuCache
def load_options(self):
# get window
window = sublime.active_window()
# get project directory
projectdir = self.get_projectdir(False)
if projectdir == None:
return
# get cache config
cache = None
config = subprocess.Popen(
self.get_xmake() +
""" l -c 'import("core.project.config"); config.load(); print("$(plat) $(arch) $(mode)")'""",
stdout=subprocess.PIPE,
cwd=projectdir,
shell=True).communicate()
if config and len(config) != 0:
cache = config[0].strip().decode('utf-8').split(' ')
# get platform
plat = cache[0] if cache != None and len(cache) > 0 else None
if plat != None and len(plat) > 0:
self.options["plat"] = plat
else:
self.options["plat"] = {
"osx": "macosx",
"linux": "linux",
"windows": "windows"
}[sublime.platform()]
# get architecture
arch = cache[1] if cache != None and len(cache) > 1 else None
if arch != None and len(arch) > 0:
self.options["arch"] = arch
else:
self.options["arch"] = sublime.arch() if sublime.platform(
) == "windows" else {
"x86": "i386",
"x64": "x86_64"
}[sublime.arch()]
# get architecture
mode = cache[2] if cache != None and len(cache) > 2 else None
if mode != None and len(mode) > 0:
self.options["mode"] = mode
else:
self.options["mode"] = "release"
def is_compatible(self, metadata):
"""
Detects if a package is compatible with the current Sublime Text install
:param metadata:
A dict from a metadata file
:return:
If the package is compatible
"""
sublime_text = metadata.get("sublime_text")
platforms = metadata.get("platforms", [])
# This indicates the metadata is old, so we assume a match
if not sublime_text and not platforms:
return True
if not is_compatible_version(sublime_text):
return False
if not isinstance(platforms, list):
platforms = [platforms]
platform_selectors = [sublime.platform() + "-" + sublime.arch(), sublime.platform(), "*"]
for selector in platform_selectors:
if selector in platforms:
return True
return False
def plugin_loaded():
global s, Pref, EncodingOnStatusBarListener
s = sublime.load_settings('Preferences.sublime-settings')
if not s.get('show_encoding', False):
s.set('show_encoding', True)
sublime.save_settings("Preferences.sublime-settings")
s = sublime.load_settings('EncodingHelper.sublime-settings')
Pref = Pref()
Pref.load()
s.clear_on_change('reload')
s.add_on_change('reload', lambda: Pref.load())
if sublime.platform() in ('linux', 'osx'):
import sys
path = os.path.normpath(
os.path.dirname(sublime.packages_path()) +
'/Packages/EncodingHelper/Codecs33-' + sublime.platform() + '-' +
sublime.arch() + '/lib')
if path not in sys.path:
sys.path.append(path)
EncodingOnStatusBarListener = EncodingOnStatusBarListener()
EncodingOnStatusBarListener.init_()
def get_usages_data(self):
return {
"SchemaVersion":
Constant.get_usages_schema_version(),
"Version":
Constant.get_version(),
"DebugMode":
str.lower(str(Settings().get("debug_mode"))),
"AsPackage":
str.lower(
str(
os.path.exists(
os.path.join(sublime.installed_packages_path(),
"Javatar.sublime-package")))),
"StartupTime":
"{0:.2f}s".format(Constant.startup_time),
"ActionHistory":
str.lower(str(Settings().get("enable_action_history"))),
"SublimeVersion":
str(sublime.version()),
"Platform":
sublime.platform(),
"Architecture":
sublime.arch()
}
def generate_dependency_paths(name):
"""
Accepts a dependency name and generates a dict containing the three standard
import paths that are valid for the current machine.
:param name:
A unicode string name of the dependency
:return:
A dict with the following keys:
- 'ver'
- 'plat'
- 'arch'
"""
dependency_dir = os.path.join(packages_path, name)
ver = u'st%s' % st_version
plat = sublime.platform()
arch = sublime.arch()
return {
'all': os.path.join(dependency_dir, u'all'),
'ver': os.path.join(dependency_dir, ver),
'plat': os.path.join(dependency_dir, u'%s_%s' % (ver, plat)),
'arch': os.path.join(dependency_dir, u'%s_%s_%s' % (ver, plat, arch))
}
def get_support_info():
pc_settings = sublime.load_settings('Package Control.sublime-settings')
is_installed_by_pc = str(
PACKAGE_NAME in set(pc_settings.get('installed_packages', [])))
info = {}
info['channel'] = sublime.channel()
info['version'] = sublime.version()
info['platform'] = sublime.platform()
info['arch'] = sublime.arch()
info['package_name'] = PACKAGE_NAME
info['package_version'] = PACKAGE_VERSION
info['pc_install'] = is_installed_by_pc
try:
import mdpopups
info['mdpopups_version'] = format_version(mdpopups,
'version',
call=True)
except Exception:
info['mdpopups_version'] = 'Version could not be acquired!'
try:
import markdown
info['markdown_version'] = format_version(markdown, 'version')
except Exception:
info['markdown_version'] = 'Version could not be acquired!'
try:
import jinja2
info['jinja_version'] = format_version(jinja2, '__version__')
except Exception:
info['jinja_version'] = 'Version could not be acquired!'
try:
import pygments
info['pygments_version'] = format_version(pygments, '__version__')
except Exception:
info['pygments_version'] = 'Version could not be acquired!'
return '''%(package_name)s:\n\n* version: %(package_version)s\n* installed via Package Control: %(pc_install)s\n\nSublime Text:\n\n* channel: %(channel)s\n* version: %(version)s\n* platform: %(platform)s\n* architecture: %(arch)s\n\nDependency versions:\n\n* mdpopups: %(mdpopups_version)s\n* markdown: %(markdown_version)s\n* pygments: %(pygments_version)s\n* jinja2: %(jinja_version)s''' % info
def get_support_info():
pc_settings = sublime.load_settings('Package Control.sublime-settings')
is_installed_by_pc = str(PACKAGE_NAME in set(pc_settings.get('installed_packages', [])))
info = {}
info['channel'] = sublime.channel()
info['version'] = sublime.version()
info['platform'] = sublime.platform()
info['arch'] = sublime.arch()
info['package_name'] = PACKAGE_NAME
info['package_version'] = PACKAGE_VERSION
info['pc_install'] = is_installed_by_pc
try:
import mdpopups
info['mdpopups_version'] = format_version(mdpopups, 'version', call=True)
except Exception:
info['mdpopups_version'] = 'Version could not be acquired!'
try:
import markdown
info['markdown_version'] = format_version(markdown, 'version')
except Exception:
info['markdown_version'] = 'Version could not be acquired!'
try:
import jinja2
info['jinja_version'] = format_version(jinja2, '__version__')
except Exception:
info['jinja_version'] = 'Version could not be acquired!'
try:
import pygments
info['pygments_version'] = format_version(pygments, '__version__')
except Exception:
info['pygments_version'] = 'Version could not be acquired!'
return '''%(package_name)s:\n\n* version: %(package_version)s\n* installed via Package Control: %(pc_install)s\n\nSublime Text:\n\n* channel: %(channel)s\n* version: %(version)s\n* platform: %(platform)s\n* architecture: %(arch)s\n\nDependency versions:\n\n* mdpopups: %(mdpopups_version)s\n* markdown: %(markdown_version)s\n* pygments: %(pygments_version)s\n* jinja2: %(jinja_version)s''' % info
def __select_dependencies(self, dependency_info):
"""
This is taken from Package Control (and slightly modified). It takes a
dependency JSON object from dependencies.json and determines which
entry (if any) should be used based on sublime version, os and
architecture. It will return an empty list if there is no match.
"""
platform_selectors = [
sublime.platform() + '-' + sublime.arch(),
sublime.platform(), '*'
]
for platform_selector in platform_selectors:
if platform_selector not in dependency_info:
continue
platform_dependency = dependency_info[platform_selector]
versions = platform_dependency.keys()
# Sorting reverse will give us >, < then *
for version_selector in sorted(versions, reverse=True):
if not _is_compatible_version(version_selector):
continue
return platform_dependency[version_selector]
# If there were no matches in the info, but there also weren't any
# errors, then it just means there are not dependencies for this machine
return []
def is_compatible(self, metadata):
"""
Detects if a package is compatible with the current Sublime Text install
:param metadata:
A dict from a metadata file
:return:
If the package is compatible
"""
sublime_text = metadata.get('sublime_text')
platforms = metadata.get('platforms', [])
# This indicates the metadata is old, so we assume a match
if not sublime_text and not platforms:
return True
if not is_compatible_version(sublime_text):
return False
if not isinstance(platforms, list):
platforms = [platforms]
platform_selectors = [
sublime.platform() + '-' + sublime.arch(),
sublime.platform(), '*'
]
for selector in platform_selectors:
if selector in platforms:
return True
return False
def plugin_loaded():
if DEBUG:
UTC_TIME = datetime.utcnow()
PYTHON = sys.version_info[:3]
VERSION = sublime.version()
PLATFORM = sublime.platform()
ARCH = sublime.arch()
PACKAGE = sublime.packages_path()
INSTALL = sublime.installed_packages_path()
message = ('Jekyll debugging mode enabled...\n'
'\tUTC Time: {time}\n'
'\tSystem Python: {python}\n'
'\tSystem Platform: {plat}\n'
'\tSystem Architecture: {arch}\n'
'\tSublime Version: {ver}\n'
'\tSublime Packages Path: {package}\n'
'\tSublime Installed Packages Path: {install}\n').format(
time=UTC_TIME,
python=PYTHON,
plat=PLATFORM,
arch=ARCH,
ver=VERSION,
package=PACKAGE,
install=INSTALL)
sublime.status_message('Jekyll: Debugging enabled...')
debug('Plugin successfully loaded.', prefix='\n\nJekyll', level='info')
debug(message, prefix='Jekyll', level='info')
def get_dict_arch_path():
"""Return Dict_arch.zip path."""
arch = sublime.arch()
if arch == "x32":
return os.path.join(BASE_PATH, "Dict32.zip")
elif arch == "x64":
return os.path.join(BASE_PATH, "Dict64.zip")
def setup():
if int(sublime.version()) < 3000:
# Sublime Text 2 & Python 2.6
pass
else:
# Sublime Text 3 & Python 3.3
globalhook.setup(sublime.arch() == 'x64')
def setUpClass(cls):
basedir = os.path.dirname(__file__)
mpath = os.path.normpath(os.path.join(
basedir, "..", "st3_{}_{}".format(sublime.platform(), sublime.arch())))
if mpath not in sys.path:
cls.mpath = mpath
sys.path.append(mpath)
def plugin_loaded():
if DEBUG:
UTC_TIME = datetime.utcnow()
PYTHON = sys.version_info[:3]
VERSION = sublime.version()
PLATFORM = sublime.platform()
ARCH = sublime.arch()
PACKAGE = sublime.packages_path()
INSTALL = sublime.installed_packages_path()
message = (
'Jekyll debugging mode enabled...\n'
'\tUTC Time: {time}\n'
'\tSystem Python: {python}\n'
'\tSystem Platform: {plat}\n'
'\tSystem Architecture: {arch}\n'
'\tSublime Version: {ver}\n'
'\tSublime Packages Path: {package}\n'
'\tSublime Installed Packages Path: {install}\n'
).format(time=UTC_TIME, python=PYTHON, plat=PLATFORM, arch=ARCH,
ver=VERSION, package=PACKAGE, install=INSTALL)
sublime.status_message('Jekyll: Debugging enabled...')
debug('Plugin successfully loaded.', prefix='\n\nJekyll', level='info')
debug(message, prefix='Jekyll', level='info')
def generate_dependency_paths(name):
"""
Accepts a dependency name and generates a dict containing the three standard
import paths that are valid for the current machine.
:param name:
A unicode string name of the dependency
:return:
A dict with the following keys:
- 'ver'
- 'plat'
- 'arch'
"""
packages_dir = os.path.join(st_dir, u'Packages')
dependency_dir = os.path.join(packages_dir, name)
ver = u'st%s' % st_version
plat = sublime.platform()
arch = sublime.arch()
return {
'all': os.path.join(dependency_dir, 'all'),
'ver': os.path.join(dependency_dir, ver),
'plat': os.path.join(dependency_dir, u'%s_%s' % (ver, plat)),
'arch': os.path.join(dependency_dir, u'%s_%s_%s' % (ver, plat, arch))
}
def setup(hwnd):
if int(sublime.version()) < 3000:
pass
else:
# load dll
globalhook.setup(hwnd, sublime.arch() == 'x64')
def _PrintDebugInfo():
"""Prints debug info into the sublime console."""
if not is_debug():
return
message = (
'AutoPEP8:'
'\n\tsublime: version=%(subl_version)s, platform=%(subl_platform)s,'
' arch=%(subl_arch)s,'
' packages_path=%(subl_packages)s\n,'
' installed_packages_path=%(subl_installed_packages)s'
'\n\tplugin: version=%(plugin_version)s'
'\n\tconfig: %(config)s'
)
config_keys = (
'max-line-length', 'list-fixes', 'ignore', 'select', 'aggressive',
'indent-size', 'format_on_save', 'syntax_list',
'file_menu_search_depth', 'avoid_new_line_in_select_mode', 'debug',
)
config = {}
for key in config_keys:
config[key] = Settings(key, None)
message_values = {
'plugin_version': VERSION,
'subl_version': sublime.version(),
'subl_platform': sublime.platform(),
'subl_arch': sublime.arch(),
'subl_packages': sublime.packages_path(),
'subl_installed_packages': sublime.installed_packages_path(),
'config': config
}
get_logger().debug(message, message_values)
def run(self, message):
v = OutputPanel('dart.config.check')
text = HEADING + '\n'
text += ('=' * 80) + '\n'
text += 'MESSAGE:\n'
text += message + '\n'
text += '\n'
text += 'CONFIGURATION:\n'
text += ('-' * 80) + '\n'
text += "editor version: {} ({})".format(sublime.version(),
sublime.channel())
text += '\n'
text += ('-' * 80) + '\n'
text += "os: {} ({})".format(sublime.platform(),
sublime.arch())
text += '\n'
text += ('-' * 80) + '\n'
setts = sublime.load_settings('Dart - Plugin Settings.sublime-settings')
text += "dart_sdk_path: {}".format(setts.get('dart_sdk_path'))
text += '\n'
text += '=' * 80
v.write(text)
v.show()
def collect(self):
self.elements.clear()
db0 = DataBlock('Version and architecture')
db0.items.append(DataItem('name', 'Sublime Text'))
db0.items.append(DataItem('version', sublime.version()))
db0.items.append(DataItem('architecture', sublime.arch()))
db0.items.append(DataItem('channel', sublime.channel()))
db0.items.append(DataItem('platform', sublime.platform()))
view = sublime.active_window().active_view()
view_settings = view.settings()
db1 = DataBlock('View settings')
for setting_name in ('syntax', 'tab_size', 'translate_tabs_to_spaces'):
db1.items.append(DataItem(setting_name, view_settings.get(setting_name)))
db2 = DataBlock('View state')
db2.items.append(DataItem('is view dirty', view.is_dirty()))
db2.items.append(DataItem('is view readonly', view.is_read_only()))
db1.items.append(DataItem('encoding', view.encoding()))
db1.items.append(DataItem('em width', view.em_width()))
db1.items.append(DataItem('selection count', len(view.sel())))
db1.items.append(DataItem('has non empty selections', view.has_non_empty_selection_region()))
self.elements.append(db0)
# TODO: Split the rest up into methods.
self.collect_package_data()
self.elements.append(db1)
self.elements.append(db2)
self.collect_profiling_data()
def setup():
if int(sublime.version()) < 3000:
# Sublime Text 2 & Python 2.6
pass
else:
# Sublime Text 3 & Python 3.3
globalhook.setup(sublime.arch() == 'x64')
def setup():
if int(sublime.version()) < 3000:
# Sublime Text 2 & Python 2.6
messagehook.setup(callback)
else:
# Sublime Text 3 & Python 3.3
globalhook.setup(sublime.arch() == 'x64')
def get_predefined_param(self, match):
'''{%%}'''
key = match.group(1)
if key == 'filename':
return os.path.basename(self.view.file_name() or '')
elif key == 'filepath':
return self.view.file_name() or ''
elif key == 'dirname':
return os.path.dirname(self.view.file_name() or '')
elif key == 'platform':
return sublime.platform()
elif key == 'arch':
return sublime.arch()
elif key == 'encoding':
encoding = self.view.encoding()
return encoding if 'Undefined' != encoding else self.settings.get('default_encoding')
elif key == 'ip':
return get_local_ip()
elif key == 'user':
user = os.getlogin() if 'windows' != sublime.platform() else ''
if user:
return user
#windows?
user = os.popen('whoami').read()
p = re.compile('[\r\n]', re.M)
return re.sub(p, '', user)
elif key == 'ext':
return get_ext(self.view.file_name())
elif key == 'year':
t = datetime.datetime.today()
return t.strftime('%Y')
elif key == 'datetime':
t = datetime.datetime.today()
return t.strftime(self.get_action_param('datetime_format', '%Y-%m-%d %H:%M:%S'))
return match.group(1)
def run(self, message):
v = OutputPanel('dart.config.check')
text = HEADING + '\n'
text += ('=' * 80) + '\n'
text += 'MESSAGE:\n'
text += message + '\n'
text += '\n'
text += 'CONFIGURATION:\n'
text += ('-' * 80) + '\n'
text += "editor version: {} ({})".format(sublime.version(),
sublime.channel())
text += '\n'
text += ('-' * 80) + '\n'
text += "os: {} ({})".format(sublime.platform(), sublime.arch())
text += '\n'
text += ('-' * 80) + '\n'
setts = sublime.load_settings(
'Dart - Plugin Settings.sublime-settings')
text += "dart_sdk_path: {}".format(setts.get('dart_sdk_path'))
text += '\n'
text += '=' * 80
v.write(text)
v.show()
def run(self):
"""Run command."""
info = {}
info["platform"] = sublime.platform()
info["version"] = sublime.version()
info["arch"] = sublime.arch()
info["bh_version"] = __version__
info["pc_install"] = is_installed_by_package_control()
try:
import mdpopups
info["mdpopups_version"] = format_version(mdpopups,
'version',
call=True)
except Exception:
info["mdpopups_version"] = 'Version could not be acquired!'
try:
import markdown
info["markdown_version"] = format_version(markdown, 'version')
except Exception:
info["markdown_version"] = 'Version could not be acquired!'
try:
import jinja2
info["jinja_version"] = format_version(jinja2, '__version__')
except Exception:
info["jinja_version"] = 'Version could not be acquired!'
try:
import pygments
info["pygments_version"] = format_version(pygments, '__version__')
except Exception:
info["pygments_version"] = 'Version could not be acquired!'
msg = textwrap.dedent("""\
- Sublime Text: %(version)s
- Platform: %(platform)s
- Arch: %(arch)s
- Theme: %(bh_version)s
- Install via PC: %(pc_install)s
- Dependencies:
* mdpopups: %(mdpopups_version)s
* markdown: %(markdown_version)s
* pygments: %(pygments_version)s
* jinja2: %(jinja_version)s
""" % info)
view = sublime.active_window().active_view()
def copy_and_hide(msg):
sublime.set_clipboard(msg)
view.hide_popup()
view.show_popup(msg.replace('\n', '<br>') + '<br><a href="' + msg +
'">Copy</a>',
on_navigate=copy_and_hide,
max_height=340)
def GetSimulatorCmd(mainlua=None, debug=False):
platform = sublime.platform()
arch = sublime.arch()
view = sublime.active_window().active_view()
simulator_path = ""
simulator_flags = []
simulator_version = GetSetting("corona_sdk_version", None)
if mainlua is not None:
simulator_path = GetSimulatorPathFromBuildSettings(mainlua)
if simulator_path is None:
simulator_path = GetSetting("corona_sdk_simulator_path", None)
if platform == "osx":
if simulator_path is None:
simulator_path = GetLatestDailyBuildSimulatorPath()
if simulator_path is None:
simulator_path = "/Applications/CoronaSDK/Corona Simulator.app"
if simulator_path.endswith(".app"):
simulator_path += "/Contents/MacOS/Corona Simulator"
simulator_flags = ["-singleton", "1"]
if not GetSetting("corona_sdk_simulator_show_console", False):
simulator_flags += ["-no-console", "1"]
if debug:
simulator_flags.append("-debug")
simulator_flags.append("1")
simulator_flags.append("-project")
if os.path.isfile(simulator_path) and os.access(
simulator_path, os.X_OK):
simulator_version = str(
subprocess.check_output(
[
'defaults', 'read',
os.path.join(os.path.dirname(simulator_path),
'../Info.plist'), 'CFBundleVersion'
],
stderr=subprocess.STDOUT).decode('utf8').strip())
elif platform == 'windows':
if simulator_path is None:
if arch == "x64":
simulator_path = "C:\\Program Files (x86)\\Corona Labs\\Corona SDK\\Corona Simulator.exe"
else:
simulator_path = "C:\\Program Files\\Corona Labs\\Corona SDK\\Corona Simulator.exe"
simulator_flags = ["/singleton"]
if not GetSetting("corona_sdk_simulator_show_console", False):
simulator_flags += ["/no-console"]
if debug:
simulator_flags.append("/debug")
# Can we find an executable file at the path
if not os.path.isfile(simulator_path) or not os.access(
simulator_path, os.X_OK):
sublime.error_message(
"Cannot find executable Corona Simulator at path '{0}'\n\nYou can set the user preference 'corona_sdk_simulator_path' to the location of the Simulator."
.format(simulator_path))
return None, None, None
return simulator_path, simulator_flags, simulator_version
def send_to_api(self):
"""
Send archive file to API
"""
self.set_message("Sending archive...")
f = open(self.archive_filename, 'rb')
files = {
'package': f.read(),
'version': sublime.version()[:1],
'platform': sublime.platform(),
'arch': sublime.arch(),
'email': self.email,
'api_key': self.api_key,
}
# Send data and delete temporary file
try:
r = requests.post(
url=self.api_upload_url, files=files, timeout=50)
except requests.exceptions.ConnectionError as err:
self.set_timed_message(
"Error while sending archive: server not available, try later",
clear=True)
self.running = False
logger.error(
'Server (%s) not available, try later.\n'
'==========[EXCEPTION]==========\n'
'%s\n'
'===============================' % (
self.api_upload_url, err))
return
f.close()
os.unlink(self.archive_filename)
if r.status_code == 201:
self.set_timed_message("Successfully sent archive", clear=True)
logger.info('HTTP [%s] Successfully sent archive' % r.status_code)
elif r.status_code == 403:
self.set_timed_message(
"Error while sending archive: wrong credentials", clear=True)
logger.info('HTTP [%s] Bad credentials' % r.status_code)
elif r.status_code == 413:
self.set_timed_message(
"Error while sending archive: filesize too large (>20MB)", clear=True)
logger.error("HTTP [%s] %s" % (r.status_code, r.content))
else:
msg = "Unexpected error (HTTP STATUS: %s)" % r.status_code
try:
j = r.json()
for error in j.get('errors'):
msg += " - %s" % error
except:
pass
self.set_timed_message(msg, clear=True, time=10)
logger.error('HTTP [%s] %s' % (r.status_code, r.content))
self.post_send()
def commandOnAbsolutePath(command, settings):
dirPath = settings.get('fish_directory')
if not dirPath and sublime.platform() == 'windows':
if sublime.arch() == 'x32':
testPaths = ('C:/cygwin/bin', 'C:/msys32/usr/bin')
elif sublime.arch() == 'x64':
testPaths = ('C:/cygwin64/bin', 'C:/msys64/usr/bin')
for p in testPaths:
if os.path.exists(p):
dirPath = p
break
if dirPath:
return os.path.join(dirPath, command)
else:
return command
def platform_arch(cls) -> str:
return {
"linux_x64": "linux-x64",
"osx_arm64": "darwin-arm64",
"osx_x64": "darwin-x64",
"windows_x32": "win32-ia32",
"windows_x64": "win32-x64",
}[sublime.platform() + "_" + sublime.arch()]
def run(self, edit, encoding):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
msg = 'Due to the limitation of embedded Python with Sublime Text, ConvertToUTF8 might not work properly.\n\nYou have to install an extra plugin to solve this problem, please kindly send the debug information to sunlxy#yahoo.com to get it:\n====== Debug Information ======\nVersion: {0}\nPlatform: {1}\nArch: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.platform(), sublime.arch(), sys.path, encoding
)
self.view.insert(edit, 0, msg)
def run(self, edit, encoding):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
msg = 'Due to the limitation of embedded Python with Sublime Text, ConvertToUTF8 might not work properly.\n\nYou have to install an extra plugin to solve this problem, please kindly send the debug information to sunlxy#yahoo.com to get it:\n====== Debug Information ======\nVersion: {0}\nPlatform: {1}\nArch: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.platform(), sublime.arch(), sys.path, encoding
)
self.view.insert(edit, 0, msg)
def _color_picker_file():
executable_suffix = None
platform = sublime.platform()
if platform == "windows":
executable_suffix = "win.exe"
else:
executable_suffix = "%s_%s" % (platform, sublime.arch())
return "ColorPicker_" + executable_suffix
def run(self):
"""Run command."""
info = {}
info["platform"] = sublime.platform()
info["version"] = sublime.version()
info["arch"] = sublime.arch()
info["plugin_version"] = __version__
info["pc_install"] = is_installed_by_package_control()
try:
import mdpopups
info["mdpopups_version"] = format_version(mdpopups,
'version',
call=True)
except Exception:
info["mdpopups_version"] = 'Version could not be acquired!'
try:
import backrefs
info["backrefs_version"] = format_version(backrefs, 'version')
except Exception:
info["backrefs_version"] = 'Version could not be acquired!'
try:
import markdown
info["markdown_version"] = format_version(markdown, 'version')
except Exception:
info["markdown_version"] = 'Version could not be acquired!'
try:
import jinja2
info["jinja_version"] = format_version(jinja2, '__version__')
except Exception:
info["jinja_version"] = 'Version could not be acquired!'
try:
import pygments
info["pygments_version"] = format_version(pygments, '__version__')
except Exception:
info["pygments_version"] = 'Version could not be acquired!'
msg = textwrap.dedent("""\
- ST ver.: %(version)s
- Platform: %(platform)s
- Arch: %(arch)s
- Plugin ver.: %(plugin_version)s
- Install via PC: %(pc_install)s
- mdpopups ver.: %(mdpopups_version)s
- backrefs ver.: %(backrefs_version)s
- markdown ver.: %(markdown_version)s
- pygments ver.: %(pygments_version)s
- jinja2 ver.: %(jinja_version)s
""" % info)
sublime.message_dialog(msg +
'\nInfo has been copied to the clipboard.')
sublime.set_clipboard(msg)
def run(self, selector=None, action=""):
if self.action != "":
action = self.action
self.action = ""
if action == "additional_packages":
view = self.window.new_file()
view.set_name("Javatar - Additional Packages")
view.set_scratch(True)
view.run_command("javatar_util", {"type": "insert", "text": "==== This section is under development ====\n\nAdditional packages\n========\n To reduce plugin size, Javatar provides additional packages for different version of Java you are working.\n\nHere are all available packages:\n\nJavaSE7: http://\nJavaSE8: http://\nJavaFX8: http://\n\n==== This section is under development ===="})
if action == "actions_history":
if not getSettings("enable_actions_history"):
sublime.message_dialog("Actions History is disabled. Please enable them first.")
return
self.action = action
if selector is not None:
report = "## Javatar Report\n### System Informations\n* Javatar Version: `%javatar_version%`\n* Sublime Version: `%sublime_version%`\n* Package Path: `%packages_path%`\n* Javatar Channel: `%javatar_channel%`\n* Sublime Channel: `%sublime_channel%`\n* Platform: `%platform%`\n* As Packages: `%is_package%`\n* Package Control: `%package_control%`\n* Architecture: `%arch%`\n* Javatar's Parent Folder: `%parent_folder%`\n* Is Project: `%is_project%`\n* Is File: `%is_file%`\n* Is Java: `%is_java%`\n\n### Action List\n%actions%"
report = report.replace("%javatar_version%", getVersion())
report = report.replace("%javatar_channel%", str.lower(getSettings("package_channel")))
report = report.replace("%is_package%", str(getPath("exist", getPath("join", sublime.installed_packages_path(), "Javatar.sublime-package"))))
report = report.replace("%parent_folder%", getPath("javatar_parent"))
report = report.replace("%sublime_version%", str(sublime.version()))
report = report.replace("%sublime_channel%", sublime.channel())
report = report.replace("%package_control%", str(getPath("exist", getPath("join", sublime.packages_path(), "Package Control")) or getPath("exist", getPath("join", sublime.installed_packages_path(), "Package Control.sublime-package"))))
report = report.replace("%is_project%", str(isProject()))
report = report.replace("%is_file%", str(isFile()))
report = report.replace("%is_java%", str(isJava()))
report = report.replace("%packages_path%", sublime.packages_path())
report = report.replace("%platform%", sublime.platform())
report = report.replace("%arch%", sublime.arch())
selectors = selector.split("|")
if len(selectors) > 1:
include = selectors[0].split(",")
exclude = selectors[1].split(",")
else:
include = selectors[0].split(",")
exclude = []
actionText = ""
actions = getAction().getAction(include, exclude)
c = 1
for action in actions:
if c > 1:
actionText += "\n"
actionText += str(c) + ". " + action
c += 1
report = report.replace("%actions%", actionText)
view = self.window.new_file()
view.set_name("Javatar Actions History Report")
view.set_scratch(True)
view.run_command("javatar_util", {"type": "add", "text": report, "dest": "Actions History"})
view.run_command("javatar_util", {"type": "set_read_only"})
else:
self.window.show_input_panel("Selector: ", "", self.run, "", "")
def run(self):
"""Run command."""
info = {}
info["platform"] = sublime.platform()
info["version"] = sublime.version()
info["arch"] = sublime.arch()
info["plugin_version"] = __version__
info["pc_install"] = is_installed_by_package_control()
try:
import mdpopups
info["mdpopups_version"] = format_version(mdpopups, 'version', call=True)
except Exception:
info["mdpopups_version"] = 'Version could not be acquired!'
try:
import backrefs
info["backrefs_version"] = format_version(backrefs, 'version')
except Exception:
info["backrefs_version"] = 'Version could not be acquired!'
try:
import markdown
info["markdown_version"] = format_version(markdown, 'version')
except Exception:
info["markdown_version"] = 'Version could not be acquired!'
try:
import jinja2
info["jinja_version"] = format_version(jinja2, '__version__')
except Exception:
info["jinja_version"] = 'Version could not be acquired!'
try:
import pygments
info["pygments_version"] = format_version(pygments, '__version__')
except Exception:
info["pygments_version"] = 'Version could not be acquired!'
msg = textwrap.dedent(
"""\
- ST ver.: %(version)s
- Platform: %(platform)s
- Arch: %(arch)s
- Plugin ver.: %(plugin_version)s
- Install via PC: %(pc_install)s
- mdpopups ver.: %(mdpopups_version)s
- backrefs ver.: %(backrefs_version)s
- markdown ver.: %(markdown_version)s
- pygments ver.: %(pygments_version)s
- jinja2 ver.: %(jinja_version)s
""" % info
)
sublime.message_dialog(msg + '\nInfo has been copied to the clipboard.')
sublime.set_clipboard(msg)
def collect_all_options(view, filename, language):
assert view is not None
assert filename is not None
assert language is not None
assert language.is_supported()
assert cindex.conf is not None
global SystemIncludes
# use clang to figure out the magical -isystem paths
# todo: ObjC and ObjCPP ??
if SystemIncludes == None:
packages = sublime.packages_path()
package = os.path.join(packages, "SublimeClang")
source = ""
compiler = ""
cindex.conf.arch = sublime.arch()
if language.kind == Language.C:
source = "test.c"
compiler = cindex.conf.locate_clang()
elif language.kind == Language.CPP:
source = "test.cpp"
compiler = cindex.conf.locate_clang_cpp()
else:
raise Error("Unsupported language.")
source = os.path.join(package, source)
info = common.ClangInfo.collect(compiler, source)
SystemIncludes = info.internal_isystem
print("Found system includes:")
print(SystemIncludes)
# this is how we got it from the settings before...
#sys_includes = common.get_setting("system_include_paths", [])
opt = CompileOptions(language, SystemIncludes)
# This is the bitmask sent to index.parse.
# For example, to be able to go to the definition of
# preprocessed macros, set it to 1, for using an implicit
# precompiled header set it to 4 and for caching completion
# results, set it to 8. Or all together 1+4+8=13.
# See http://clang.llvm.org/doxygen/group__CINDEX__TRANSLATION__UNIT.html#gab1e4965c1ebe8e41d71e90203a723fe9
# and http://clang.llvm.org/doxygen/Index_8h_source.html
# for more details
opt.index_parse_type = 13
language_options = common.get_setting("language_options", {})
if language_options.has_key(language.key()):
opt.language_options = language_options[language.key()]
project_file, project_options = common.get_project_settings(filename)
if project_file != None:
opt.project_file = project_file
opt.project_options = project_options
return opt
def run(self):
"""Run command."""
info = {}
info["platform"] = sublime.platform()
info["version"] = sublime.version()
info["arch"] = sublime.arch()
info["bh_version"] = __version__
info["pc_install"] = is_installed_by_package_control()
try:
import mdpopups
info["mdpopups_version"] = format_version(mdpopups, 'version', call=True)
except Exception:
info["mdpopups_version"] = 'Version could not be acquired!'
try:
import markdown
info["markdown_version"] = format_version(markdown, 'version')
except Exception:
info["markdown_version"] = 'Version could not be acquired!'
try:
import jinja2
info["jinja_version"] = format_version(jinja2, '__version__')
except Exception:
info["jinja_version"] = 'Version could not be acquired!'
try:
import pygments
info["pygments_version"] = format_version(pygments, '__version__')
except Exception:
info["pygments_version"] = 'Version could not be acquired!'
msg = textwrap.dedent(
"""\
- Sublime Text: %(version)s
- Platform: %(platform)s
- Arch: %(arch)s
- Theme: %(bh_version)s
- Install via PC: %(pc_install)s
- Dependencies:
* mdpopups: %(mdpopups_version)s
* markdown: %(markdown_version)s
* pygments: %(pygments_version)s
* jinja2: %(jinja_version)s
""" % info
)
view = sublime.active_window().active_view()
def copy_and_hide(msg):
sublime.set_clipboard(msg)
view.hide_popup()
view.show_popup(msg.replace('\n', '<br>') + '<br><a href="' + msg + '">Copy</a>', on_navigate = copy_and_hide, max_height = 340)
def run(self):
info = {}
info['platform'] = sublime.platform()
info['version'] = sublime.version()
info['arch'] = sublime.arch()
info['boxy_version'] = __version__
info['pc_install'] = is_installed_by_package_control()
try:
import mdpopups
info['mdpopups_version'] = format_version(mdpopups,
'version',
call=True)
except Exception:
info['mdpopups_version'] = 'Version could not be acquired!'
try:
import markdown
info['markdown_version'] = format_version(markdown, 'version')
except Exception:
info['markdown_version'] = 'Version could not be acquired!'
try:
import jinja2
info['jinja_version'] = format_version(jinja2, '__version__')
except Exception:
info['jinja_version'] = 'Version could not be acquired!'
try:
import pygments
info['pygments_version'] = format_version(pygments, '__version__')
except Exception:
info['pygments_version'] = 'Version could not be acquired!'
msg = textwrap.dedent('''\
- Boxy Theme: %(boxy_version)s
- Sublime Text: %(version)s
- Platform: %(platform)s
- Package Control: %(pc_install)s
- Dependencies:
* mdpopups: %(mdpopups_version)s
* markdown: %(markdown_version)s
* pygments: %(pygments_version)s
* jinja2: %(jinja_version)s
''' % info)
view = sublime.active_window().active_view()
def copy_and_hide(msg):
sublime.set_clipboard(msg)
view.hide_popup()
view.show_popup(msg.replace('\n', '<br>') + '<br><a href="' + msg +
'">Copy</a>',
on_navigate=copy_and_hide)
def run(self, edit, encoding, file_name):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
msg = 'Oops! The file {0} is detected as {1} which is not supported by your Sublime Text.\n\nPlease check whether it is in the list of Python\'s Standard Encodings (http://docs.python.org/library/codecs.html#standard-encodings) or not.\n\nIf yes, '.format(
file_name, encoding)
branch = self.get_branch(sublime.platform(), sublime.arch())
if branch:
ver = '33' if ST3 else '26'
msg = msg + 'please install Codecs{0} (https://github.com/seanliang/Codecs{0}/tree/{1}) and restart Sublime Text to make ConvertToUTF8 work properly. If it is still not working, '.format(
ver, branch)
import platform
msg = msg + 'please kindly send the following information to sunlxy#yahoo.com:\n====== Debug Information ======\nVersion: {0}-{1}\nPlatform: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.arch(), platform.platform(), sys.path,
encoding)
self.view.insert(edit, 0, msg)
self.view.set_read_only(True)
self.view.window().focus_view(self.view)
def filter_releases(package, settings, releases):
"""
Returns all releases in the list of releases that are compatible with
the current platform and version of Sublime Text
:param package:
The name of the package
:param settings:
A dict optionally containing the `install_prereleases` key
:param releases:
A list of release dicts
:return:
A list of release dicts
"""
platform_selectors = [
sublime.platform() + '-' + sublime.arch(),
sublime.platform(), '*'
]
install_prereleases = settings.get('install_prereleases')
allow_prereleases = install_prereleases is True
if not allow_prereleases and isinstance(
install_prereleases, list) and package in install_prereleases:
allow_prereleases = True
if not allow_prereleases:
releases = version_exclude_prerelease(releases)
output = []
st_version = int(sublime.version())
for release in releases:
platforms = release.get('platforms', '*')
if not isinstance(platforms, list):
platforms = [platforms]
matched = False
for selector in platform_selectors:
if selector in platforms:
matched = True
break
if not matched:
continue
# Default to '*' (for legacy reasons), see #604
if not is_compatible_version(release.get('sublime_text', '*'),
st_version):
continue
output.append(release)
return output
def run(self):
info = {}
info['platform'] = sublime.platform()
info['version'] = sublime.version()
info['arch'] = sublime.arch()
info['boxy_version'] = __version__
info['pc_install'] = is_installed_by_package_control()
try:
import mdpopups
info['mdpopups_version'] = format_version(mdpopups, 'version',
call=True)
except Exception:
info['mdpopups_version'] = 'Version could not be acquired!'
try:
import markdown
info['markdown_version'] = format_version(markdown, 'version')
except Exception:
info['markdown_version'] = 'Version could not be acquired!'
try:
import jinja2
info['jinja_version'] = format_version(jinja2, '__version__')
except Exception:
info['jinja_version'] = 'Version could not be acquired!'
try:
import pygments
info['pygments_version'] = format_version(pygments, '__version__')
except Exception:
info['pygments_version'] = 'Version could not be acquired!'
msg = textwrap.dedent(
'''\
- Boxy Theme: %(boxy_version)s
- Sublime Text: %(version)s
- Platform: %(platform)s
- Package Control: %(pc_install)s
- Dependencies:
* mdpopups: %(mdpopups_version)s
* markdown: %(markdown_version)s
* pygments: %(pygments_version)s
* jinja2: %(jinja_version)s
''' % info
)
view = sublime.active_window().active_view()
def copy_and_hide(msg):
sublime.set_clipboard(msg)
view.hide_popup()
view.show_popup(msg.replace('\n', '<br>') +
'<br><a href="' + msg + '">Copy</a>',
on_navigate=copy_and_hide)
def run(self, edit, encoding):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
fp = open(os.path.join(PKG_PATH, 'python26.txt'), 'r')
msg = fp.read()
fp.close()
msg += 'Version: {0}\nPlatform: {1}\nArch: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.platform(), sublime.arch(), sys.path, encoding
)
self.view.insert(edit, 0, msg)
def run(self, edit, encoding):
self.view.set_name('ConvertToUTF8 Instructions')
self.view.set_scratch(True)
self.view.settings().set("word_wrap", True)
fp = open(os.path.join(PKG_PATH, 'python26.txt'), 'r')
msg = fp.read()
fp.close()
msg += 'Version: {0}\nPlatform: {1}\nArch: {2}\nPath: {3}\nEncoding: {4}\n'.format(
sublime.version(), sublime.platform(), sublime.arch(), sys.path,
encoding)
self.view.insert(edit, 0, msg)
def has_libclang():
"""Ensure libclang tests will run only on platforms that support this.
Returns:
str: row contents
"""
# Older version of Sublime Text x64 have ctypes crash bug.
if platform.system() == "Windows" and sublime.arch() == "x64" and \
int(sublime.version()) < 3123:
return False
return True
def run(self, cmd = [], file_regex = "", kill_old = False, dream_seeker = False, dream_daemon = False): dmpath = path[sublime.arch()] dme_dir = self.build(dmpath, cmd[0], file_regex) dmb_dir = self.find_dmb(dme_dir) if dream_seeker: self.run_in_seeker(dmpath, dmb_dir) if dream_daemon: self.run_in_daemon(dmpath, dmb_dir)
def getArch():
result = ""
if os.environ['OS'].startswith("Windows"):
result = "windows_"
else:
result = "linux_"
if sublime.arch() == "x64":
result += "amd64"
else:
result += "386"
return result
def has_libclang():
"""Ensure libclang tests will run only on platforms that support this.
Returns:
str: row contents
"""
# Older version of Sublime Text x64 have ctypes crash bug.
if platform.system() == "Windows" and sublime.arch() == "x64" and \
int(sublime.version()) < 3123:
return False
return True
def get_arch():
try:
# handle a case of m1 running under roseeta
if sublime.platform() == "osx":
if "ARM64" in platform.version().upper():
return "arm64"
except Exception as e:
print("Error checking if apple m1:", e)
pass
return sublime.arch()
def getArch():
result = ""
if "windows" in sublime.platform():
result = "windows_"
else:
result = "linux_"
if sublime.arch() == "x64":
result += "amd64"
else:
result += "386"
return result
def __init__(self, *args, **kwargs):
super(PushbCommand, self).__init__(*args, **kwargs)
self.headers = {
'Accept': 'application/json',
'Authorization': 'Bearer ' + get_setting('token'),
'Content-Type': 'application/json',
'User-Agent': 'Sublime Text/%(version)s (%(platform)s/%(arch)s)' % {
'version': sublime.version(),
'platform': sublime.platform(),
'arch': sublime.arch(),
},
}
def filter_releases(package, settings, releases):
"""
Returns all releases in the list of releases that are compatible with
the current platform and version of Sublime Text
:param package:
The name of the package
:param settings:
A dict optionally containing the `install_prereleases` key
:param releases:
A list of release dicts
:return:
A list of release dicts
"""
platform_selectors = [
sublime.platform() + '-' + sublime.arch(),
sublime.platform(),
'*'
]
install_prereleases = settings.get('install_prereleases')
allow_prereleases = install_prereleases is True
if not allow_prereleases and isinstance(install_prereleases, list) and package in install_prereleases:
allow_prereleases = True
if not allow_prereleases:
releases = version_exclude_prerelease(releases)
output = []
for release in releases:
platforms = release.get('platforms', '*')
if not isinstance(platforms, list):
platforms = [platforms]
matched = False
for selector in platform_selectors:
if selector in platforms:
matched = True
break
if not matched:
continue
# Default to '*' (for legacy reasons), see #604
if not is_compatible_version(release.get('sublime_text', '*')):
continue
output.append(release)
return output
def run():
"""Run command."""
info = {
'platform': sublime.platform(),
'st_version': sublime.version(),
'arch': sublime.arch(),
'package_version': gitgutter_version(),
'pc_install': is_installed_by_package_control(),
'git_version': git_version()
}
try:
import markdown
info['markdown'] = module_version(markdown, 'version')
except ImportError:
info['markdown'] = 'not installed!'
try:
import mdpopups
info['mdpopups'] = module_version(mdpopups, 'version')
except ImportError:
info['mdpopups'] = 'not installed!'
try:
import jinja2
info['jinja'] = module_version(jinja2, '__version__')
except ImportError:
info['jinja'] = 'not installed!'
try:
import pygments
info['pygments'] = module_version(pygments, '__version__')
except ImportError:
info['pygments'] = 'not installed!'
msg = textwrap.dedent(
"""\
- Sublime Text %(st_version)s
- Platform: %(platform)s
- Arch: %(arch)s
- GitGutter %(package_version)s
- Install via PC: %(pc_install)s
- %(git_version)s
- mdpopups %(mdpopups)s
- markdown %(markdown)s
- pygments %(pygments)s
- jinja2 %(jinja)s
""" % info
)
sublime.message_dialog(msg + '\nInfo has been copied to clipboard.')
sublime.set_clipboard(msg)
def run(self):
info = {}
info['platform'] = sublime.platform()
info['version'] = sublime.version()
info['arch'] = sublime.arch()
info['boxy_version'] = __version__
info['pc_install'] = is_installed_by_package_control()
try:
import mdpopups
info['mdpopups_version'] = format_version(mdpopups, 'version',
call=True)
except Exception:
info['mdpopups_version'] = 'Version could not be acquired!'
try:
import markdown
info['markdown_version'] = format_version(markdown, 'version')
except Exception:
info['markdown_version'] = 'Version could not be acquired!'
try:
import jinja2
info['jinja_version'] = format_version(jinja2, '__version__')
except Exception:
info['jinja_version'] = 'Version could not be acquired!'
try:
import pygments
info['pygments_version'] = format_version(pygments, '__version__')
except Exception:
info['pygments_version'] = 'Version could not be acquired!'
msg = textwrap.dedent(
'''\
- Boxy Theme: %(boxy_version)s
- Sublime Text: %(version)s
- Platform: %(platform)s
- Package Control: %(pc_install)s
- Dependencies:
* mdpopups: %(mdpopups_version)s
* markdown: %(markdown_version)s
* pygments: %(pygments_version)s
* jinja2: %(jinja_version)s
''' % info
)
sublime.message_dialog(
msg + '\nInfo has been copied to the clipboard.'
)
sublime.set_clipboard(msg)
