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 _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)