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