def setUp(self):
self.kbs = sublime.decode_value(
sublime.load_resource(
'Packages/Vintageous/Default.sublime-keymap'))
self.known_kbs = sublime.decode_value(
sublime.load_resource(
'Packages/Vintageous/tests/data/Default.sublime-keymap'))
def run(self, cmd, code):
"""
Attempt to parse code as JSON.
Returns '' if it succeeds, the error message if it fails.
Use ST's loose parser for its setting files, or when specified.
"""
is_sublime_file = os.path.splitext(
self.filename)[1].startswith('.sublime-')
if self.settings.get('strict') and not is_sublime_file:
strict = True
else:
strict = False
try:
if strict:
self.regex = self.strict_regex
json.loads(code)
else:
self.regex = self.loose_regex
sublime.decode_value(code)
return ''
except ValueError as err:
return str(err)
def __init__(self, scheme_file, color_filter=None):
"""Initialize."""
if color_filter is None:
color_filter = self.filter
self.legacy = not scheme_file.lower().endswith('.sublime-color-scheme')
self.color_scheme = path.normpath(scheme_file)
self.scheme_file = path.basename(self.color_scheme)
if self.legacy:
self.scheme_obj = color_filter(
readPlistFromBytes(
re.sub(
br"^[\r\n\s]*<!--[\s\S]*?-->[\s\r\n]*|<!--[\s\S]*?-->", b'',
sublime.load_binary_resource(sublime_format_path(self.color_scheme))
)
)
)
else:
sublime.decode_value(
sublime.load_resource(sublime_format_path(self.color_scheme)),
preserve_lines=True
)
self.scheme_file = scheme_file
self.matched = {}
self.variables = {}
self.parse_scheme()
def decodeEntity(xml, category='iso'):
global entities
if not isinstance(xml, str):
return xml
if entities[category]:
forward, reverse = entities[category]
else:
if category == 'iso':
forward = sublime.decode_value(sublime.load_resource('Packages/' + package_name + '/IsoEntities.json'))
elif category == 'html':
forward = sublime.decode_value(sublime.load_resource('Packages/' + package_name + '/HtmlEntities.json'))
reverse = dict((v, k) for k, v in forward.items())
entities[category] = (forward, reverse)
def parseEntity(match):
entity = match.group(1)
try:
if entity.isdigit():
return reverse[int(entity)]
else:
return chr(forward[entity])
except:
return match.group(0)
xml = re.sub('&([a-zA-Z0-9]+);', parseEntity, xml)
return xml
def reload_settings(self):
self.settings_default = sublime.decode_value(sublime.load_resource(from_package('Mediawiker.sublime-settings')))
self.settings = sublime.load_settings('Mediawiker.sublime-settings')
try:
self.settings_user = sublime.decode_value(sublime.load_resource(from_package('Mediawiker.sublime-settings', name='User')))
except IOError:
self.settings_user = {}
def __init__(self):
self.client_id = "141"
self.client_secret = "4*ic:5WfF;LxE534"
self.settings = tools.load_settings("LaTeXing", mendeley_oauth_token="", mendeley_internal_cite_key=False, mendeley_cite_key_pattern="{Author}{year}")
# Load map
self.map = sublime.decode_value(sublime.load_resource("Packages/LaTeXing/latexing/api/mendeley.map"))
# bibtex: zotero type
self.type_map = self.map["types"]
# bibtex: zotero field
self.field_map = self.map["fields"]
# Check for user maps
try:
self.user_map = sublime.decode_value(sublime.load_resource("Packages/User/LaTeXing/mendeley.map"))
self.type_map.update(self.user_map["types"] if "types" in self.user_map else {})
self.field_map.update(self.user_map["fields"] if "fields" in self.user_map else {})
except:
pass
self.status = "Ok"
self.items = []
self.items_no_key = {}
def __init__(self):
self.client_key = "40af22476e380eadfef5"
self.client_secret = "ec5cfba3fb9fb063d0d4"
self.settings = tools.load_settings(
"LaTeXing",
zotero_user_key="",
zotero_user_id="",
zotero_cite_key_pattern="{Author}{year}")
# Load map
self.map = sublime.decode_value(
sublime.load_resource("Packages/LaTeXing/latexing/api/zotero.map"))
# bibtex: zotero type
self.type_map = self.map["types"]
# bibtex: zotero field
self.field_map = self.map["fields"]
# Check for user maps
try:
self.user_map = sublime.decode_value(
sublime.load_resource("Packages/User/LaTeXing/zotero.map"))
self.type_map.update(self.user_map["types"] if "types" in
self.user_map else {})
self.field_map.update(self.user_map["fields"] if "fields" in
self.user_map else {})
except:
pass
self.status = "Ok"
self.items = []
self.items_no_key = {}
def __init__(self):
self.client_key = "40af22476e380eadfef5"
self.client_secret = "ec5cfba3fb9fb063d0d4"
self.settings = tools.load_settings("LaTeXing",
zotero_user_key="",
zotero_user_id="",
zotero_cite_key_pattern="{Author}{year}"
)
# Load map
self.map = sublime.decode_value(sublime.load_resource("Packages/LaTeXing/latexing/api/zotero.map"))
# bibtex: zotero type
self.type_map = self.map["types"]
# bibtex: zotero field
self.field_map = self.map["fields"]
# Check for user maps
try:
self.user_map = sublime.decode_value(sublime.load_resource("Packages/User/LaTeXing/zotero.map"))
self.type_map.update(self.user_map["types"] if "types" in self.user_map else {})
self.field_map.update(self.user_map["fields"] if "fields" in self.user_map else {})
except:
pass
self.status = "Ok"
self.items = []
self.items_no_key = {}
def run(self, cmd, code):
"""
Attempt to parse code as JSON.
Returns '' if it succeeds, the error message if it fails.
Use ST's loose parser for its setting files, or when specified.
"""
is_sublime_file = os.path.splitext(self.filename)[1].startswith('.sublime-')
if self.get_view_settings().get('strict') and not is_sublime_file:
strict = True
else:
strict = False
try:
if strict:
self.regex = self.strict_regex
json.loads(code)
else:
self.regex = self.loose_regex
sublime.decode_value(code)
return ''
except ValueError as err:
return str(err)
def run(self, cmd, code):
"""Attempt to parse code as JSON, return '' if it succeeds, the error message if it fails."""
# Use ST's loose parser for its setting files.
strict = os.path.splitext(self.filename)[1] not in self.extensions
try:
if strict:
self.__class__.regex = self.strict_regex
# establish basic JSON compliance with in built python JSON library
template = json.loads(code)
# now validate against the AWS api
cfn = boto3.client('cloudformation')
template = cfn.validate_template(TemplateBody=code)
print(template)
else:
self.__class__.regex = self.loose_regex
sublime.decode_value(code)
return ''
except ValueError as err:
return str(err)
def merge_overrides(self):
"""Merge override schemes."""
package_overrides = []
user_overrides = []
if self.scheme_file.endswith('.hidden-color-scheme'):
pattern = '%s.hidden-color-scheme'
else:
pattern = '%s.sublime-color-scheme'
for override in sublime.find_resources(
pattern % path.splitext(self.scheme_file)[0]):
if override.startswith('Packages/User/'):
user_overrides.append(override)
else:
package_overrides.append(override)
for override in (package_overrides + user_overrides):
try:
ojson = sublime.decode_value(sublime.load_resource(override))
except IOError:
# Fallback if file was created manually and not yet found in resources
# Though it is unlikely this would ever get executed as `find_resources`
# probably wouldn't have seen it either.
with codecs.open(packages_path(override),
'r',
encoding='utf-8') as f:
ojson = sublime.decode_value(sanitize_json(f.read()))
for k, v in ojson.get('variables', {}).items():
self.scheme_obj['variables'][k] = v
for k, v in ojson.get(GLOBAL_OPTIONS, {}).items():
self.scheme_obj[GLOBAL_OPTIONS][k] = v
for item in ojson.get('rules', []):
self.scheme_obj['rules'].append(item)
self.overrides.append(override)
# Rare case of being given a file but sublime hasn't indexed the files and can't find it
if (not self.overrides and self.color_scheme.endswith(
('.sublime-color-scheme', '.hidden-color-scheme'))
and self.color_scheme.startswith('Packages/')):
with codecs.open(packages_path(self.color_scheme),
'r',
encoding='utf-8') as f:
ojson = sublime.decode_value(sanitize_json(f.read()))
for k, v in ojson.get('variables', {}).items():
self.scheme_obj['variables'][k] = v
for k, v in ojson.get(GLOBAL_OPTIONS, {}).items():
self.scheme_obj[GLOBAL_OPTIONS][k] = v
for item in ojson.get('rules', []):
self.scheme_obj['rules'].append(item)
self.overrides.append(self.color_scheme)
def _parse_snippet_xml(self, name, xml):
snippet = {}
for node in xml.childNodes:
if node.nodeType == node.ELEMENT_NODE:
value_node = node.firstChild
if value_node == None:
continue
snippet[node.tagName] = value_node.data
if len(snippet) == 0:
return None
if 'content' not in snippet:
return None
if 'context' in snippet:
snippet['context'] = sublime.decode_value(snippet['context'])
if 'commands' in snippet:
snippet['commands'] = sublime.decode_value(snippet['commands'])
if snippet['content'][0] == "\n":
snippet['content'] = snippet['content'][1:]
if snippet['content'][len(snippet['content']) - 1] == "\n":
snippet['content'] = snippet['content'][:len(snippet['content']) - 1]
if len(snippet['content']) == 0:
return None
if 'scope' in snippet:
# load old snippets
snippet['_scope'] = snippet['scope']
is_old = (
re.search(r'^\(?([\w\+]+\.[\w\+]+,?\s*)*$', snippet['scope']) != None or
'++' in snippet['scope']
)
if is_old:
snippet['scope'] = (
'((?:\W|^)' + snippet['scope'].
replace(', ', '(?:\W|$)|(?:\W|^)').
replace('+', '\\+').replace('.', '\\.') + '(?:\W|$))'
)
snippet['scope'] = re.compile(snippet['scope'])
snippet['name'], _ = os.path.splitext(os.path.basename(name))
snippet['path'] = name
if 'order' in snippet:
snippet['order'] = int(snippet['order'])
return snippet
def reload_settings(self):
self.settings_default = sublime.decode_value(
sublime.load_resource(from_package('Mediawiker.sublime-settings')))
self.settings = sublime.load_settings('Mediawiker.sublime-settings')
try:
self.settings_user = sublime.decode_value(
sublime.load_resource(
from_package('Mediawiker.sublime-settings', name='User')))
except IOError:
self.settings_user = {}
def library(self):
url = "/documents?limit=500&reverse=false&order=asc&view=all"
json_documents = sublime.decode_value(self.client.get(url))
documents = json_documents
while len(json_documents) == 500:
json_documents = sublime.decode_value(self.client.get(url + "&marker=" + json_documents[-1]['id']))
documents += json_documents
return documents
def settings(self, attr):
DEFAULT = 'Packages/MarkdownTOC/MarkdownTOC.sublime-settings'
files = sublime.find_resources('MarkdownTOC.sublime-settings')
files.remove(DEFAULT)
settings = sublime.decode_value(sublime.load_resource(DEFAULT))
for f in files:
user_settings = sublime.decode_value(sublime.load_resource(f))
if user_settings != None:
Util.dict_merge(settings, user_settings)
return settings[attr]
def _parse_snippet_xml(self, name, xml):
snippet = {}
for node in xml.childNodes:
if node.nodeType == node.ELEMENT_NODE:
value_node = node.firstChild
if value_node == None:
continue
snippet[node.tagName] = value_node.data
if len(snippet) == 0:
return None
if 'content' not in snippet:
return None
if 'context' in snippet:
snippet['context'] = sublime.decode_value(snippet['context'])
if 'commands' in snippet:
snippet['commands'] = sublime.decode_value(snippet['commands'])
if snippet['content'][0] == "\n":
snippet['content'] = snippet['content'][1:]
if snippet['content'][len(snippet['content']) - 1] == "\n":
snippet['content'] = snippet['content'][:len(snippet['content']) -
1]
if len(snippet['content']) == 0:
return None
if 'scope' in snippet:
# load old snippets
snippet['_scope'] = snippet['scope']
is_old = (re.search(r'^\(?([\w\+]+\.[\w\+]+,?\s*)*$',
snippet['scope']) != None
or '++' in snippet['scope'])
if is_old:
snippet['scope'] = ('((?:\W|^)' + snippet['scope'].replace(
', ', '(?:\W|$)|(?:\W|^)').replace('+', '\\+').replace(
'.', '\\.') + '(?:\W|$))')
snippet['scope'] = re.compile(snippet['scope'])
snippet['name'], _ = os.path.splitext(os.path.basename(name))
snippet['path'] = name
if 'order' in snippet:
snippet['order'] = int(snippet['order'])
return snippet
def merge_overrides(self):
"""Merge override schemes."""
package_overrides = []
user_overrides = []
if self.scheme_file.endswith('.hidden-color-scheme'):
pattern = '%s.hidden-color-scheme'
else:
pattern = '%s.sublime-color-scheme'
for override in sublime.find_resources(pattern % path.splitext(self.scheme_file)[0]):
if override.startswith('Packages/User/'):
user_overrides.append(override)
else:
package_overrides.append(override)
for override in (package_overrides + user_overrides):
try:
ojson = sublime.decode_value(sublime.load_resource(override))
except IOError:
# Fallback if file was created manually and not yet found in resources
# Though it is unlikely this would ever get executed as `find_resources`
# probably wouldn't have seen it either.
with codecs.open(packages_path(override), 'r', encoding='utf-8') as f:
ojson = sublime.decode_value(sanitize_json(f.read()))
for k, v in ojson.get('variables', {}).items():
self.scheme_obj['variables'][k] = v
for k, v in ojson.get(GLOBAL_OPTIONS, {}).items():
self.scheme_obj[GLOBAL_OPTIONS][k] = v
for item in ojson.get('rules', []):
self.scheme_obj['rules'].append(item)
self.overrides.append(override)
# Rare case of being given a file but sublime hasn't indexed the files and can't find it
if (
not self.overrides and
self.color_scheme.endswith(('.sublime-color-scheme', '.hidden-color-scheme')) and
self.color_scheme.startswith('Packages/')
):
with codecs.open(packages_path(self.color_scheme), 'r', encoding='utf-8') as f:
ojson = sublime.decode_value(sanitize_json(f.read()))
for k, v in ojson.get('variables', {}).items():
self.scheme_obj['variables'][k] = v
for k, v in ojson.get(GLOBAL_OPTIONS, {}).items():
self.scheme_obj[GLOBAL_OPTIONS][k] = v
for item in ojson.get('rules', []):
self.scheme_obj['rules'].append(item)
self.overrides.append(self.color_scheme)
def castStringAsDict(variables):
if variables != None:
if (type(variables) is dict) != True:
try:
if (variables.strip() != ""):
try:
variables = sublime.decode_value(
variables) # may throw ValueError
except:
# we do try some simple things
if re.match("[a-zA-z_]\\w*?=[^\"]*$",
variables) != None:
key, val = variables.split("=", 1)
variables = sublime.decode_value(
"{\"" + key + "\":\"" + val +
"\"}") # may still throw ValueError
elif re.match("(['\"])[^'\"]*?\\1=(['\"])[^'\"]*?\\2",
variables) != None:
key, val = variables.split("\"=\"", 1)
variables = sublime.decode_value(
"{" + key + "\":\"" + val +
"}") # may still throw ValueError
elif re.match("(['\"])[^'\"]?\\1\\:(['\"])[^'\"]*?\\2",
variables) != None:
variables = sublime.decode_value(
"{" + variables +
"}") # may still throw ValueError
#end if
#end try
# Still not dict?
if (type(variables) is dict) != True:
raise ValueError("still no dict after stringdecode")
else:
variables = dict()
#end if variables empty
except: # AttributeError (strip) if no string, ValueError from decode, or raised
raise ValueError(
"variables argument can not be converted to / used as dict"
)
#end except
#end if variables not dict already
return variables
#end def
def decodeEntity(xml, category='iso'):
global entities
if not isinstance(xml, str):
return xml
if entities[category]:
forward, reverse = entities[category]
else:
resourceMap = {
"iso": "IsoEntities.json",
"html": "HtmlEntities.json",
}
forward = sublime.decode_value(sublime.load_resource('Packages/' + package_name + '/' + resourceMap[category]))
reverse = dict((v, k) for k, v in forward.items())
entities[category] = (forward, reverse)
def parseEntity(match):
entity = match.group(1)
try:
if entity.isdigit():
return reverse[int(entity)]
else:
return chr(forward[entity])
except:
return match.group(0)
xml = re.sub('&([a-zA-Z0-9]+);', parseEntity, xml)
return xml
def load_tag_list():
tags_to_filter = [
'abort',
'admin',
'case',
'catch',
'component',
'continue',
'defaultcase',
'else',
'elseif',
'exit',
'finally',
'function',
'if',
'interface',
'rethrow',
'retry',
'return',
'script',
'servlet',
'servletparam',
'set',
'sleep',
'switch',
'try',
'while',
]
tags = sublime.load_resource(
"Packages/CFML/src/basecompletions/json/cfml_tags.json"
)
tags = sublime.decode_value(tags).keys()
return [t.lower()[2:] for t in tags if t.lower()[2:] not in tags_to_filter]
def getBowerPackages(self):
if (self._bowerComponents is not None):
return
cacheFile = self.getCachePath() + "\\bower-component-list.json"
if not os.path.isfile(cacheFile):
apiUrl = 'https://bower-component-list.herokuapp.com'
## TODO: do it async
urllib.request.urlretrieve(apiUrl, cacheFile)
content = self.file_get_contents(cacheFile)
self._bowerComponents = []
for idx, val in enumerate(sublime.decode_value(content)):
name = val.get('name')
desc = val.get('description', "Description not provided")
updated = val.get('updated', "Last updated not provided")
stars = 0 if not val['stars'] else val['stars']
if ((not name) or (not desc) or (not updated) or stars < 1):
continue
component = [name, desc, updated]
self._bowerComponents.append(component)
def folders(self):
client = ZoteroClient(self.client_key, self.client_secret,
self.settings["zotero_user_key"],
self.settings["zotero_user_id"])
url = "/collections?content=json"
x = xml.etree.ElementTree.fromstring(client.get(url))
json_folders = []
for folder in x.findall(
"{http://www.w3.org/2005/Atom}entry/{http://www.w3.org/2005/Atom}content"
):
json_folders += [sublime.decode_value((folder.text))]
def build_folder_path(folder):
path = [folder["name"]]
if not folder["parentCollection"]:
return path
else:
for item in json_folders:
if folder["parentCollection"] == item["collectionKey"]:
path = build_folder_path(item) + path
return path
folders = {}
for folder in json_folders:
folders[folder["collectionKey"]] = "/".join(
build_folder_path(folder))
return folders
def getLanguageIndex(language):
global languages_index
if not languages_index.get(language):
index_json = sublime.decode_value(
sublime.load_resource(getLanguagePath(language) + '/index.json'))
languages_index[language] = index_json["entries"]
return languages_index[language]
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 on_activated(self):
workspace_path = self.view.window().project_file_name().replace('sublime-project','sublime-Hotkeyfolders')
if os.path.exists(workspace_path):
with open(workspace_path, 'r') as file:
data = sublime.decode_value(file.read())
if data and 'root' in data:
self.view.set_status('root','❤ ' + data['root'] + ' 💜')
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 analyse_package(self, filepath):
"""
Analyse package source and returns package informations
@param filename: a path to package file
"""
try:
packages = sublime.decode_value(sublime.load_resource(filepath))
except ValueError as e:
ActionHistory().add_action(
"javatar.core.packages_loader_thread.analyse_package",
"Invalid JSON package [file=" + filepath + "]",
e
)
else:
if "experiment" in packages and packages["experiment"]:
return None
filename = basename(filepath)
if "name" in packages:
filename = packages["name"]
count = self.count_classes(packages)
self.installed_packages.append({"name": filename,
"path": filepath})
Logger().log(
'Package "{}" loaded with {} classes in {} packages'
.format(
filename,
count[1],
count[0]
)
)
return packages
return None
def process_message(self) -> None:
"""Called when a full line has been read from the socket
"""
message = b"".join(self.rbuffer)
self.rbuffer = []
try:
data = sublime.decode_value(message.decode("utf8"))
except (NameError, ValueError):
data = json.loads(message.replace(b"\t", b" " * 8).decode("utf8"))
callback = self.pop_callback(data.pop("uid"))
if callback is None:
logger.error(
"Received {} from the JSONServer but there is not callback "
"to handle it. Aborting....".format(message)
)
try:
callback(data)
except Exception as error:
logging.error(error)
for traceback_line in traceback.format_exc().splitlines():
logging.error(traceback_line)
def process_message(self) -> None:
"""Called when a full line has been read from the socket
"""
message = b''.join(self.rbuffer)
self.rbuffer = []
try:
data = sublime.decode_value(message.decode('utf8'))
except (NameError, ValueError):
data = json.loads(message.replace(b'\t', b' ' * 8).decode('utf8'))
callback = self.pop_callback(data.pop('uid'))
if callback is None:
logger.error(
'Received {} from the JSONServer but there is not callback '
'to handle it. Aborting....'.format(message)
)
try:
callback(data)
except Exception as error:
logging.error(error)
for traceback_line in traceback.format_exc().splitlines():
logging.error(traceback_line)
def read_client_config(
name: str,
client_config: Dict,
base_settings_path: Optional[str] = None) -> ClientConfig:
if base_settings_path:
base = sublime.decode_value(sublime.load_resource(base_settings_path))
settings = DottedDict(base.get("settings", {}))
init_options = DottedDict(base.get("initializationOptions", {}))
else:
settings = DottedDict()
init_options = DottedDict()
settings.update(client_config.get("settings",
{})) # overrides from the user
init_options.update(client_config.get("initializationOptions",
{})) # overrides from the user
languages = read_language_configs(client_config)
return ClientConfig(name, client_config.get("command", []),
client_config.get("tcp_port", None),
client_config.get("scopes", []),
client_config.get("syntaxes", []),
client_config.get("languageId", ""), languages,
client_config.get("enabled", False), init_options,
settings, client_config.get("env", dict()),
client_config.get("tcp_host", None),
client_config.get("tcp_mode", None),
client_config.get("experimental_capabilities", dict()))
def parseJSON(self, package, name, ext):
if ST2:
path = os.path.join(sublime.packages_path(), package,
name + '.' + ext)
if not os.path.isfile(path):
path = os.path.join(sublime.packages_path(), package,
'Default.' + ext)
if not os.path.isfile(path):
return None
with codecs.open(path) as f:
content = self.removeComments(f.read())
if f is not None:
f.close()
try:
parsedJSON = json.loads(content, cls=ConcatJSONDecoder)
except (ValueError):
return None
return parsedJSON[0]
else:
try:
resource = sublime.load_resource('Packages/' + package + '/' +
name + '.' + ext)
except (IOError):
try:
resource = sublime.load_resource('Packages/' + package +
'/Default.' + ext)
except (IOError):
return None
return sublime.decode_value(resource)
def manage_package(self, package):
self.done = False
file_list = list_package_files(package)
platform_keymap = "default (%s).sublime-keymap" % (PLATFORM.lower())
for filename in file_list:
if filename.lower().endswith("default.sublime-keymap")or \
filename.lower().endswith(platform_keymap):
content = get_resource(package, filename)
if content == None:
continue
try:
if VERSION < 3013:
minified_content = json_minify(content)
minified_content = strip_dangling_commas(minified_content)
minified_content = minified_content.replace("\n", "\\\n")
if self.debug:
self.debug_minified[package] = minified_content
key_map = json.loads(minified_content)
else:
key_map = sublime.decode_value(content)
except:
if not self.prev_error:
traceback.print_exc()
self.prev_error = True
sublime.error_message("Could not parse a keymap file. See console for details")
#error_path = os.path.join(os.path.basename(orig_path), filename)
logger.warning("FindKeyConflicts[Warning]: An error " + "occured while parsing '" + package + "'")
continue
self.handle_key_map(package, key_map)
self.done = True
def get_super_menu():
"""Create a menu, which contains all menus."""
if hasattr(get_super_menu, "super_menu"):
return get_super_menu.super_menu
menus = sublime.find_resources("*.sublime-menu")
super_menu = MenuEntry("Super")
for menu_path in menus:
menu_id = menu_path.split("/")[-1].split(".")[0]
res_str = sublime.load_resource(menu_path)
mobj = sublime.decode_value(res_str)
super_menu.add_child({
"id": menu_id,
"children": mobj
})
# manually create and add a syntax selection menu
syntax_menu = build_syntax_menu()
for i, child in enumerate(super_menu.children):
if child.iden == "Syntax":
super_menu.children[i] = syntax_menu
break
else:
super_menu.children.append(syntax_menu)
get_super_menu.super_menu = super_menu
return super_menu
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 merge_overrides(self):
"""Merge override schemes."""
package_overrides = []
user_overrides = []
for override in sublime.find_resources(
'%s.sublime-color-scheme' %
path.splitext(self.scheme_file)[0]):
if override.startswith('Packages/User/'):
user_overrides.append(override)
else:
package_overrides.append(override)
for override in (package_overrides + user_overrides):
ojson = sublime.decode_value(sublime.load_resource(override))
for k, v in ojson.get('variables', {}).items():
self.scheme_obj['variables'][k] = v
for k, v in ojson.get(GLOBAL_OPTIONS, {}).items():
self.scheme_obj[GLOBAL_OPTIONS][k] = v
for item in ojson.get('rules', []):
self.scheme_obj['rules'].append(item)
self.overrides.append(override)
def read_json(file):
if not os.path.isfile(file):
return None
fo = open(file, "r")
data = fo.read()
fo.close()
return sublime.decode_value(data)
def decodeEntity(xml, category="iso"):
global entities
if not isinstance(xml, str):
return xml
if entities[category]:
forward, reverse = entities[category]
else:
resourceMap = {"iso": "IsoEntities.json", "html": "HtmlEntities.json"}
forward = sublime.decode_value(sublime.load_resource("Packages/" + package_name + "/" + resourceMap[category]))
reverse = dict((v, k) for k, v in forward.items())
entities[category] = (forward, reverse)
def parseEntity(match):
entity = match.group(1)
try:
if entity.isdigit():
return reverse[int(entity)]
else:
return chr(forward[entity])
except:
return match.group(0)
xml = re.sub("&([a-zA-Z0-9]+);", parseEntity, xml)
return xml
def from_sublime_settings(cls, name: str, s: sublime.Settings,
file: str) -> "ClientConfig":
base = sublime.decode_value(sublime.load_resource(file))
settings = DottedDict(base.get("settings",
{})) # defined by the plugin author
settings.update(read_dict_setting(s, "settings",
{})) # overrides from the user
init_options = DottedDict(base.get("initializationOptions", {}))
init_options.update(read_dict_setting(s, "initializationOptions", {}))
disabled_capabilities = s.get("disabled_capabilities")
file_watcher = cast(FileWatcherConfig,
read_dict_setting(s, "file_watcher", {}))
if isinstance(disabled_capabilities, dict):
disabled_capabilities = DottedDict(disabled_capabilities)
else:
disabled_capabilities = DottedDict()
return ClientConfig(
name=name,
selector=_read_selector(s),
priority_selector=_read_priority_selector(s),
schemes=s.get("schemes"),
command=read_list_setting(s, "command", []),
tcp_port=s.get("tcp_port"),
auto_complete_selector=s.get("auto_complete_selector"),
# Default to True, because an LSP plugin is enabled iff it is enabled as a Sublime package.
enabled=bool(s.get("enabled", True)),
init_options=init_options,
settings=settings,
env=read_dict_setting(s, "env", {}),
experimental_capabilities=s.get("experimental_capabilities"),
disabled_capabilities=disabled_capabilities,
file_watcher=file_watcher,
path_maps=PathMap.parse(s.get("path_maps")))
def classes_in_file(self, file_path):
if not JavaUtils().is_java_file(file_path):
return []
classes = []
try:
parser = GrammarParser(sublime.decode_value(sublime.load_resource(
"Packages/Javatar/grammars/Java8.javatar-grammar"
)))
java_file = open(file_path, "r")
source_code = java_file.read()
java_file.close()
parse_output = parser.parse_grammar(source_code)
if parse_output["success"]:
class_names = parser.find_by_selectors(
Settings().get("class_declaration_name_selector"),
)
for class_name in class_names:
nodes = parser.find_by_selectors(
Settings().get("class_members_filter_selector") % (
class_name["value"]
)
)
classes.append({
"name": class_name["value"],
"nodes": nodes
})
except Exception as e:
ActionHistory().add_action(
"javatar.core.java_structure.classes_in_file",
"Error while parsing",
e
)
return classes
def decode_value(string):
# print("decode_value")
if hasattr(sublime, 'decode_value'):
return sublime.decode_value(string)
else:
lines = [line for line in string.split("\n") if not re.search(r'//.*', line)]
return json.loads("\n".join(lines))
def process_message(self):
"""Called when a full line has been read from the socket
"""
message = b''.join(self.rbuffer)
self.rbuffer = []
try:
data = sublime.decode_value(message.decode('utf8'))
except NameError:
data = json.loads(message.decode('utf8'))
callback = self.callbacks.pop(data.pop('uid'))
if callback is None:
logger.error(
'Received {} from the JSONServer but there is not callback '
'to handle it. Aborting....'.format(message)
)
try:
callback(data)
except Exception as error:
logging.error(error)
for traceback_line in traceback.format_exc().splitlines():
logging.error(traceback_line)
def getConnections():
connections = {}
directory = os.path.join(sublime.packages_path(), 'User', global_settings.get('configs_folder'))
if not os.path.isdir(directory):
try:
os.makedirs(directory)
except OSError as exc: # Python >2.5
if exc.errno == errno.EEXIST and os.path.isdir(directory):
pass
else: raise
for name in os.listdir(directory):
if name[:1] == '.':
continue
json = None
with open(os.path.join(directory, name)) as f:
try:
json = sublime.decode_value(f.read())
except Exception as e:
debug('could not load config file(%s): %s' % (name, e))
continue
json['name'] = name
connections[name] = json
return collections.OrderedDict(sorted(connections.items(), key=lambda k: k))
def analyse_package(self, filepath):
add_action(
"javatar.util.collection.analyse_import",
"Analyse package [file=" + filepath + "]"
)
try:
imports = sublime.decode_value(sublime.load_resource(filepath))
except ValueError:
sublime.error_message("Invalid JSON format")
else:
if "experiment" in imports and imports["experiment"]:
return None
filename = basename(filepath)
if "name" in imports:
filename = imports["name"]
count = self.count_classes(imports)
self.installed_packages.append({"name": filename, "path": filepath})
print(
'Javatar package "{}" loaded with {} classes in {} packages'
.format(
filename,
count[1],
count[0]
)
)
return imports
return None
def on_pre_close(self, view):
if not view.settings().get('rust_environment_editor'):
return
settings = view.settings().get('rust_environment_editor_settings')
contents = view.substr(sublime.Region(0, view.size()))
try:
result = sublime.decode_value(contents)
except:
sublime.error_message('Value was not valid JSON, try again.')
view.window().run_command('cargo_set_environment_editor', {
'package': settings.get('package'),
'which': settings['which'],
'variant': settings.get('variant'),
'target': settings.get('target'),
'contents': contents,
})
return
view.window().run_command('cargo_set_environment', {
'package': settings.get('package'),
'which': settings['which'],
'variant': settings.get('variant'),
'target': settings.get('target'),
'env': result,
})
def classes_in_file(self, file_path):
if not JavaUtils().is_java_file(file_path):
return []
classes = []
try:
parser = GrammarParser(
sublime.decode_value(
sublime.load_resource(
"Packages/Javatar/grammars/Java8.javatar-grammar")))
java_file = open(file_path, "r")
source_code = java_file.read()
java_file.close()
parse_output = parser.parse_grammar(source_code)
if parse_output["success"]:
class_names = parser.find_by_selectors(
Settings().get("class_declaration_name_selector"), )
for class_name in class_names:
nodes = parser.find_by_selectors(
Settings().get("class_members_filter_selector") %
(class_name["value"]))
classes.append({
"name": class_name["value"],
"nodes": nodes
})
except Exception as e:
ActionHistory().add_action(
"javatar.core.java_structure.classes_in_file",
"Error while parsing", e)
return classes
def __init__(self, scheme_file, color_filter=None):
"""Initialize."""
if color_filter is None:
color_filter = self.filter
self.legacy = not scheme_file.lower().endswith(
'.sublime-color-scheme') if NEW_SCHEMES else True
self.color_scheme = path.normpath(scheme_file)
self.scheme_file = path.basename(self.color_scheme)
if self.legacy:
scheme_obj = readPlistFromBytes(
re.sub(
br"^[\r\n\s]*<!--[\s\S]*?-->[\s\r\n]*|<!--[\s\S]*?-->",
b'',
sublime.load_binary_resource(
sublime_format_path(self.color_scheme))))
self.convert_format(scheme_obj)
else:
self.scheme_obj = sublime.decode_value(
sublime.load_resource(sublime_format_path(self.color_scheme)))
if 'variables' not in self.scheme_obj:
self.scheme_obj['variables'] = {}
if GLOBAL_OPTIONS not in self.scheme_obj:
self.scheme_obj[GLOBAL_OPTIONS] = {}
if 'rules' not in self.scheme_obj:
self.scheme_obj['rules'] = []
self.overrides = []
if NEW_SCHEMES:
self.merge_overrides()
self.scheme_obj = color_filter(self.scheme_obj)
self.scheme_file = scheme_file
self.matched = {}
self.variables = {}
self.parse_scheme()
def allFunctions(self): """retorna todas las funciones""" modulos=sublime.decode_value(open(RutasPython.funciones()).read()) lista=[] for modulo in modulos: lista+=[ (funcion+"\t•"+modulo, self.ponerCursor(modulo+"."+funcion)) for funcion in modulos[modulo]] return sorted(lista)
def run(self, edit):
src_content = sublime.load_resource(
"Packages/LaTeXing/LaTeXing.sublime-settings")
src_json = sublime.decode_value(src_content)
items = [{
"key": key,
"value": value
} for key, value in sorted(src_json.items(),
key=lambda x: src_content.find(x[0]))
if isinstance(value, bool)]
settings = tools.load_settings(
"LaTeXing", **dict([item["key"], item["value"]] for item in items))
message = [[
"%s %s" %
("Enable" if not settings[item["key"]] else "Disable", item["key"])
] for item in items]
def on_done(i):
if i >= 0:
# Read/save preferences
tools.save_settings(
"LaTeXing",
**{items[i]["key"]: not settings[items[i]["key"]]})
sublime.status_message(
"%s is now %s" %
(items[i]["key"],
"disabled" if settings[items[i]["key"]] else "enabled"))
self.view.window().show_quick_panel(message, on_done)
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 __init__(self, on_complete=None):
self.running = True
self.on_complete = on_complete
self.parser = GrammarParser(sublime.decode_value(sublime.load_resource(
"Packages/Javatar/grammars/JavatarSnippet.javatar-grammar"
)))
threading.Thread.__init__(self)
def __init__(self, scheme_file, color_filter=None):
"""Initialize."""
if color_filter is None:
color_filter = self.filter
self.color_scheme = path.normpath(scheme_file)
self.scheme_file = path.basename(self.color_scheme)
content = sublime.load_binary_resource(
sublime_format_path(self.color_scheme))
if scheme_file.lower().endswith(
('.tmtheme',
'.hidden-tmtheme')) or IS_XML_RE.match(content) is not None:
self.legacy = True
self.convert_format(
readPlistFromBytes(XML_COMMENT_RE.sub(b'', content)))
else:
self.legacy = False
self.scheme_obj = sublime.decode_value(content.decode('utf-8'))
if 'variables' not in self.scheme_obj:
self.scheme_obj['variables'] = {}
if GLOBAL_OPTIONS not in self.scheme_obj:
self.scheme_obj[GLOBAL_OPTIONS] = {}
if 'rules' not in self.scheme_obj:
self.scheme_obj['rules'] = []
self.overrides = []
if NEW_SCHEMES:
self.merge_overrides()
self.scheme_obj = color_filter(self.scheme_obj)
self.scheme_file = scheme_file
self.matched = {}
self.variables = {}
self.parse_scheme()
def install(self, log: core.Logger) -> core.awaitable[None]:
try:
log.info('Installing adapter: {}'.format(self.name))
yield from core.run_in_executor(self.downalod_and_extract_blocking,
log)
vscode_package_file = os.path.join(self.path, 'extension',
'package.json')
snippets_output_file = os.path.join(self.path,
'sublime_debugger.json')
snippets = [] #type: List[dict]
with open(vscode_package_file, "rb") as file:
j = sublime.decode_value(file.read().decode('utf-8'))
for debugger in j.get('contributes', {}).get('debuggers', []):
snippets.extend(debugger.get('configurationSnippets', []))
with open(snippets_output_file, 'w') as file:
sublime_adapter_info = {
'configurationSnippets': snippets,
}
content = json.dumps(sublime_adapter_info)
# strip out unescaped stuff
# FIXME this isn't correct... but good enough for now...
content = content.replace('^\\\"', '')
content = content.replace('\\\"', '')
file.write(content)
log.info('Finished Installing adapter: {}'.format(self.name))
except Exception as e:
log.info('Failled Finished Installing adapter: {}'.format(e))
def parseJSON(self, package, name, ext):
if ST2:
path = os.path.join(sublime.packages_path(), package, name + '.' + ext)
if not os.path.isfile(path):
path = os.path.join(sublime.packages_path(), package, 'Default.' + ext)
if not os.path.isfile(path):
return None
return None
with codecs.open(path) as f:
content = self.removeComments(f.read())
if f is not None:
f.close()
try:
parsedJSON = json.loads(content, cls=ConcatJSONDecoder)
except (ValueError):
return None
return parsedJSON[0]
else:
try:
resource = sublime.load_resource('Packages/' + package + '/' + name + '.' + ext)
except (IOError):
try:
resource = sublime.load_resource('Packages/' + package + '/Default.' + ext)
except (IOError):
return None
return None
return sublime.decode_value(resource)
def on_pre_close(self, view):
if not view.settings().get('rust_environment_editor'):
return
settings = view.settings().get('rust_environment_editor_settings')
contents = view.substr(sublime.Region(0, view.size()))
try:
result = sublime.decode_value(contents)
except:
sublime.error_message('Value was not valid JSON, try again.')
view.window().run_command('cargo_set_environment_editor', {
'package': settings.get('package'),
'which': settings['which'],
'variant': settings.get('variant'),
'target': settings.get('target'),
'contents': contents,
})
return
view.window().run_command('cargo_set_environment', {
'package': settings.get('package'),
'which': settings['which'],
'variant': settings.get('variant'),
'target': settings.get('target'),
'env': result,
})
def _parse_settings(self, lines):
"""Parse the setting file and capture comments.
This is naive but gets the job done most of the time.
"""
content = []
comment = []
in_comment = False
for line in lines:
stripped = line.strip()
if in_comment:
if stripped.endswith("*/"):
in_comment = False
# remove all spaces and asterix
line = line.rstrip("*/ \t")
if line:
comment.append(line)
elif stripped.startswith("* "):
comment.append(stripped[2:])
else:
comment.append(line)
continue
# ignore empty lines if not in a comment
# empty line in comment may be used as visual separator
elif not stripped:
continue
if stripped.startswith("/*"):
in_comment = True
# remove all asterix
stripped = stripped[2:].lstrip("*")
if stripped:
comment.append(stripped)
continue
if stripped.startswith("//"):
# skip comment lines ending with `//` (likely used as separators)
# a standalone `//` adds an empty line as visual separator
stripped = stripped[2:]
if not stripped or not stripped.endswith("//"):
comment.append(stripped)
continue
content.append(line)
if comment:
# the json key is used as key for the comments located above it
match = re.match(r'"((?:[^"]|\\.)*)":', stripped)
if not match:
continue
key = match.group(1)
if key not in self.comments:
self.comments[key] = textwrap.dedent('\n'.join(comment))
comment.clear()
# Return decoded json file from content with stripped comments
return sublime.decode_value('\n'.join(content))
def get_animal(self, adjective):
data_file = sublime.load_resource("Packages/CreativeCrocodile/animals.json")
data = sublime.decode_value(data_file)
letter = adjective[:1].lower()
matchedAnimals = data[letter]
random.shuffle(matchedAnimals)
return matchedAnimals[0]
def run(self, cmd, code):
"""Attempt to parse code as JSON, return '' if it succeeds, the error message if it fails."""
# Use ST's loose parser for its setting files.
strict = os.path.splitext(self.filename)[1] not in self.extensions
try:
if strict:
self.__class__.regex = self.strict_regex
json.loads(code)
else:
self.__class__.regex = self.loose_regex
sublime.decode_value(code)
return ''
except ValueError as err:
return str(err)
