def run(self, edit):
filename = self.view.file_name()
if filename is None:
filename = ""
extension = os.path.splitext(filename)[1][1:]
text = self.getTextFromBeginningOfLineToCursor()
script = 'Application("TeaCode").expandAsJson({text}, {{ "extension": {extension} }})'.format(
text=sublime.encode_value(text),
extension=sublime.encode_value(extension))
command = ["osascript", "-l", "JavaScript", "-e", script]
session = subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True)
stdout, stderr = session.communicate()
if stderr:
sublime.message_dialog(
"Could not run TeaCode. Please make sure it's installed. You can download the app from www.apptorium.com/teacode"
)
return
self.handleJson(stdout, edit)
def tweak_theme():
view = sublime.active_window().active_view()
if not view:
return
theme = view.settings().get("theme")
if theme is None:
print("Can't guess current theme.")
return
theme_path = os.path.join(sublime.packages_path(), "User", theme)
if os.path.exists(theme_path):
with open(theme_path, mode="r", encoding="utf-8") as f:
theme_text = f.read()
if POETRY_MARKERS.search(theme_text):
return
safety_path = os.path.join(sublime.packages_path(), "User",
"Original-" + theme)
with open(safety_path, mode="w", encoding="utf-8") as f:
f.write(theme_text)
theme = sublime.decode_value(theme_text)
else:
theme = []
theme.extend(POETRY_RULES)
tweaked_theme = sublime.encode_value(theme, True)
with open(theme_path, mode="w", encoding="utf-8") as f:
f.write(tweaked_theme)
LOG.debug("Poetry: Done tweaking '{}'!".format(theme_path))
def run(self):
self.folders = ['..']
workspace_path = self.window.project_file_name().replace(
'sublime-project', 'sublime-Hotkeyfolders')
with open(workspace_path, 'r+') as file:
self.data = sublime.decode_value(file.read())
if not 'ignore' in self.data:
self.data['ignore'] = '.git'
file.seek(0)
file.write(sublime.encode_value(self.data))
file.truncate()
#添加root目录下不在ignore内的文件夹
if 'root' in self.data:
root = self.data['root']
for folder in os.listdir(root):
if os.path.isdir(root + '\\' +
folder) and not folder in self.data['ignore']:
self.folders.append(folder)
##
self.folders_len = len(self.folders)
#添加项目中其他根目录
for folder in self.window.project_data()['folders']:
self.folders.append(folder['path'])
##
self.window.show_quick_panel(self.folders, self.on_done)
def get_completions(self, prefix):
cls = self.__class__
loveCompletions = []
for i, key in enumerate(cls.api.keys()):
item = cls.api[key]
description = item['meta']['description'].split('.')[0] + '.'
prop_type = item['meta']['prop_type'] or 'variable'
kind = self.kinds[prop_type]
href = 'subl:love' + " " + sublime.encode_value({ "key": key, "point": "", "hide_on_mouse_move": False })
completion_text = (key + '($0)') if prop_type == 'function' else key
completion = sublime.CompletionItem(
key,
prop_type,
completion_text,
sublime.COMPLETION_FORMAT_SNIPPET,
kind,
'''<a href='{}'>{}</a>'''.format(href, description)
)
loveCompletions.append(completion)
return loveCompletions
def _write_aliases(self, aliases):
view = None
for current_view in sublime.active_window().views():
if current_view.file_name().endswith('.sublime-project'):
view = current_view
break
if view == None:
raise Exception('Project settings not found')
raw_settings = view.substr(sublime.Region(0, view.size()))
root_settings = sublime.decode_value(raw_settings)
if 'settings' not in root_settings:
root_settings['settings'] = {}
settings = root_settings['settings']
for keyword in aliases:
key = 'keyword.' + keyword
if key not in settings:
settings[key] = {}
if 'aliases' not in settings[key]:
settings[key]['aliases'] = {}
settings[key]['aliases'].update(aliases[keyword])
args = {
'region': [0, view.size()],
'text': sublime.encode_value(root_settings)
}
view.run_command('replace_region', args)
view.run_command('pretty_json')
view.run_command('save')
def on_done(self, index):
if index < 0:
return
if index is 0:
for folder in self.window.project_data()['folders']:
if os.path.normpath(self.data['root']) == os.path.normpath(
folder['path']):
if not sublime.ok_cancel_dialog(
"Do you leave from project-folders"):
return
if index < self.folders_len:
dir_path = os.path.abspath(self.data['root'] + '\\' +
self.folders[index])
else:
dir_path = self.folders[index]
workspace_path = self.window.project_file_name().replace(
'sublime-project', 'sublime-Hotkeyfolders')
with open(workspace_path, 'w') as file:
self.data['root'] = dir_path
file.write(sublime.encode_value(self.data))
self.window.active_view().erase_status('root')
self.window.active_view().set_status('root', '❤ ' + dir_path + ' 💜')
def done(self):
view = self.window.new_file()
view.set_scratch(True)
default = self.get_setting('env')
template = util.multiline_fix("""
// Enter environment variables here in JSON syntax.
// Close this view when done to commit the settings.
""")
if 'contents' in self.cmd_input:
# Used when parsing fails to attempt to edit again.
template = self.cmd_input['contents']
elif default:
template += sublime.encode_value(default, True)
else:
template += util.multiline_fix("""
{
// "RUST_BACKTRACE": "1"
}
""")
# Unfortunately Sublime indents on 'insert'
view.settings().set('auto_indent', False)
view.run_command('insert', {'characters': template})
view.settings().set('auto_indent', True)
view.set_syntax_file('Packages/JavaScript/JSON.sublime-syntax')
view.settings().set('rust_environment_editor', True)
view.settings().set('rust_environment_editor_settings', {
'package': self.choices.get('package'),
'which': self.choices['which'],
'variant': self.choices.get('variant'),
'target': self.choices.get('target'),
})
def done(self):
view = self.window.new_file()
view.set_scratch(True)
default = self.get_setting('env')
template = util.multiline_fix("""
// Enter environment variables here in JSON syntax.
// Close this view when done to commit the settings.
""")
if 'contents' in self.cmd_input:
# Used when parsing fails to attempt to edit again.
template = self.cmd_input['contents']
elif default:
template += sublime.encode_value(default, True)
else:
template += util.multiline_fix("""
{
// "RUST_BACKTRACE": "1"
}
""")
# Unfortunately Sublime indents on 'insert'
view.settings().set('auto_indent', False)
view.run_command('insert', {'characters': template})
view.settings().set('auto_indent', True)
view.set_syntax_file('Packages/JavaScript/JSON.sublime-syntax')
view.settings().set('rust_environment_editor', True)
view.settings().set('rust_environment_editor_settings', {
'package': self.choices.get('package'),
'which': self.choices['which'],
'variant': self.choices.get('variant'),
'target': self.choices.get('target'),
})
def guardar(self):
archivo=open(self.rutaArchivo, "w")
d={}
d["tags"]=self.tags
d["attrs"]=self.attrs
archivo.write(sublime.encode_value(d, True))
archivo.close()
def save(self, data, indent=4):
self.fdir = os.path.dirname(self.fpath)
if not os.path.isdir(self.fdir):
os.makedirs(self.fdir)
f = codecs.open(self.fpath, "w+", encoding=self.encoding)
f.write(sublime.encode_value(data, True))
f.close()
def init_project(self, project_path, project_file):
init = {'folders': [{'path': '%s' % project_path}]}
with open(project_file, 'w', encoding='UTF-8') as file:
file.write(sublime.encode_value(init))
self.window.set_project_data(init)
def _patch_general(themes, dest, isettings):
theme_content = []
color = isettings.get("color")
opacity = isettings.get("opacity")
size = isettings.get("size")
row_padding = isettings.get("row_padding")
if color or opacity or size or row_padding:
icon = _patch_icon(None, color, opacity)
if size:
icon["content_margin"] = [size, size]
if row_padding:
icon["row_padding"] = row_padding
theme_content.append(icon)
color = isettings.get("color_on_hover")
opacity = isettings.get("opacity_on_hover")
if color or opacity:
theme_content.append(_patch_icon("hover", color, opacity))
color = isettings.get("color_on_select")
opacity = isettings.get("opacity_on_select")
if color or opacity:
theme_content.append(_patch_icon("selected", color, opacity))
text = sublime.encode_value(theme_content)
for theme in themes:
log("Patching `{}`".format(theme))
with open(os.path.join(dest, theme), "w") as t:
t.write(text)
def set(status=False, timeout=0):
"""Set color in the status status
Sets the given action as color in the status bar
Keyword Arguments:
status {bool} -- sets a color in the status bar based on the actions
defined in the 'colors' global var. (default: {False})
timeout {number} -- removes the status bar color after the given delay
in milliseconds. If not defined the color will keep
forever (default: {0})
"""
global theme_path
check_folder_paths()
resource = []
# background color
resource.append({"class": "status_bar", "layer0.tint": colors[status][0]})
# text color
resource.append({"class": "label_control", "color": colors[status][1]})
resource = sublime.encode_value(resource)
# save file
with open(theme_path, 'w') as file:
file.write(resource)
if(timeout > 0):
sublime.set_timeout_async(remove, timeout)
def save(self, data, indent=4):
self.fdir = os.path.dirname(self.fpath)
if not os.path.isdir(self.fdir):
os.makedirs(self.fdir)
f = codecs.open(self.fpath, "w+", encoding=self.encoding)
f.write(sublime.encode_value(data, True))
f.close()
def save(self, data, indent=4):
self.fdir = os.path.dirname(self.fpath)
if not os.path.isdir(self.fdir):
os.makedirs(self.fdir)
with open(self.fpath, mode='w', encoding=self.encoding,
newline='\n') as f:
f.write(sublime.encode_value(data, True))
def tweak_theme():
view = sublime.active_window().active_view()
theme = view.settings().get('theme')
if theme is None:
print("Can't guess current theme.")
return
theme_path = os.path.join(sublime.packages_path(), 'User', theme)
if os.path.exists(theme_path):
with open(theme_path, mode='r', encoding='utf-8') as f:
theme_text = f.read()
if PYTEST_MARKERS.search(theme_text):
print("Already patched")
return
safety_path = os.path.join(sublime.packages_path(), 'User',
'Original-' + theme)
with open(safety_path, mode='w', encoding='utf-8') as f:
f.write(theme_text)
theme = sublime.decode_value(theme_text)
else:
theme = []
theme.extend(PYTEST_RULES)
tweaked_theme = sublime.encode_value(theme, True)
with open(theme_path, mode='w', encoding='utf-8') as f:
f.write(tweaked_theme)
print('Done tweaking!')
def encode_value(value, pretty=False):
if hasattr(sublime, 'encode_value'):
return sublime.encode_value(value, pretty)
else:
return json.dumps(value,
sort_keys=True if pretty else False,
indent=4 if pretty else 0)
def _load_package_schemas(self) -> List[Any]:
global_preferences_schemas = []
resources = ResourcePath.glob_resources('sublime-package.json')
for resource in resources:
schema = self._parse_schema(resource)
if not schema:
continue
settings = schema.get('contributions').get('settings')
for s in settings:
i = len(self._schema_uri_to_content)
file_patterns = s.get('file_patterns')
schema_content = s.get('schema')
uri = schema_content.get(
'$id') or 'sublime://settings/{}'.format(i)
self._schema_uri_to_content[uri] = sublime.encode_value(
schema_content, pretty=False)
self._register_schemas([{
'fileMatch': file_patterns,
'uri': uri
}])
if file_patterns:
for pattern in file_patterns:
if pattern == '/Preferences.sublime-settings':
global_preferences_schemas.append(schema_content)
return global_preferences_schemas
def run(self, edit, type="", text="", region=None, dest=None):
if type == "insert":
self.view.insert(edit, 0, text)
elif type == "add":
self.view.insert(edit, self.view.size(), text)
elif type == "replace":
self.view.insert(edit, region, text)
elif type == "set_read_only":
self.view.set_read_only(True)
elif type == "test":
if not isStable():
self.view.show_popup_menu(["A", "B"], self.nothing)
elif type == "remote_hash":
if not isStable():
sublime.active_window().show_input_panel("URL:", "", self.remote_hash, None, None)
elif type == "hash":
if not isStable():
print(hashlib.sha256(self.view.substr(sublime.Region(0,self.view.size())).encode("utf-8")).hexdigest())
elif type == "tojson":
if not isStable():
jsonObj = sublime.decode_value(self.view.substr(sublime.Region(0,self.view.size())))
self.view.replace(edit, sublime.Region(0,self.view.size()), sublime.encode_value(jsonObj, True));
elif type == "reload":
if isDebug():
getAction().addAction("javatar.command.utils.reload", "Reload Javatar")
print("Reloading Javatar...")
import sys
from imp import reload
for mod in sys.modules:
if mod.lower().startswith("javatar") and not mod.lower().endswith("_utils") and sys.modules[mod] is not None:
print("Reloading module " + mod + "...")
reload(sys.modules[mod])
from ..Javatar import plugin_loaded
plugin_loaded()
def init_problems(self, handler, contest_id, base, pid='A'):
inputs, outputs = handler.try_load_tests(contest_id, pid)
if inputs:
file_name = path.join(base, pid + '.cpp')
if not path.exists(file_name):
file = open(file_name, 'w')
file.close()
tests = []
for i in range(len(inputs)):
tests.append({
'test': inputs[i],
'correct_answers': [outputs[i]]
})
with open(get_tests_file_path(file_name), 'w') as f:
f.write(sublime.encode_value(tests, True))
def go(self=self, handler=handler, contest_id=contest_id, base=base, pid=self.next_problem(pid)):
self.init_problems(handler, contest_id, base, pid=pid)
sublime.set_timeout_async(go)
else:
if len(pid) == 1:
self.init_problems(handler, contest_id, base, pid + '1')
elif pid[1] == '1':
sublime.status_message('tests loaded')
return
else:
self.init_problems(handler, contest_id, base, chr(ord(pid[0]) + 1))
def run(self):
"""API entry point to rebuild main menu."""
# create cache directory
cache_path = menu_cache_path()
if not os.path.isdir(cache_path):
os.makedirs(cache_path)
# build main menu structure
menu = [{
"id": "preferences",
"children": [{
"caption": "Theme",
"children": self.create_menu(
"switch_theme", ["*.sublime-theme"], "themes_exclude")
}]
}]
if _HAVE_ST_UI:
# ST3127+ no longer provides its own "Color Scheme" sub menu.
menu[0]["children"].insert(0, {
"caption": "Color Scheme",
"children": self.create_menu(
"switch_color_scheme",
["*.sublime-color-scheme", "*.tmTheme"],
"colors_exclude"
)
})
# save main menu to file
cache_path = os.path.join(cache_path, "Main.sublime-menu")
with open(cache_path, "w", encoding="utf-8") as menu_file:
menu_file.write(sublime.encode_value(menu, False))
def write_new_theme(self, name):
full_path = os.path.join(sublime.packages_path(),
self.get_theme_path(name))
with util.file.safe_open(full_path, "wb", buffering=0) as out_f:
out_f.write(
sublime.encode_value(self.dict, pretty=True).encode("utf-8"))
def format_completion_item(value,
default=None,
is_default=False,
label=None,
description=None):
"""Create a completion item with its type as description.
Arguments:
value (any):
The value which is added when completions are committed.
If `label` is none, the `value` is used as label, too.
default (any):
Sets is_default if equals `value`.
is_default (bool):
If `True` the completion item is marked '(default)'.
label (str):
An alternative label to use to present the `value`
in the completions panel.
description (str):
An optional description to display after the label.
If `None` is provided, the data type of `value` is displayed.
"""
if isinstance(value, dict):
raise ValueError("Cannot format dictionary value", value)
if not is_default:
is_default = value in default if isinstance(default,
list) else value == default
return (("{0} \t(default) {1}" if is_default else "{0} \t{1}").format(
sublime.encode_value(label or value).strip('"'), description
or type(value).__name__), value)
def init_problems(self, handler, contest_id, base, pid=0):
inputs, outputs = handler.try_load_tests(contest_id, pid)
if inputs:
file_name = path.join(base, chr(ord('A') + pid) + '.cpp')
if not path.exists(file_name):
file = open(file_name, 'w')
file.close()
tests = []
for i in range(len(inputs)):
tests.append({
'test': inputs[i],
'correct_answers': [outputs[i]]
})
file = open(file_name + TestManagerCommand.TESTS_FILE_SUFFIX, 'w')
file.write(sublime.encode_value(tests, True))
file.close()
def go(self=self,
handler=handler,
contest_id=contest_id,
base=base,
pid=pid + 1):
self.init_problems(handler, contest_id, base, pid=pid)
sublime.set_timeout_async(go)
def clear(self):
"""Clear tweaks."""
if not self._lock():
log('Failed to acquire lock!')
return
self._setup(noedit=True)
if self.theme_valid:
csm = ColorSchemeMatcher(self.scheme_map["original"])
content = self._get_tmtheme(csm.get_scheme_obj(
)) if not NEW_SCHEMES else csm.get_scheme_obj()
if NEW_SCHEMES:
with codecs.open(self.scheme_clone, "w",
encoding='utf-8') as f:
f.write(sublime.encode_value(content, pretty=True))
self.scheme_map["redo"] = ""
self.scheme_map["undo"] = ""
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
else:
with open(self.scheme_clone, "wb") as f:
f.write(writePlistToBytes(content))
self.scheme_map["redo"] = ""
self.scheme_map["undo"] = ""
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
if self.set_tweaked_scheme:
sublime.set_timeout(self._set_tweaked_scheme, 300)
else:
Lock.release_lock()
else:
Lock.release_lock()
log("Theme has not been tweaked!", status=True)
def format_completion_item(value, default=None, is_default=False, label=None, annotation=None):
"""Create a completion item with its type as description.
Arguments:
value (any):
The value which is added when completions are committed.
If `label` is none, the `value` is used as label, too.
default (any):
Sets is_default if equals `value`.
is_default (bool):
If `True` the completion item is marked '(default)'.
label (str):
An alternative label to use to present the `value`
in the completions panel.
annotation (str):
An optional annotation to display after the label.
"""
if isinstance(value, dict):
raise ValueError("Cannot format dictionary value", value)
if not is_default:
is_default = value in default if isinstance(default, list) else value == default
type_ = type(value).__name__
return sublime.CompletionItem(
trigger=sublime.encode_value(label or value).strip('"'),
annotation=("(default) {}" if is_default else "{}").format(annotation or ""),
completion=value,
kind=(sublime.KIND_ID_SNIPPET, type_[0], type_),
)
def toggle():
preferences = sublime.load_settings("Preferences.sublime-settings")
color_scheme = os.path.basename(preferences.get("color_scheme"))
color_scheme_file = os.path.splitext(
color_scheme)[0] + ".sublime-color-scheme"
user_color_scheme = get_user_color_scheme("Packages/User/" +
color_scheme_file)
user_color_scheme_path = os.path.join(sublime.packages_path(), "User",
color_scheme_file)
non_cfml_rules = [
row for row in user_color_scheme["rules"]
if "scope" not in row or not row["scope"].endswith("cfml")
]
has_cfml_rules = len(user_color_scheme["rules"]) > len(non_cfml_rules)
if has_cfml_rules:
user_color_scheme["rules"] = non_cfml_rules
else:
user_color_scheme["rules"].extend(get_cfml_rules())
with open(user_color_scheme_path, "w") as f:
f.write(sublime.encode_value(user_color_scheme, True))
if len(user_color_scheme.keys()) == 1 and len(
user_color_scheme["rules"]) == 0:
print("CFML: Packages/User/{} is now empty.".format(color_scheme_file))
def run(self):
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
end_time = time.time() + SublimeNodeClient.CONNECT_TIMEOUT
while not self.connected:
remaining_time = end_time - time.time()
if remaining_time < 0:
raise Exception(
"Unable to connect to `{0}`".format(self.server_address)
)
try:
client.connect(self.server_address)
self.connected = True
except (ConnectionRefusedError, FileNotFoundError):
pass
while self.connected:
while not self.queue.empty():
(message, callback) = self.queue.get()
encoded = sublime.encode_value(message) + "\n"
client.send(bytes(encoded, "utf-8"))
if callback:
sublime.set_timeout(callback, 0)
time.sleep(SublimeNodeClient.BRIDGE_THROTTLE)
client.close()
def build_tooltip(self, view, key):
"""Return html encoded docstring for settings key.
Arguments:
view (sublime.View):
the view to provide completions for
key (string):
the key under the cursor
"""
if key in self.defaults:
# the comment for the setting
comment = html_encode(self.comments.get(key) or "No description.")
# the default value from base file
default = html_encode(
sublime.encode_value(self.defaults.get(key), pretty=True))
# prepare a link to add the settings to user file or jump to its
# position for editing, if the item in side-by-side setting's
# base view is hoverd
if view.settings().get('edit_settings_view') == 'base':
edit = "<a href=\"edit:{0}\">✏</a>".format(key)
else:
edit = ""
else:
comment, default, edit = "No description.", "unknown setting", ""
# format tooltip html content
return ("<h1>{key} {edit}</h1>"
"<h2>Default: {default}</h2>"
"<p>{comment}</p>").format(**locals())
def memorize_tests(self):
# print([x.memorize() for x in (self.tester.get_tests())])
f = open(self.dbg_file + ':tests', 'w')
f.write(
sublime.encode_value(
[x.memorize() for x in (self.tester.get_tests())], True))
f.close()
def _theme_valid(self, scheme_file, noedit=False):
"""Check if theme is valid."""
is_working = scheme_file.startswith(TEMP_PATH + '/')
if (
is_working and self.scheme_map is not None and
self.scheme_map["working"] == scheme_file and
self._exists(self.scheme_map["original"])
):
if self._exists(self.scheme_map["working"]):
self.scheme_file = packages_path(self.scheme_map["original"])
self.scheme_clone = packages_path(self.scheme_map["working"])
else:
# Recover from missing temp
log("Revert to original because temp is missing")
if self.set_safe:
self._set_theme_safely(self.scheme_map["original"])
else:
self.settings.set(SCHEME, self.scheme_map["original"])
self.scheme_map["redo"] = ""
self.scheme_map["undo"] = ""
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
return True
elif not is_working and not noedit:
self._ensure_temp()
csm = ColorSchemeMatcher(scheme_file)
content = get_tmtheme(csm.get_scheme_obj()) if not NEW_SCHEMES else csm.get_scheme_obj()
self.scheme_file = packages_path(scheme_file)
base, old_ext = splitext(basename(scheme_file))
if NEW_SCHEMES:
ext = '.hidden-color-scheme' if old_ext == '.hidden-color-scheme' else '.sublime-color-scheme'
else:
ext = '.tmTheme'
self.scheme_clone = packages_path(join(normpath(TEMP_PATH), 'tweak-' + base + ext))
try:
if NEW_SCHEMES:
with codecs.open(self.scheme_clone, "w", encoding='utf-8') as f:
f.write(sublime.encode_value(content, pretty=True))
else:
with open(self.scheme_clone, "wb") as f:
f.write(writePlistToBytes(content))
self.scheme_map = {
"original": scheme_file,
"working": "%s/%s" % (TEMP_PATH, 'tweak-' + base + ext),
"undo": "",
"redo": ""
}
self.set_tweaked_scheme = {
"set_safe": self.set_safe,
"scheme": self.scheme_map["working"],
}
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
return True
except Exception as e:
log(e)
sublime.error_message("Cannot clone theme")
return False
return False
def clear(self):
"""Clear tweaks."""
if not self._lock():
log('Failed to acquire lock!')
return
self._setup(noedit=True)
if self.theme_valid:
csm = ColorSchemeMatcher(self.scheme_map["original"])
content = self._get_tmtheme(csm.get_scheme_obj()) if not NEW_SCHEMES else csm.get_scheme_obj()
if NEW_SCHEMES:
with codecs.open(self.scheme_clone, "w", encoding='utf-8') as f:
f.write(sublime.encode_value(content, pretty=True))
self.scheme_map["redo"] = ""
self.scheme_map["undo"] = ""
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
else:
with open(self.scheme_clone, "wb") as f:
f.write(writePlistToBytes(content))
self.scheme_map["redo"] = ""
self.scheme_map["undo"] = ""
self.p_settings["scheme_map"] = self.scheme_map
self._save_tweak_settings()
if self.set_tweaked_scheme:
sublime.set_timeout(self._set_tweaked_scheme, 300)
else:
Lock.release_lock()
else:
Lock.release_lock()
log("Theme has not been tweaked!", status=True)
def _patch_general(themes, dest, isettings):
theme_content = []
color = isettings.get("color")
opacity = isettings.get("opacity")
size = isettings.get("size")
row_padding = isettings.get("row_padding")
if color or opacity or size or row_padding:
icon = _patch_icon(None, color, opacity)
if size:
icon["content_margin"] = [size, size]
if row_padding:
icon["row_padding"] = row_padding
theme_content.append(icon)
color = isettings.get("color_on_hover")
opacity = isettings.get("opacity_on_hover")
if color or opacity:
theme_content.append(_patch_icon("hover", color, opacity))
color = isettings.get("color_on_select")
opacity = isettings.get("opacity_on_select")
if color or opacity:
theme_content.append(_patch_icon("selected", color, opacity))
text = sublime.encode_value(theme_content)
for theme in themes:
log("Patching `{}`".format(theme))
with open(os.path.join(dest, theme), "w") as t:
t.write(text)
def save():
for file_name in mode if mode else CACHE_NAMES:
if file_name in self.cache_data:
str_json = sublime.encode_value(self.cache_data[file_name])
with open(os.path.join(sublime.cache_path(), "LaTeXing", file_name), 'w', encoding="utf-8") as f:
log.trace("%s", f)
f.write(str_json)
log.info("%s (%s)" % (file_name, tools.size_of_string(str_json)))
def format_completion_item(value, default=False):
"""Create a completion item with its type as description."""
if isinstance(value, dict):
raise ValueError("Cannot format dictionary value", value)
default_str = "(default) " if default else ""
return ("{0} \t{2}{1}".format(
sublime.encode_value(value).strip('"'),
type(value).__name__, default_str), value)
def format_completion_item(value, default=False):
"""Create a completion item with its type as description."""
default_str = "(default) " if default else ""
return (
"{0} \t{2}{1}".format(
sublime.encode_value(value).strip('"'),
type(value).__name__, default_str),
# 'cast' dicts to frozen sets, because those are hashable
frozenset(value.items()) if isinstance(value, dict) else value)
def format_completion_item(value, default=False):
"""Create a completion item with its type as description."""
if isinstance(value, dict):
raise ValueError("Cannot format dictionary value", value)
default_str = "(default) " if default else ""
return ("{0} \t{2}{1}".format(sublime.encode_value(value).strip('"'),
type(value).__name__,
default_str),
value)
def as_completion(self, with_key=False):
if with_key:
# TODO doesn't escape json chars
formatted_value = _escape_in_snippet(
sublime.encode_value(self.value))
contents = '"{}": ${{0:{}}},'.format(self.name, formatted_value)
return ("{}\t{}".format(self.name, self.source), contents)
else:
return ("{}\t{}".format(self.name, self.source), self.name)
def save_stylesheets(self, style_sheets):
"""Save the stylesheet dictionary to file"""
content = sublime.encode_value(style_sheets, True)
with open(self.theme_file_path, "w") as f:
f.write(content)
self.style_sheets = style_sheets
def send_command(self, callback: Callable, **data: Any) -> None:
"""Send the given command that should be handled bu the given callback
"""
data["uid"] = self.add_callback(callback)
try:
self.push(bytes("{}\r\n".format(sublime.encode_value(data)), "utf8"))
except NameError:
self.push(bytes("{}\r\n".format(json.dumps(data)), "utf8"))
def save_stylesheets(self, style_sheets): """Save the stylesheet dictionary to file""" content = sublime.encode_value(style_sheets, True) with open(self.theme_file_path, "w") as f: f.write(content) self.style_sheets = style_sheets
def configurarCadena(self, cadena):
comando={}
if self.lenguaje=="plsql":
comando["cmd"]=["sqlplus", cadena, "@", "$file"]
comando["selector"]="source.plsql"
comando=sublime.encode_value(comando, True)
ruta=os.path.join(sublime.packages_path(), "user", self.lenguaje+".sublime-build")
archivo=open(ruta, "w")
archivo.write(comando)
archivo.close()
def send_command(self, callback, **data):
"""Send the given command that should be handled bu the given callback
"""
data['uid'] = self.add_callback(callback)
try:
self.push(
bytes('{}\r\n'.format(sublime.encode_value(data)), 'utf8'))
except NameError:
self.push(bytes('{}\r\n'.format(json.dumps(data)), 'utf8'))
def save(self, data, indent=4):
self.fdir = os.path.dirname(self.fpath)
if not os.path.isdir(self.fdir):
os.makedirs(self.fdir)
f = codecs.open(self.fpath, "w+", encoding=self.encoding)
if sublime.version() > "3000":
f.write(sublime.encode_value(data, True))
else:
f.write(json.dumps(data, ensure_ascii=False, indent=indent))
f.close()
def request(self, method, url, params=None, body=None, headers=None, raw_response=False, as_json=False):
try:
import ssl
pool_manager = PoolManager(
num_pools=4,
maxsize=8,
block=False,
timeout=60.0,
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=GDriveUtil.get_cert_file(),
ssl_version=ssl.PROTOCOL_TLSv1,
)
except (ImportError):
pool_manager = PoolManager(
num_pools=4,
maxsize=8,
block=False,
timeout=60.0,
)
params = params or {}
headers = headers or {}
headers["User-Agent"] = "DrSync/0.1"
if params:
if body:
raise ValueError("body parameter cannot be used with params parameter")
if as_json:
body = sublime.encode_value(params)
headers["Content-type"] = "application/json"
headers["Content-Length"] = len(body)
else:
body = urllib.parse.urlencode(params)
headers["Content-type"] = "application/x-www-form-urlencoded"
if hasattr(body, "getvalue"):
body = str(body.getvalue())
headers["Content-Length"] = len(body)
if hasattr(body, "read"):
headers["Content-Length"] = len(body.read())
for key, value in headers.items():
if type(value) == str and "\n" in value:
raise ValueError("headers should not contain newlines (" + key + ": " + value + ")")
try:
response = pool_manager.urlopen(method=method, url=url, body=body, headers=headers, preload_content=False)
except socket.error as e:
raise SocketError(url, e)
except exceptions.SSLError as e:
raise SocketError(url, "SSL certificate error: %s" % e)
if response.status != 200:
raise ErrorResponse(response, response.read())
return {"headers": response.headers, "data": self.process_response(response, raw_response)}
def plugin_loaded(): rm_in = open(path.join(root_dir, 'system_settings.json')) sys_settings = sublime.decode_value(rm_in.read()) rm_in.close() if not sys_settings['is_init']: sys_settings['is_init'] = True rm_out = open(path.join(root_dir, 'system_settings.json'), 'w') rm_out.write(sublime.encode_value(sys_settings)) rm_out.close() sublime.windows()[0].open_file(path.join(root_dir, 'Docs/Docs-EN.md'))
def __overwrite(self): import os cur_name = self.get_current_settings() contents = self.get_settings_contents() current_content = contents[cur_name] preferences = os.path.join(sublime.packages_path(), 'User', 'Preferences.sublime-settings') with open(preferences, mode='w') as f: f.write(sublime.encode_value(current_content, True)) return True
def on_done(i):
if i < 0:
return
key = items[i]
value = CACHE.cache_data[key]
view = self.window.new_file()
view.set_name("temp::" + key)
view.set_scratch(True)
view.set_read_only(True)
view.run_command("ltx_append_text", {"string": sublime.encode_value(value, True)})
view.run_command("ltx_select_point", {"point": 0})
def _key_snippet(key, value, bol="", eol=",\n"):
"""Create snippet with default value depending on type.
Arguments:
key (string):
the settings key name
value (any):
the default value of the setting read from base file
bol (string):
the prefix to add to the beginning of line
eol (string):
the suffix to add to the end of line
Returns:
string: the contents field to insert into completions entry
"""
encoded = sublime.encode_value(value)
encoded = encoded.replace("\\", "\\\\") # escape snippet markers
encoded = encoded.replace("$", "\\$")
encoded = encoded.replace("}", "\\}")
if isinstance(value, str):
# create the snippet for json strings and exclude quotation marks
# from the input field {1:}
#
# "key": "value"
#
fmt = '{bol}"{key}": "${{1:{encoded}}}"{eol}'
encoded = encoded[1:-1] # strip quotation
elif isinstance(value, list):
# create the snippet for json lists and exclude brackets
# from the input field {1:}
#
# "key":
# [
# value
# ]
#
fmt = '{bol}"{key}":\n[\n\t${{1:{encoded}}}\n]{eol}'
encoded = encoded[1:-1] # strip brackets
elif isinstance(value, dict):
# create the snippet for json dictionaries braces
# from the input field {1:}
#
# "key":
# {
# value
# }
#
fmt = '{bol}"{key}":\n{{\n\t${{1:{encoded}}}\n}}{eol}'
encoded = encoded[1:-1] # strip braces
else:
fmt = '{bol}"{key}": ${{1:{encoded}}}{eol}'
return fmt.format(**locals())
def send_command(self, callback, **data):
"""Send the given command that should be handled bu the given callback
"""
data['uid'] = self.add_callback(callback)
try:
self.push(
bytes('{}\r\n'.format(sublime.encode_value(data)), 'utf8')
)
except NameError:
self.push(bytes('{}\r\n'.format(json.dumps(data)), 'utf8'))
def run(self):
for filepath in sublime.find_resources("*.javatar-imports"):
get_action().add_action("javatar.command.utils.convert.run", "Converting imports \""+get_path("name", filepath)+"\"")
packages_file = {"name":get_path("name", filepath), "packages":{}}
imports_file = sublime.decode_value(sublime.load_resource(filepath))
total_package = 0
total_class = 0
for imports in imports_file:
if "package" in imports:
total_package += 1
package = imports["package"]
packages_file["packages"][package] = {}
if "default" in imports:
packages_file["packages"][package]["default"] = imports["default"]
if "interface" in imports:
packages_file["packages"][package]["interface"] = []
total_class += len(imports["interface"])
for clss in imports["interface"]:
packages_file["packages"][package]["interface"].append({"name":clss,"fields":[],"methods:":[]})
if "class" in imports:
packages_file["packages"][package]["class"] = []
total_class += len(imports["class"])
for clss in imports["class"]:
packages_file["packages"][package]["class"].append({"name":clss,"fields":[],"methods:":[]})
if "enum" in imports:
packages_file["packages"][package]["enum"] = []
total_class += len(imports["enum"])
for clss in imports["enum"]:
packages_file["packages"][package]["enum"].append({"name":clss,"fields":[],"methods:":[]})
if "exception" in imports:
packages_file["packages"][package]["exception"] = []
total_class += len(imports["exception"])
for clss in imports["exception"]:
packages_file["packages"][package]["exception"].append({"name":clss,"fields":[],"methods:":[]})
if "error" in imports:
packages_file["packages"][package]["error"] = []
total_class += len(imports["error"])
for clss in imports["error"]:
packages_file["packages"][package]["error"].append({"name":clss,"fields":[],"methods:":[]})
if "annotation" in imports:
packages_file["packages"][package]["annotation"] = []
total_class += len(imports["annotation"])
for clss in imports["annotation"]:
packages_file["packages"][package]["annotation"].append({"name":clss,"fields":[],"methods:":[]})
if "type" in imports:
packages_file["packages"][package]["type"] = []
total_class += len(imports["type"])
for clss in imports["type"]:
packages_file["packages"][package]["type"].append({"name":clss,"fields":[],"methods:":[]})
with open(get_path("join", get_path("parent", sublime.packages_path()), filepath.replace(".javatar-imports", "-converted.javatar-packages")), "w") as filew:
print(sublime.encode_value(packages_file, True), file=filew)
sublime.message_dialog("Conversion Done\nTotal Packages: " + str(total_package) + "\nTotal Classes: " + str(total_class))
def save_cache(self, cache):
if "creation_time" not in cache:
cache["creation_time"] = int(time.time())
from .macro import Macro
cache_location = Macro().parse(Settings().get(
"cache_file_location"
))
cache_path = os.path.join(cache_location, ".javatar-cache")
if os.path.exists(cache_path):
os.remove(cache_path)
cache_file = open(cache_path, "w")
cache_file.write(sublime.encode_value(cache, True))
cache_file.close()
def send_command(self, callback, **data):
"""Send the given command that should be handled bu the given callback
"""
uid = uuid.uuid4()
self.callbacks[uid.hex] = callback
data['uid'] = uid.hex
try:
self.push(
bytes('{}\r\n'.format(sublime.encode_value(data)), 'utf8')
)
except NameError:
self.push(bytes('{}\r\n'.format(json.dumps(data)), 'utf8'))
def guardarArchivos(self): archivo=open(self.ruta, "w") if len(self.archivos["archivos"])>500: lista=self.archivos["archivos"] lista=list(reversed(list(reversed(lista))[:250])) self.archivos["archivos"]=lista if len(self.archivos["carpetas"])>500: lista=self.archivos["carpetas"] lista=list(reversed(list(reversed(lista))[:250])) self.archivos["carpetas"]=lista archivo.write(sublime.encode_value(self.archivos, True)) archivo.close()
def guardarFunciones():
texto=ArchivoJavascript.getTextoLimpio()
js=ArchivoJavascript.cargarArchivo()
d=ArchivoJavascript.diseccionar(librerias=True, variables=True, texto=texto)
for libreria in d["librerias"]:
if js["librerias"].get("libreria"):
js[librerias][libreria]=list(set(js["librerias"][libreria])|ArchivoJavascript.getMiembros(libreria))
else:
js["librerias"][libreria]=ArchivoJavascript.getMiembros(libreria, texto=texto)
for variable in d["variables"]:
tipo=ArchivoJavascript.getTipo(variable, texto=texto)
if js["clases"].get(tipo)==None:js["clases"][tipo]=[]
js["clases"][clase]=list(set(js["clases"][clase]+ArchivoJavascript.getMiembros(variable)))
archivo=open(sublime.packages_path()+os.sep+"javascript"+os.sep+"javascript.json","w")
archivo.write(sublime.encode_value(js, True))
archivo.close()
def generate_file(self):
if len(self.window.folders()) <= 0:
sublime.error_message(
"No folder opened. Local dependency creation cancelled."
)
return
dep_file = open(os.path.join(
self.window.folders()[0],
os.path.basename(self.window.folders()[0]) + ".sublime-local-dependency"
), "w")
dependencies = {
"packages": []
}
for package in self.package_selection:
dependencies["packages"].append(package)
dep_file.write(sublime.encode_value(dependencies, True))
dep_file.close()
def getJsonOrGenerate(name, callback):
filename = getI18nCachePath() + name + ".json"
if os.path.exists(filename):
with open(filename, "r", encoding="utf8") as f:
json = f.read(10485760)
content = sublime.decode_value(json)
else:
content = callback()
dirname = os.path.dirname(filename)
if not os.path.isdir(dirname):
os.makedirs(dirname)
with open(filename, "w", encoding="utf8") as f:
f.write(sublime.encode_value(content))
return content
def load(self, default=[]):
self.fdir = os.path.dirname(self.fpath)
if not os.path.isdir(self.fdir):
os.makedirs(self.fdir)
if os.path.exists(self.fpath):
with open(self.fpath, mode='r', encoding=self.encoding) as f:
content = f.read()
try:
data = sublime.decode_value(content)
except Exception:
sublime.message_dialog('%s is bad!' % self.fpath)
raise
if not data:
data = default
else:
with open(self.fpath, mode='w', encoding=self.encoding, newline='\n') as f:
data = default
f.write(sublime.encode_value(data, True))
return data
