def __init__(self):
if not hasattr(self, "setting") is None:
self.setting = {}
if platform.system() == 'Windows':
self.dirSep = "\\"
else:
self.dirSep = '/'
self.setting['file_path'] = self.dirSep + "User" + self.dirSep + "memTask.json"
self.stopTimer = True
self.fileName = False
self.fileView = False
self.totalTime = {
'fromLastCommit': 0
}
self.finish = False
if not sublime.version() or int(sublime.version()) > 3000:
# Sublime Text 3
timeout = 1000
else:
timeout = 0
sublime.set_timeout(lambda: self.finish_init(), timeout)
def __init__(self, view, syntax=None):
self.platform = sublime.platform()
self.classmap = {}
self.st_version = 2
if sublime.version() == '' or int(sublime.version()) > 3000:
self.st_version = 3
self.file_name = view.file_name()
self.settings = sublime.load_settings('CodeFormatter.sublime-settings')
self.packages_path = sublime.packages_path()
self.syntax_file = view.settings().get('syntax')
self.syntax = syntax or self.get_syntax()
# map of settings names with related class
map_settings_formatter = [
('codeformatter_php_options', PhpFormatter),
('codeformatter_js_options', JsFormatter),
('codeformatter_css_options', CssFormatter),
('codeformatter_html_options', HtmlFormatter),
('codeformatter_python_options', PyFormatter),
('codeformatter_vbscript_options', VbscriptFormatter),
('codeformatter_scss_options', ScssFormatter),
('codeformatter_coldfusion_options', ColdfusionFormatter),
]
for name, _class in map_settings_formatter:
syntaxes = self.settings.get(name, {}).get('syntaxes')
if not syntaxes or not isinstance(syntaxes, str):
continue
for _formatter in syntaxes.split(','):
self.classmap[_formatter.strip()] = _class
def __init__(self, view=False, file_name=False, syntax=False):
self.platform = sublime.platform()
self.classmap = {
"php": PhpFormatter,
"javascript": JsFormatter,
"json": JsFormatter,
"html": HtmlFormatter,
"asp": HtmlFormatter,
"xml": HtmlFormatter,
"css": CssFormatter,
"less": CssFormatter,
"python": PyFormatter,
}
self.st_version = 2
if sublime.version() == "" or int(sublime.version()) > 3000:
self.st_version = 3
self.syntax_file = view.settings().get("syntax")
if syntax == False:
self.syntax = self.getSyntax()
else:
self.syntax = syntax
self.file_name = file_name
self.settings = sublime.load_settings("CodeFormatter.sublime-settings")
self.packages_path = sublime.packages_path()
def run(self, edit):
if int(sublime.version()) >= 3000:
org_sel = list(self.view.sel())
for region in self.view.sel():
expand_selection_around(self.view, region, r'(".*?"|\'.*?\'|%Q{.*?})')
for region in self.view.sel():
if region.size() == 0:
continue
selected = self.view.substr(region)
if selected[0] == '"':
inner = selected[1:-1]
inner = re.sub(r"[^\\]\'", lambda m: re.sub("'", "\\'", m.group(0)), inner)
inner = re.sub(r'\\"', '"', inner)
replace = "'" + inner + "'"
elif selected[0] == "'":
inner = selected[1:-1]
inner = re.sub(r"\\'", "'", inner)
inner = re.sub(r'\\"', '"', inner)
replace = "%Q{" + inner + "}"
elif selected[0] == "%":
inner = selected[3:-1]
inner = re.sub(r'[^\\]"', lambda m: re.sub('"', '\\"', m.group(0)), inner)
inner = re.sub(r"\\'", "'", inner)
replace = '"' + inner + '"'
else:
return
self.view.replace(edit, region, replace)
if int(sublime.version()) >= 3000:
self.view.sel().clear()
self.view.sel().add_all(org_sel)
def check_dependencies():
if sublime.version() > "3000" and 'Package Control' in sys.modules:
package_control = sys.modules['Package Control'].package_control
elif sublime.version() < "3000" and 'package_control' in sys.modules:
package_control = sys.modules['package_control']
else:
sublime.set_timeout(check_dependencies, 20)
return
manager = package_control.package_manager.PackageManager()
required_dependencies = set(manager.find_required_dependencies())
class myPackageCleanup(package_control.package_cleanup.PackageCleanup):
def finish(self, installed_packages, found_packages, found_dependencies):
missing_dependencies = required_dependencies - set(found_dependencies)
if len(missing_dependencies) == 0:
touch("success")
kill_subl()
else:
sublime.set_timeout(_check_dependencies, 20)
def _check_dependencies():
myPackageCleanup().run()
_check_dependencies()
def run(self, package_name, source, items):
# Reload current file first if not in root dir
if os.path.dirname(source):
if sublime.version()[0] == "3":
modulename = package_name + "." + (source.replace(os.sep, ".")[:-3] if source[-11:] != "__init__.py" else source.replace(os.sep, ".")[:-12])
else:
modulename = os.path.join(package_dir, source)
# Reload the file
sublime_plugin.reload_plugin(modulename)
print("Package Reloader - Reloading %s" % package_name)
# Load modules
for item in items:
if sublime.version()[0] == "3":
modulename = package_name + "." + (item.replace("/", ".")[:-3] if item[-11:] != "__init__.py" else item.replace("/", ".")[:-12])
else:
modulename = os.path.join(package_dir, item)
sublime_plugin.reload_plugin(modulename)
# Clean up multiple callbacks
for key, value in sublime_plugin.all_callbacks.items():
items = {}
for item in value:
name = item.__module__ + '.' + item.__class__.__name__
# Save item connected with the name
if name in items:
items[name] += [item]
else:
items[name] = [item]
sublime_plugin.all_callbacks[key] = [value[0] for key, value in items.items()]
def run(self, edit):
if int(sublime.version()) >= 3000:
org_sel = list(self.view.sel())
for region in self.view.sel():
expand_selection_around(self.view, region, r'(".*?"|\'.*?\'|:\w+)')
for region in self.view.sel():
if region.size() == 0:
continue
selected = self.view.substr(region)
if selected[0] == '"':
inner = selected[1:-1]
replace = ":" + inner
elif selected[0] == "'":
inner = selected[1:-1]
replace = ":" + inner
elif selected[0] == ":":
inner = selected[1:]
replace = '"' + inner + '"'
else:
return
self.view.replace(edit, region, replace)
if int(sublime.version()) >= 3000:
self.view.sel().clear()
self.view.sel().add_all(org_sel)
def __init__(self, view=False, file_name=False, syntax=False):
self.platform = sublime.platform()
self.classmap = {
'php': PhpFormatter,
'javascript': JsFormatter,
'json': JsFormatter,
'html': HtmlFormatter,
'asp': HtmlFormatter,
'xml': HtmlFormatter,
'css': CssFormatter,
'less': CssFormatter,
'python': PyFormatter
}
self.st_version = 2
if sublime.version() == '' or int(sublime.version()) > 3000:
self.st_version = 3
self.syntax_file = view.settings().get('syntax')
if syntax == False:
self.syntax = self.getSyntax()
else:
self.syntax = syntax
self.file_name = file_name
self.settings = sublime.load_settings('CodeFormatter.sublime-settings')
self.packages_path = sublime.packages_path()
def get_gutter_mark(self):
"""
Returns gutter mark icon or empty string if marks are disabled.
"""
# ST does not expect platform specific paths here, but only
# forward-slash separated paths relative to "Packages"
self.gutter_mark_success = '/'.join(
[settings.mark_themes_dir, 'success']
)
if int(sublime.version()) >= 3014:
self.gutter_mark_success += '.png'
self.gutter_mark = ''
mark_type = settings.gutter_marks
if mark_type in ('dot', 'circle', 'bookmark', 'cross'):
self.gutter_mark = mark_type
elif mark_type.startswith('theme-'):
theme = mark_type[6:]
if theme not in ('alpha', 'bright', 'dark', 'hard', 'simple'):
log("unknown gutter mark theme: '{0}'".format(mark_type))
return
# ST does not expect platform specific paths here, but only
# forward-slash separated paths relative to "Packages"
self.gutter_mark = '/'.join(
[settings.mark_themes_dir, '{0}-{{0}}'.format(theme)]
)
if int(sublime.version()) >= 3014:
self.gutter_mark += '.png'
def backup_with_prompt_on_done(path):
global prompt_parameters
if os.path.exists(path) == True:
if sublime.version()[0] == "2":
if sublime.ok_cancel_dialog(
"Backup already exists @ %s \nReplace it?" % path, "Continue") == True:
prompt_parameters["operation_to_perform"](path)
else:
tools.packagesync_cancelled()
else:
confirm_override = sublime.yes_no_cancel_dialog(
"Backup already exists @ %s \nReplace it?" % path, "Continue")
if confirm_override == sublime.DIALOG_YES:
prompt_parameters["operation_to_perform"](path)
elif sublime.version()[0] == "3" and confirm_override == sublime.DIALOG_NO:
prompt_parameters["initial_text"] = path
prompt_for_location()
else:
tools.packagesync_cancelled()
elif os.path.isabs(os.path.dirname(path)) == True:
prompt_parameters["operation_to_perform"](path)
else:
sublime.error_message("Please provide a valid path for backup.")
prompt_parameters["initial_text"] = path
prompt_for_location()
def __init__(self, view=False, file_name=False, syntax=False, saving=False):
self.platform = sublime.platform()
self.classmap = {}
self.st_version = 2
if sublime.version() == "" or int(sublime.version()) > 3000:
self.st_version = 3
self.file_name = file_name
self.settings = sublime.load_settings("CodeFormatter.sublime-settings")
self.packages_path = sublime.packages_path()
self.syntax_file = view.settings().get("syntax")
if syntax == False:
self.syntax = self.getSyntax()
else:
self.syntax = syntax
self.saving = saving
# PHP
opts = self.settings.get("codeformatter_php_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = PhpFormatter
# Javascript
opts = self.settings.get("codeformatter_js_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = JsFormatter
# CSS
opts = self.settings.get("codeformatter_css_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = CssFormatter
# HTML
opts = self.settings.get("codeformatter_html_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = HtmlFormatter
# Python
opts = self.settings.get("codeformatter_python_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = PyFormatter
# VBScript
opts = self.settings.get("codeformatter_vbscript_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = VbscriptFormatter
# SCSS
opts = self.settings.get("codeformatter_scss_options")
if "syntaxes" in opts and opts["syntaxes"]:
for _formatter in opts["syntaxes"].split(","):
self.classmap[_formatter.strip()] = PyFormatter
def is_compatible_version(version_range):
min_version = float("-inf")
max_version = float("inf")
if version_range == '*':
return True
gt_match = re.match('>(\d+)$', version_range)
ge_match = re.match('>=(\d+)$', version_range)
lt_match = re.match('<(\d+)$', version_range)
le_match = re.match('<=(\d+)$', version_range)
range_match = re.match('(\d+) - (\d+)$', version_range)
if gt_match:
min_version = int(gt_match.group(1)) + 1
elif ge_match:
min_version = int(ge_match.group(1))
elif lt_match:
max_version = int(lt_match.group(1)) - 1
elif le_match:
max_version = int(le_match.group(1))
elif range_match:
min_version = int(range_match.group(1))
max_version = int(range_match.group(2))
else:
return None
if min_version > int(sublime.version()):
return False
if max_version < int(sublime.version()):
return False
return True
def run(self):
self.window.run_command('hide_panel');
if int(sublime.version()) >= 2136:
self.window.run_command("show_panel", {"panel": "find_in_files", "where":"<open folders>"})
elif int(sublime.version()) >= 2134:
self.window.run_command("show_panel", {"panel": "find_in_files", "where":""})
else:
self.window.run_command("show_panel", {"panel": "find_in_files", "location":"<open folders>"})
def __init__(me, cmd, env, listener, path="", shell=False):
threading.Thread.__init__(me, name="cssondiet")
me.finished = False
me.exitcode = 0
me.listener = listener
output = None
try:
idx = cmd.index("-o")
output = cmd[idx+1]
except:
output = False
minify = "-m" in cmd
inputfile = cmd[-1]
if output == False or output == inputfile:
output = inputfile+".css"
class an_argument(object):
def __init__(me, input, output="-", minify=False ):
me.cod_files = [ input ]
me.output = output
me.no_comments = False
me.no_header = False
me.minify_css = minify
me.args = an_argument( inputfile, output, minify )
print("Actually running embedded COD script with inputfile=%s, " \
"output=%s, minify=%s from %s package\n" % \
( inputfile, output, str(minify), PACKAGeDIR) )
me.start_time = time.time()
try:
if sublime.version()[0] == "2":
script_dir = os.path.join( sublime.packages_path(), PACKAGeDIR )
#me.read_stderr("script_dir: %s\n" % script_dir )
fp, pathname, description = imp.find_module("cod", [ script_dir ] )
try:
me.cod_module = imp.load_module("cod", fp, pathname, description)
finally:
if fp:
fp.close()
elif sublime.version()[0] == "3":
sublimemodule = __import__("CSS-On-Diet")
me.cod_module = sublimemodule.cod
except ImportError:
me.read_stderr("[Error loading embedded COD preprocessor]\n")
me.finished = True
if me.listener:
me.listener.on_finished(me)
return
me.start()
def get_pygments(style):
"""
Get pygments style.
Subllime CSS support is limited. It cannot handle well
things like: `.class1 .class2`, but it can handle things like:
`.class1.class2`. So we will not use things like `.highlight` in front.
We will first find {...} which has no syntax class. This will contain
our background and possibly foreground. If for whatever reason we
have no background or foreground, we will use `#000000` or `#ffffff`
respectively.
"""
try:
# Lets see if we can find the pygments theme
text = HtmlFormatter(style=style).get_style_defs(".dummy")
text = re_missing_semi_colon.sub("; }", text)
except Exception:
return ""
bg = None
fg = None
# Find {...} which has no syntax classes
m = re_base_colors.search(text)
if m:
# Find background
m1 = re_bgcolor.search(m.group(1))
if m1:
# Use `background-color` as it works better
# with Sublime CSS
bg = m1.group(1).replace("background", "background-color")
# Find foreground
m1 = re_color.search(m.group(1))
if m1:
fg = m1.group(1)
# Use defaults if None found
if bg is None:
bg = "background-color: #ffffff"
if fg is None:
fg = "color: #000000"
# Reassemble replacing .highlight {...} with .codehilite, .inlinehilite {...}
# All other classes will be left bare with only their syntax class.
code_blocks = CODE_BLOCKS_LEGACY if int(sublime.version()) < 3119 else CODE_BLOCKS
if m:
css = clean_css((text[: m.start(0)] + (code_blocks % (bg, fg)) + text[m.end(0) :] + "\n"))
else:
css = clean_css(((code_blocks % (bg, fg)) + "\n" + text + "\n"))
if int(sublime.version()) < 3119:
return css.replace(".dummy ", "")
else:
return re_pygments_selectors.sub(r".mdpopups .highlight \1, .mdpopups .inline-highlight \1", css)
def __init__(self, s):
self.package = s['package']
self.output = s['output'] if 'output' in s else None
if 'syntax_test' in s and sublime.version() >= "3000":
self.syntax_test = s['syntax_test']
else:
self.syntax_test = False
if 'coverage' in s and sublime.version() >= "3103":
self.coverage = s['coverage']
else:
self.coverage = False
def run(self, edit):
view = self.view
window = sublime.active_window()
if(int(sublime.version()) >= 3000):
# ST3 - use project data
project_data = window.project_data()
utils = _projectPHPClassUtils( project_data.get('folders')[0].get('path') )
else:
utils = _projectPHPClassUtils( window.folders()[0] )
if( utils.is_browser_view(view) != True ):
return
point = view.sel()[0]
if(point.begin() == point.end()):
return
window.focus_view(view)
word = view.substr(view.word(point))
line = view.substr(view.line(point))
methodname = None
if( line.startswith('\t') or re.match('\s+', line, re.IGNORECASE) ):
methodname = word
regionbefore = sublime.Region(0,point.end())
lineregions = view.split_by_newlines(regionbefore)
clindex = len( lineregions ) - 1
# for lineregion in lineregions:
classname = None
while( classname == None and clindex >= 0 ):
line = view.substr(lineregions[clindex])
clindex -= 1
if(line.startswith('\t') == False and not re.match('\s+', line, re.IGNORECASE) ):
classname = line
else:
classname = word
classname = classname.split('\n')[0].strip()
if(len(classname)>0):
try:
if(utils.get_num_panels() == 2):
if(view.name() == 'PHP Class Methods'):
# in methods view. open file definition
self._open_file_definition(window, utils, classname, methodname)
else:
# in classes view. update methods view
methodview = utils.find_methods_view()
rootPath = window.folders()[0]
if(int(sublime.version()) >= 3000):
project_data = window.project_data()
rootPath = project_data.get('folders')[0].get('path')
args = {"rootPath" : rootPath, "group": 2, "classname": classname}
methodview.run_command("fill_browser_view", { "args": args })
else:
# all in one... go, go, go!
self._open_file_definition(window, utils, classname, methodname)
except:
sublime.status_message('Unknown Class Name: '+str(classname))
def is_visible(self):
st_version = 2
# Warn about out-dated versions of ST3
if sublime.version() == '':
st_version = 3
print('Package Control: Please upgrade to Sublime Text 3 build 3012 or newer')
elif int(sublime.version()) > 3000:
st_version = 3
if st_version == 3 :
return False
return True
def sanity_check(env={}, error_log=False):
if not env:
env = sh.env()
ns = '(not set)'
sl = [
('install state', _inst_state()),
('sublime.version', sublime.version()),
('sublime.channel', sublime.channel()),
('about.ann', gs.attr('about.ann', '')),
('about.version', gs.attr('about.version', '')),
('version', about.VERSION),
('platform', about.PLATFORM),
('~bin', '%s' % gs.home_dir_path('bin')),
('margo.exe', '%s (%s)' % _tp(_margo_bin())),
('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')),
('go.version', sh.GO_VERSION),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
('set.shell', str(gs.lst(gs.setting('shell')))),
('env.shell', env.get('SHELL', '')),
('shell.cmd', str(sh.cmd('${CMD}'))),
]
if error_log:
try:
with open(gs.home_path('log.txt'), 'r') as f:
s = f.read().strip()
sl.append(('error log', s))
except Exception:
pass
return sl
def run_shell_command(self, command, working_dir):
if not command:
return False
if BEFORE_CALLBACK:
os.system(BEFORE_CALLBACK)
if AFTER_CALLBACK:
command += " ; " + AFTER_CALLBACK
self.save_test_run(command, working_dir)
if COMMAND_PREFIX:
command = COMMAND_PREFIX + ' ' + command
if int(sublime.version().split('.')[0]) <= 2:
command = [command]
if USE_TERMINAL:
trm=OpenInTerminal()
trm.run(working_dir, command)
else:
self.view.window().run_command("exec", {
"cmd": command,
"shell": True,
"working_dir": working_dir,
"file_regex": r"([^ ]*\.rb):?(\d*)",
"encoding": TERMINAL_ENCODING
})
self.display_results()
return True
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 prepare_data(self, view, data):
"""Prepare the returned data
"""
st_version = int(sublime.version())
show_tooltip = get_settings(view, 'enable_signatures_tooltip', True)
show_doc = get_settings(view, 'merge_signatures_and_doc', True)
if data['success'] and 'No docstring' not in data['doc']:
if show_tooltip and show_doc and st_version >= 3070:
self.doc = '<br>'.join(data['doc'].split('<br>')[2:])
if not show_tooltip or st_version < 3070:
self.signature = data['doc'].splitlines()[2]
else:
self.signature = data['doc'].split('<br>')[0]
if ('(' in self.signature and
self.signature.split('(')[0].strip() not in self.exclude):
if self.signature is not None and self.signature != '':
if show_tooltip:
return self._show_popup(view)
return self._show_status(view)
if st_version >= 3070:
if view.is_popup_visible():
view.hide_popup()
view.erase_status('anaconda_doc')
def is_enabled(self):
try:
import mdpopups
except Exception:
return False
return (mdpopups.version() >= (1, 7, 3)) and (int(sublime.version()) >= 3118)
def sublime_text_3():
"""Returns True if this is Sublime Text 3
"""
try:
return int(sublime.version()) >= 3000
except ValueError:
return sys.hexversion >= 0x030000F0
def read_package_file(package, relative_path, binary=False):
"""
Reads the contents of a file that is part of a package
:param package:
The name of the package to read from
:param relative_path:
The path to the file, relative to the package root
:param binary:
If the contents should be read as a byte string instead of a unicode string
:return:
A unicode or byte string (depending on value if binary param) or False on error
"""
if relative_path is None:
return False
package_dir = _get_package_dir(package)
if os.path.exists(package_dir) and _regular_file_exists(package, relative_path):
return _read_regular_file(package, relative_path, binary)
if int(sublime.version()) >= 3000:
result = _read_zip_file(package, relative_path, binary)
if result is not False:
return result
return False
def package_file_exists(package, relative_path):
"""
Determines if a file exists inside of the package specified. Handles both
packed and unpacked packages.
:param package:
The name of the package to look in
:param relative_path:
The path to the file, relative to the package root
:return:
A bool - if the file exists
"""
if relative_path is None:
return False
package_dir = _get_package_dir(package)
if os.path.exists(package_dir):
result = _regular_file_exists(package, relative_path)
if result:
return result
if int(sublime.version()) >= 3000:
return _zip_file_exists(package, relative_path)
return False
def list_packages(self, unpacked_only=False):
"""
:param unpacked_only:
Only list packages that are not inside of .sublime-package files
:return: A list of all installed, non-default, package names
"""
package_names = os.listdir(sublime.packages_path())
package_names = [path for path in package_names if
os.path.isdir(os.path.join(sublime.packages_path(), path))]
if int(sublime.version()) > 3000 and unpacked_only == False:
package_files = os.listdir(sublime.installed_packages_path())
package_names += [f.replace('.sublime-package', '') for f in package_files if re.search('\.sublime-package$', f) != None]
# Ignore things to be deleted
ignored = ['User']
for package in package_names:
cleanup_file = os.path.join(sublime.packages_path(), package,
'package-control.cleanup')
if os.path.exists(cleanup_file):
ignored.append(package)
packages = list(set(package_names) - set(ignored) -
set(self.list_default_packages()))
packages = sorted(packages, key=lambda s: s.lower())
return packages
def run(self):
self.old_view = ng.active_view()
try:
self.definition_List = ng.get_current_project_indexes().get('definitions')
except:
self.definition_List = None
if ng.is_indexing:
return
if not self.definition_List:
ng.active_window().run_command('angularjs_file_index')
return
self.current_window = ng.active_window()
self.current_view = ng.active_view()
self.current_file = self.current_view.file_name()
self.current_file_location = self.current_view.sel()[0].end()
formated_definition_list = []
for item in self.definition_List:
current_definition = [
item[0],
[item[1].replace(path,'') for path in ng.active_window().folders()][0][1:]
]
formated_definition_list.append(current_definition);
if int(sublime.version()) >= 3000 and ng.settings.get('show_file_preview'):
self.current_window.show_quick_panel(formated_definition_list, self.on_done, False, -1, self.on_highlight)
else:
self.current_window.show_quick_panel(formated_definition_list, self.on_done)
def underline_regions(self, view, scope_name, regions):
if sublime.version() >= '3019':
# in Sublime Text 3, the regions are just underlined
flags = (
sublime.DRAW_NO_FILL |
sublime.DRAW_NO_OUTLINE |
sublime.DRAW_SOLID_UNDERLINE
)
view.add_regions(
SCOPE_PREFIX + scope_name,
regions,
scope_name,
flags=flags
)
else:
# in Sublime Text 2, the 'empty region underline' hack is used
char_regions = [
sublime.Region(pos, pos)
for region in regions
for pos in range(region.a, region.b)
]
view.add_regions(
SCOPE_PREFIX + scope_name,
char_regions,
scope_name,
sublime.DRAW_EMPTY_AS_OVERWRITE)
def _on_done():
buf = StringIO()
for item in results:
tabulate(item, output=buf)
new_view = sublime.active_window().new_file()
new_view.set_scratch(True)
new_view.settings().set('word_wrap', False)
new_view.settings().set('line_numbers', False)
new_view.settings().set('gutter', False)
new_view.set_name('LaTeXTools System Check')
if sublime.version() < '3103':
new_view.settings().set(
'syntax',
'Packages/LaTeXTools/system_check.hidden-tmLanguage'
)
else:
new_view.settings().set(
'syntax', 'Packages/LaTeXTools/system_check.sublime-syntax'
)
new_view.set_encoding('UTF-8')
new_view.run_command(
'latextools_insert_text',
{'text': buf.getvalue().rstrip()}
)
new_view.set_read_only(True)
buf.close()
def __init__(self):
if int(sublime.version()) < 4050:
self._is_overlay_panel = self._is_overlay_panel_heuristic
self._overlay_panel_open = False
self._zip_view_awaiting_panel_close = None
def is_ST2():
return sublime.version().startswith('2')
'cli': '--jsx-bracket-same-line',
'default': 'false'
}, {
'option': 'parser',
'cli': '--parser',
'default': 'babylon'
}, {
'option': 'semi',
'cli': '--semi',
'default': 'true'
}]
ALLOWED_FILE_EXTENSIONS = [
'js',
'jsx',
]
IS_SUBLIME_TEXT_LATEST = int(sublime.version()) >= 3000
class JsPrettierCommand(sublime_plugin.TextCommand):
_error_message = None
@property
def debug(self):
return self.get_setting('debug', False)
@property
def has_error(self):
if not self._error_message:
return False
return True
def is_st3():
return sublime.version()[0] == '3'
from collections import defaultdict, deque
try:
import sublime
import sublime_plugin
from sublime import status_message, error_message
except ImportError: # running tests
import sys
from tests.sublime_fake import sublime
from tests.sublime_fake import sublime_plugin
sys.modules['sublime'] = sublime
sys.modules['sublime_plugin'] = sublime_plugin
if sublime.version().startswith('2'):
import ctags
from ctags import (FILENAME, parse_tag_lines, PATH_ORDER, SYMBOL,
TagElements, TagFile)
from helpers.edit import Edit
else: # safe to assume if not ST2 then ST3
from CTags import ctags
from CTags.ctags import (FILENAME, parse_tag_lines, PATH_ORDER, SYMBOL,
TagElements, TagFile)
from CTags.helpers.edit import Edit
"""
Contants
"""
OBJECT_PUNCTUATORS = {
'class': '.',
import sublime, sublime_plugin, time, os.path, json, threading, sys, socket, time
from threading import Thread
try:
import socketserver
except ImportError:
import SocketServer as socketserver
VERSION = "Takana plugin v0.4"
DEBUG = False
TAKANA_SERVER_PORT = 48628
st_ver = 3000 if sublime.version() == '' else int(sublime.version())
print("***************************************")
print(VERSION)
class Error:
region_key = 'error_dot'
def __init__(self, file, line):
self.file = file
self.line = line
self.view = None
def update_view(self, view):
self.clear()
self.view = view
self.show()
def show(self):
# coding: utf-8
import sublime
import sys
import os
st_version = 2
if sublime.version() == '':
st_version = 3
print('Joomla Pack: Please upgrade to Sublime Text 3 build 3012 or newer')
elif int(sublime.version()) > 3000:
st_version = 3
if st_version == 3:
installed_dir, _ = __name__.split('.')
elif st_version == 2:
installed_dir = os.path.basename(os.getcwd())
# Ensure the user has installed Joomla Pack properly
if installed_dir != 'JoomlaPack':
message = ("Joomla Pack\n\nThis package appears to be installed " +
"incorrectly.\n\nIt should be installed as \"JoomlaPack\", " +
"but seems to be installed as \"%s\".\n\n" % installed_dir)
# If installed unpacked
if os.path.exists(os.path.join(sublime.packages_path(), installed_dir)):
message += ("Please use the Preferences > Browse Packages... menu " +
"entry to open the \"Packages/\" folder and rename" +
"\"%s/\" to \"JoomlaPack/\" " % installed_dir)
# If installed as a .sublime-package file
else:
message += ("Please use the Preferences > Browse Packages... menu " +
import sublime
import sublime_plugin
DEFAULT_MAX_FILE_SIZE = 1048576
DEFAULT_COLOR_SCOPE_NAME = "invalid"
DEFAULT_IS_ENABLED = True
DEFAULT_CHECK_SPACES = True
DEFAULT_SINGLE_SPACE = False
DEFAULT_CHECK_EOL = True
DEFAULT_CHECK_TABS = True
DEFAULT_CHECK_MIXED = True
DEFAULT_LAST_WHITESPACE = False
hws_toggled = False
hws_v3 = (int(sublime.version()) >= 3000)
def plugin_loaded():
global hws_v3
if is_enabled(True) and hws_v3:
highlight_whitespaces(sublime.active_window().active_view())
def is_enabled(init=False):
global hws_toggled
if init:
hws_toggled = bool(get_settings().get('highlight_whitespaces_enabled',
DEFAULT_IS_ENABLED))
if os.path.isfile(file_path):
os.remove(file_path)
sublime.save_settings("Package Syncing.sublime-settings")
sublime.status_message(
"sync_folder successfully set to \"%s\"" % path)
#
sublime.run_command("pkg_sync", {
"mode": ["pull", "push"],
"override": override
})
else:
sublime.error_message("Invalid Path %s" % path)
self.window.show_input_panel("Sync Folder", sync_folder, on_done, None,
None)
def plugin_loaded():
sublime.set_timeout(
lambda: sublime.run_command("pkg_sync", {"mode": ["pull", "push"]}),
2000)
def plugin_unloaded():
tools.stop_watcher()
if sublime.version()[0] == "2":
plugin_loaded()
import sublime
import sublime_plugin
###----------------------------------------------------------------------------
st_version = int(sublime.version())
###----------------------------------------------------------------------------
class OverrideAuditOpenFileCommand(sublime_plugin.WindowCommand):
"""
A proxy for the default open_file command that will hide itself from the
menu/command palette in newer versions of Sublime Text.
"""
def run(self, **kwargs):
self.window.run_command("open_file", kwargs)
def is_visible(self, file, contents=None):
return st_version < 3124
###----------------------------------------------------------------------------
class OverrideAuditEditSettingsCommand(sublime_plugin.WindowCommand):
"""
A proxy for the default edit_settings command that will hide itself from
from __future__ import print_function
import sublime
import sublime_plugin
import re
if sublime.version() < '3000':
_ST3 = False
else:
_ST3 = True
SECTION_TYPES = ['part', 'chapter', 'section', 'subsection',
'subsubsection', 'paragraph', 'subparagraph']
def get_begin_mark_patter(sec_type):
return r'\\' + sec_type + r'\*?(?:\[.*\])?\{.*\}(?:\s*%\s\(fold\))?'
def get_end_mark_patter(sec_type):
return r'%\s*' + sec_type + r'.*\s*\(end\)'
# Find top level's mark name in this buffer
# return None if find failed
def find_top_level(view):
top_level = None
for i in SECTION_TYPES:
regions = view.find_all(get_begin_mark_patter(i))
if len(regions) == 0:
continue
else:
top_level = i
break
return top_level
def load(self):
if not sublime.version().startswith('3'):
raise Exception("Not Sublime 3!")
import zipfile
PACKAGE_NAME = 'SublimeTmpl'
TMLP_DIR = 'templates'
KEY_SYNTAX = 'syntax'
KEY_FILE_EXT = 'extension'
BASE_PATH = os.path.abspath(
os.path.dirname(__file__)) #Installed Packages/xx.sublime-package
PACKAGES_PATH = sublime.packages_path() # for ST2
# sys.path += [BASE_PATH]
# sys.path.append(BASE_PATH)
# import sys;print(sys.path)
IS_GTE_ST3 = int(sublime.version()[0]) >= 3
class SublimeTmplCommand(sublime_plugin.TextCommand):
def run(self, edit, type='html'):
view = self.view
opts = self.get_settings(type)
tmpl = self.get_code(type)
# print(KEY_SYNTAX in opts)
self.tab = self.creat_tab(view)
self.set_syntax(opts)
self.set_code(tmpl)
def get_settings(self, type=None):
def generate_colour_scheme(self, view, generate=True):
# make sure we have hex AND we're >= ST3 (load_resource doesn't work in ST2)
colour_removed = sbs_settings().get('remove_colour', 'invalid.illegal')
colour_added = sbs_settings().get('add_colour', 'string')
colour_modified_deletion = sbs_settings().get(
'modified_colour_deletion', 'support.class')
colour_modified_addition = sbs_settings().get(
'modified_colour_addition', 'support.class')
colour_unmodified_deletion = sbs_settings().get(
'unmodified_colour_deletion', 'invalid.illegal')
colour_unmodified_addition = sbs_settings().get(
'unmodified_colour_addition', 'string')
colour_text = sbs_settings().get('text_colour', '')
notHex = False
for col in [
colour_removed, colour_added, colour_modified_deletion,
colour_modified_addition, colour_unmodified_deletion,
colour_unmodified_addition
]:
if not '#' in col:
notHex = True
if int(sublime.version()) < 3000 or notHex:
return {
'removed': colour_removed,
'added': colour_added,
'modified_deletion': colour_modified_deletion,
'modified_addition': colour_modified_addition,
'unmodified_deletion': colour_unmodified_deletion,
'unmodified_addition': colour_unmodified_addition
}
# generate theme strings
colourStrings = {}
colourHexes = {}
for col in [['removed', colour_removed], ['added', colour_added],
['modified_deletion', colour_modified_deletion],
['modified_addition', colour_modified_addition],
['unmodified_deletion', colour_unmodified_deletion],
['unmodified_addition', colour_unmodified_addition]]:
colourStrings[col[0]] = 'comparison.' + col[0]
colourHexes[col[0]] = col[1]
# generate modified theme
if generate:
# load current scheme
current_scheme = view.settings().get('color_scheme') # no 'u' >:(
try:
scheme = sublime.load_resource(current_scheme)
except:
# sometimes load_resource can fail (seemingly on OSX when upgrading from ST2->ST3)
# manually re-selecting the colour scheme once should fix this for good (see issue #31)
sublime.message_dialog(
'Could not load colour scheme.\nFalling back to a blank colour scheme.\n\nTo fix this, please manually re-select your colour scheme in\n\tPreferences > Color Scheme\n\nThis should not happen again once action has been taken.\nSorry for the inconvenience.'
)
scheme = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>settings</key><array></array></dict></plist>'
# determine if scheme is using the new .sublime-color-scheme json format
scheme_json = False
try:
scheme = sublime.decode_value(scheme)
scheme_json = True
except:
scheme_json = False
# create format specific data
if scheme_json:
for name in colourStrings:
string = colourStrings[name]
chex = colourHexes[name]
scheme['rules'].append({
"name": name,
"scope": string,
"background": chex,
"foreground": colour_text
})
data = json.dumps(scheme)
else:
xml = ''
xml_tmpl = '<dict><key>name</key><string>{}</string><key>scope</key><string>{}</string><key>settings</key><dict><key>background</key><string>{}</string><key>foreground</key><string>{}</string></dict></dict>'
dropzone = scheme.rfind('</array>')
# loop through colours and generate their xml
for name in colourStrings:
string = colourStrings[name]
chex = colourHexes[name]
xml += xml_tmpl.format('Comparison ' + name, string, chex,
colour_text)
# combiiiiiiiiiiiiine
data = scheme[:dropzone] + xml + scheme[dropzone:]
# determine theme filename
# relative for settings, absolute for writing to file
# replacing slashes for relative path necessary on windows
# completely separate filenames are necessary to avoid json erroneously taking precedence
theme_name = 'SBSCompareTheme.tmTheme'
if scheme_json:
theme_name = 'SBSCompareScheme.sublime-color-scheme'
abs_theme_file = os.path.join(sublime.packages_path(), 'User',
theme_name)
rel_theme_file = os.path.join(
os.path.basename(sublime.packages_path()), 'User', theme_name)
rel_theme_file = rel_theme_file.replace('\\', '/')
# save new theme
try:
with open(abs_theme_file, 'w', encoding='utf-8') as f:
f.write(data)
except:
sublime.message_dialog(
'Could not write theme file.\nPlease ensure that your Sublime config directory is writeable and restart Sublime.\n\nFull path:\n'
+ abs_theme_file)
# save filename for later use (if we rerun this without regenerating)
self.last_theme_file = rel_theme_file
# set view settings to use new theme
view.settings().set('color_scheme', self.last_theme_file)
return colourStrings
# -*- coding: UTF-8 -*-
import errno
import sublime
import sublime_plugin
if int(sublime.version()) < 3000:
from sublime_haskell_common import is_enabled_haskell_command, call_and_wait_with_input, SublimeHaskellTextCommand
else:
from SublimeHaskell.sublime_haskell_common import is_enabled_haskell_command, call_and_wait_with_input, SublimeHaskellTextCommand
class SublimeHaskellStylish(SublimeHaskellTextCommand):
def run(self, edit):
try:
regions = []
for region in self.view.sel():
regions.append(sublime.Region(region.a, region.b))
if region.empty():
selection = sublime.Region(0, self.view.size())
else:
selection = region
sel_str = self.view.substr(selection).replace('\r\n', '\n')
exit_code, out, err = call_and_wait_with_input(
['stylish-haskell'], sel_str)
out_str = out.replace('\r\n', '\n')
if exit_code == 0 and out_str != sel_str:
self.view.replace(edit, selection, out_str)
self.view.sel().clear()
for region in regions:
import sublime
import os
import sys
if sublime.platform() == 'linux' and '3000' > sublime.version() > '2000':
path = os.path.join(sublime.packages_path(), 'Codecs26', 'lib')
if path not in sys.path:
sys.path.append(path)
else:
print('Warning: Codecs26 is working for Sublime Text 2 on linux only')
# -*- coding: utf-8 -*-
import os.path
import sublime
import sublime_plugin
STVER = int(sublime.version())
ST3 = STVER >= 3000
def get(key, default=None):
"""Get a value from GitGutter.sublime-settings.
This function provides secure access to the package settings by loading
the settings file on demand.
Arguments:
key (string): The setting to read.
default (any): The value to return if 'key' is not available.
Returns:
any: The value from settings file if loaded and key exists or the
default value provided from the caller.
"""
try:
settings = get.settings
except AttributeError:
settings = sublime.load_settings('GitGutter.sublime-settings')
get.settings = settings
return settings.get(key, default)
deleted = delete_trailing_regions(self.view, edit)
if deleted:
if ts_settings.get("trailing_spaces_save_after_trim") \
and not ts_settings.get("trailing_spaces_trim_on_save"):
sublime.set_timeout(lambda: self.save(self.view), 10)
msg_parts = {
"nbRegions": deleted,
"plural": 's' if deleted > 1 else ''
}
message = "Deleted %(nbRegions)s trailing spaces region%(plural)s" % msg_parts
else:
message = "No trailing spaces to delete!"
sublime.status_message(message)
def save(self, view):
if view.file_name() is None:
view.run_command('prompt_save_as')
else:
view.run_command('save')
# ST3 features a plugin_loaded hook which is called when ST's API is ready.
#
# We must therefore call our init callback manually on ST2. It must be the last
# thing in this plugin (thanks, beloved contributors!).
if not int(sublime.version()) > 3000:
plugin_loaded()
# -*- coding: utf-8 -*-
import sublime_plugin
import sublime
import re
import webbrowser
from itertools import chain
from .hyper_click.path_resolver import HyperClickPathResolver
ST3118 = int(sublime.version()) >= 3118
if ST3118:
class HyperClickAnnotator(sublime_plugin.ViewEventListener):
@classmethod
def is_applicable(cls, settings):
syntax = settings.get('syntax', None)
if not syntax:
return False
plugin_settings = sublime.load_settings(
'hyper_click.sublime-settings')
annotations_enabled = plugin_settings.get('annotations_enabled')
if not annotations_enabled:
return False
supported_syntaxes = plugin_settings.get('supported_syntaxes')
aggregated_systaxes = list(
chain.from_iterable(supported_syntaxes.values()))
for s in aggregated_systaxes:
if syntax.endswith(s):
return True
return False
'stippled_underline': sublime.DRAW_STIPPLED_UNDERLINE | UNDERLINE_FLAGS,
'none': sublime.HIDDEN
}
UNDERLINE_STYLES = (
'solid_underline', 'squiggly_underline', 'stippled_underline'
)
SOME_WS = re.compile(r'\s')
FALLBACK_MARK_STYLE = 'outline'
WS_ONLY = re.compile(r'^\s+$')
MULTILINES = re.compile('\n')
# Sublime > 4074 supports underline styles on white space
# https://github.com/sublimehq/sublime_text/issues/137
SUBLIME_SUPPORTS_WS_SQUIGGLES = int(sublime.version()) > 4074
State = {
'active_view': None,
'current_sel': tuple(),
'idle_views': set(),
'quiet_views': set(),
'views': set()
} # type: State_
def plugin_loaded():
State.update({
'active_view': sublime.active_window().active_view(),
'idle_views': set()
})
import sublime
import sublime_plugin
import re
import sys
import collections
ST3 = sublime.version() >= '3000'
try:
from . import inflection
except ValueError: # HACK: for ST2 compatability
import inflection
# SECTION: FUNCTIONS WITHOUT SIDE EFFECTS THAT ARE USED TO COMPOSE COMMANDS
def isa(*types):
return lambda x: isinstance(x, types)
iterable = isa(collections.Iterable)
def offset_region(region, offset):
return sublime.Region(region.a + offset, region.b + offset)
def order_regions(regions):
order = lambda r: (r.begin(), r.end())
return sorted(regions, key=order)
# coding:utf-8
# import os
import re
import sublime
from unittest import TestCase
VERSION = sublime.version()
class TestBase(TestCase):
"""Super class includes common settings and functions. This class doesn't include any tests."""
def setUp(self):
self.view = sublime.active_window().new_file()
# make sure we have a window to work with
s = sublime.load_settings("Preferences.sublime-settings")
s.set("close_windows_when_empty", False)
def tearDown(self):
if self.view:
# close file
self.view.set_scratch(True)
self.view.window().focus_view(self.view)
self.view.window().run_command("close_file")
# -----
def setText(self, string):
self.view.run_command("insert", {"characters": string})
def getRow(self, row):
return self.view.substr(self.view.line(self.view.text_point(row, 0)))
import sys
import sublime
if int(sublime.version()) >= 3114:
__all__ = ["AfiRevertCommand", "plugin_loaded", "plugin_unloaded"]
# Clear module cache to force reloading all modules of this package.
prefix = __package__ + "." # don't clear the base package
for module_name in [
module_name for module_name in sys.modules
if module_name.startswith(prefix) and module_name != __name__
]:
del sys.modules[module_name]
prefix = None
from .core.cleaning import AfiRevertCommand, clean_all
from .core.settings import add_listener, clear_listener
from .core.utils.overlay import disable_overlay, enable_overlay
def plugin_loaded():
def plugin_loaded_async():
add_listener()
enable_overlay()
sublime.set_timeout_async(plugin_loaded_async)
def plugin_unloaded():
is_upgrading = False
was_removed = False
// Auto add extensions to language settings file in User folder.
// Do not manually remove "apply_syntax_extensions" from the settings file.
// "extenstions" are ignored by "match": "all" setting.
"add_exts_to_lang_settings": true,
// Control level of logging in the console.
// (true|false|"verbose")
"debug": true,
// Put your custom syntax rules here:
"syntaxes": [
]
}
'''
USE_ST_SYNTAX = int(sublime.version()) >= 3084
PLUGIN_NAME = 'ApplySyntax'
PLUGIN_DIR = "Packages/%s" % PLUGIN_NAME
PLUGIN_SETTINGS = PLUGIN_NAME + '.sublime-settings'
EXT_SETTINGS = PLUGIN_NAME + ".ext-list"
ST_LANGUAGES = ('.sublime-syntax', '.tmLanguage') if USE_ST_SYNTAX else ('.tmLanguage',)
SETTINGS = {}
LANG_HASH = 0
# Call back for whether view(s) have been touched
on_touched_callback = None
def ensure_user_settings():
"""Create a default 'User' settings file for ApplySyntax if it doesn't exist."""
import sublime
import sublime_plugin
try:
from .format_date import FormatDate, UnknownTimeZoneError # ST3
except ValueError:
from format_date import FormatDate, UnknownTimeZoneError # ST2
ST2 = int(sublime.version()) < 3000
if not ST2:
basestring = str
# Global variables
fdate = FormatDate()
# Global settings object
s = None
# Print tracebacks
DEBUG = False
def status(msg, e=None):
msg = "[InsertDate] " + msg
sublime.status_message(msg)
if e is not None:
msg += "\n%s: %s" % (type(e).__name__, e)
print(msg)
if e and DEBUG:
import traceback
traceback.print_exc()
import sublime
from unittest import TestCase
version = sublime.version()
class TestJSExamples(TestCase):
def setUp(self):
self.view = sublime.active_window().new_file()
# make sure we have a window to work with
s = sublime.load_settings("Preferences.sublime-settings")
s.set("close_windows_when_empty", False)
def tearDown(self):
if self.view:
self.view.set_scratch(True)
self.view.window().run_command("close_file")
def setText(self, string):
self.view.run_command("insert", {"characters": string})
def goToLine(self, line):
self.view.run_command("goto_line", {"line": line})
def getRow(self, row):
return self.view.substr(
self.view.line(self.view.text_point(row - 1, 0)))
def test_align_js1(self):
string = """var x = {
foo: "hello",
# ST2/ST3 compat
from __future__ import print_function
import sublime
if sublime.version() < '3000':
# we are on ST2 and Python 2.X
_ST3 = False
import getTeXRoot
import parseTeXlog
from latextools_plugin import (add_plugin_path, get_plugin,
NoSuchPluginException,
_classname_to_internal_name)
from latextools_utils.is_tex_file import is_tex_file
from latextools_utils import get_setting
from latextools_utils.tex_directives import parse_tex_directives
from latextools_utils.external_command import (execute_command,
external_command,
get_texpath, update_env)
from latextools_utils.output_directory import (get_aux_directory,
get_output_directory,
get_jobname)
from latextools_utils.progress_indicator import ProgressIndicator
from latextools_utils.sublime_utils import (get_project_file_name,
parse_json_with_comments)
from latextools_utils.utils import run_on_main_thread
strbase = basestring
else:
_ST3 = True
from . import getTeXRoot
from . import parseTeXlog
import os
import json
import re
import shutil
import codecs
import string
import random
import MavensMate.config as config
import MavensMate.lib.apex.apex_extensions as apex_extensions
import sublime
import subprocess
from xml.dom.minidom import parse
settings = sublime.load_settings('mavensmate.sublime-settings')
packages_path = sublime.packages_path()
sublime_version = int(float(sublime.version()))
debug = config.debug
def standard_object_names():
return [
"Account", "Opportunity", "Contact", "Lead", "Pricebook2", "Product"
]
def get_friendly_platform_key():
friendly_platform_map = {
'darwin': 'osx',
'win32': 'windows',
'linux2': 'linux',
import re
import time
# Modules for expression evaluation
import math
import random
import sublime
import sublime_plugin
# Compatability
ST3 = int(sublime.version()) > 3000
if ST3:
basestring = str
module_name = "Insert Nums"
# Utility functions ####################
def int_or_float(value):
try:
return int(value) if value is not None else None
except ValueError:
return float(value)
def num_to_alpha(num, length=0):
res = ''
def create_comparison(view1_contents,
view2_contents,
syntax,
name1_override=False,
name2_override=False):
view1_syntax = syntax
view2_syntax = syntax
# make new window
active_window.run_command('new_window')
new_window = sublime.active_window()
new_window.set_layout({
"cols": [0.0, 0.5, 1.0],
"rows": [0.0, 1.0],
"cells": [[0, 0, 1, 1], [1, 0, 2, 1]]
})
if int(sublime.version()) >= 3000:
if sbs_settings().get('hide_sidebar', False):
new_window.set_sidebar_visible(False)
if sbs_settings().get('hide_menu', False):
new_window.set_menu_visible(False)
if sbs_settings().get('hide_minimap', False):
new_window.set_minimap_visible(False)
if sbs_settings().get('hide_status_bar', False):
new_window.set_status_bar_visible(False)
if sbs_settings().get('hide_tabs', False):
new_window.set_tabs_visible(False)
else:
if sbs_settings().get('hide_sidebar', False):
new_window.run_command('toggle_side_bar')
if sbs_settings().get('hide_menu', False):
new_window.run_command('toggle_menu')
# view names
view_prefix = sbs_settings().get('display_prefix', '')
view2_name = name2_override
view1_name = 'untitled'
if active_view.file_name():
view1_name = active_view.file_name()
elif active_view.name():
view1_name = active_view.name()
if name1_override != False:
view1_name = name1_override
name1base = os.path.basename(view1_name)
name2base = os.path.basename(view2_name)
if name1base == name2base:
dirname1 = os.path.dirname(view1_name)
dirname2 = os.path.dirname(view2_name)
path_prefix = os.path.commonprefix([dirname1, dirname2])
if path_prefix != '':
path_prefix = path_prefix.replace('\\', '/')
path_prefix = path_prefix.split(
'/')[:-1] # leave last directory in path
path_prefix = '/'.join(path_prefix) + '/'
plen = len(path_prefix)
dirname1 = dirname1[plen:]
dirname2 = dirname2[plen:]
separator = ' - '
if int(sublime.version()) >= 3000:
separator = ' — '
view1_name = name1base + separator + dirname1
view2_name = name2base + separator + dirname2
if dirname1 == dirname2:
view1_name = name1base
view2_name = name2base
else:
view1_name = name1base
view2_name = name2base
view1_name += ' (active)'
view2_name += ' (other)'
# view 1
new_window.run_command('new_file')
new_window.run_command('insert_view', {'string': view1_contents})
new_window.active_view().set_syntax_file(view1_syntax)
new_window.active_view().set_name(view_prefix + view1_name)
new_window.active_view().set_scratch(True)
view1 = new_window.active_view()
# view 2
new_window.run_command('new_file')
new_window.run_command('insert_view', {'string': view2_contents})
new_window.active_view().set_syntax_file(view2_syntax)
new_window.active_view().set_name(view_prefix + view2_name)
# move view 2 to group 2
new_window.set_view_index(new_window.active_view(), 1, 0)
new_window.active_view().set_scratch(True)
view2 = new_window.active_view()
# keep track of these views
view1.settings().set("is_sbs_compare", True)
view2.settings().set("is_sbs_compare", True)
# disable word wrap
view1.settings().set('word_wrap', 'false')
view2.settings().set('word_wrap', 'false')
# generate and set colour scheme
self.colours = self.generate_colour_scheme(view1)
self.generate_colour_scheme(view2, generate=False)
# run diff
self.compare_views(view1, view2)
# make readonly
new_window.focus_view(view1)
if sbs_settings().get('read_only', False):
new_window.active_view().set_read_only(True)
new_window.focus_view(view2)
if sbs_settings().get('read_only', False):
new_window.active_view().set_read_only(True)
# activate scroll syncer
ViewScrollSyncer(new_window, [view1, view2])
# move views to top left
view1.set_viewport_position((0, 0), False)
view2.set_viewport_position((0, 0), False)
# move cursors to top left
origin = view.text_point(0, 0)
view1.sel().clear()
view1.sel().add(sublime.Region(origin))
view1.show(origin)
view2.sel().clear()
view2.sel().add(sublime.Region(origin))
view2.show(origin)
# focus first view
new_window.focus_view(view1)
