def run(self, edit): view = self.view if not view.file_name().endswith('.js'): return jsContent = jsmin(view.substr(Region(0, view.size()))).replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n') if not jsContent: return template = os.path.splitext(view.file_name())[0] + '.mist' templateView = view.window().find_open_file(template) if templateView: region = templateView.find('"script"\s*:\s*"\K.*?(?=",)', 0, 0) if region == Region(-1, -1): scriptLine = '"script": "' + jsContent + '",\n ' templateView.insert(edit, 4, scriptLine) print('当前脚本已插入 ' + template) else: if jsContent == templateView.substr(region): return templateView.replace(edit, region, jsContent) print('当前脚本已同步至 ' + template) sublime.set_timeout_async(lambda:templateView.run_command('save'), 50) else: if os.path.isfile(template): replaceJSInTemplate(template, jsContent)
def on_highlight(index): """Temporarily apply new skin, if quick panel selection changed. Arguments: index (int): Index of the highlighted skin. """ if index == -1: return self.last_selected = index def preview_skin(): # The selected row has changed since the timeout was created. if index != self.last_selected: return for key, val in skins[index][PREF].items(): # backup settings before changing the first time if key not in initial_prefs: initial_prefs[key] = self.prefs.get(key) if val: self.prefs.set(key, val) else: self.prefs.erase(key) # start timer to delay the preview a little bit sublime.set_timeout_async(preview_skin, 250)
def get_remote_tags_list(self, remote, remote_name): if "tags" in remote: if remote["tags"]: msg = "\n".join( " {} {}".format(tag.sha[:7], tag.tag) for tag in remote["tags"] if tag.tag[-3:] != "^{}" ) else: msg = NO_REMOTE_TAGS_MESSAGE elif "loading" in remote: msg = LOADING_TAGS_MESSAGE else: def do_tags_fetch(remote=remote, remote_name=remote_name): remote["tags"] = self.get_tags(remote_name, reverse=True) self.render() sublime.set_timeout_async(do_tags_fetch, 0) remote["loading"] = True msg = LOADING_TAGS_MESSAGE return self.template_remote.format( remote_name=remote_name, remote_tags_list=msg )
def on_load_async( self, view ): self.new_ColorScheme = None window = view.window() try: windowVariables = window.extract_variables() file = windowVariables[ "file" ] filePath = windowVariables[ "file_path" ] fileName = windowVariables[ "file_name" ] except( AttributeError, KeyError ) as e : return settings = sublime.load_settings( "ConditionalColorSchemes.sublime-settings" ) preferred_ColorScheme_Set = settings.get( "preferred_ColorScheme_Set", "" ) include_FileName_In_FilePath = settings.get( "include_FileName_In_FilePath", "" ) fileName_ColorSchemes = settings.get( "fileName_ColorSchemes", [] ) filePath_ColorSchemes = settings.get( "filePath_ColorSchemes", [] ) if include_FileName_In_FilePath == True: filePath = file if preferred_ColorScheme_Set == "filePath_ColorSchemes": self.get_Conditional_ColorScheme( fileName, fileName_ColorSchemes ) self.get_Conditional_ColorScheme( filePath, filePath_ColorSchemes ) elif preferred_ColorScheme_Set == "fileName_ColorSchemes": self.get_Conditional_ColorScheme( filePath, filePath_ColorSchemes ) self.get_Conditional_ColorScheme( fileName, fileName_ColorSchemes ) if self.new_ColorScheme != None: set_ColorScheme = lambda: view.settings().set( "color_scheme", self.new_ColorScheme ) sublime.set_timeout_async( set_ColorScheme )
def run(self, edit): interface = ui.get_interface(self.view.id()) non_cached_sections = (interface.get_view_regions("unstaged_files") + interface.get_view_regions("untracked_files") + interface.get_view_regions("merge_conflicts")) non_cached_lines = util.view.get_lines_from_regions( self.view, self.view.sel(), valid_ranges=non_cached_sections ) non_cached_files = ( os.path.join(self.repo_path, line.strip()) for line in non_cached_lines if line[:4] == " " ) cached_sections = interface.get_view_regions("staged_files") cached_lines = util.view.get_lines_from_regions( self.view, self.view.sel(), valid_ranges=cached_sections ) cached_files = ( os.path.join(self.repo_path, line.strip()) for line in cached_lines if line[:4] == " " ) sublime.set_timeout_async( lambda: self.load_diff_windows(non_cached_files, cached_files), 0)
def run(self, edit, key): self.key = key ''' mom_is_wash_the_rama МамаМылаРаму MamaMilaRamu фывыфв ''' sel = self.view.sel()[0] phrase = self.view.substr(sel) if '' == phrase.strip(): phrase = self.view.substr(self.view.line(sel)).strip() if '' == phrase: return if re.search('[a-z]', phrase, re.I) is not None: direction = 'en-ru' else: direction = 'ru-en' phrase = re.sub('[_\-]', ' ', phrase) phrase = re.sub('([A-ZА-Я])', r' \1', phrase) def translate(): self.request_translation(phrase, direction) sublime.set_timeout_async(translate, 0)
def on_selection(id): if id == -1: return selection = menu_options[id] if not selection.requires_action: return elif selection.menu_text == ADD_ALL_UNSTAGED_FILES: self.git("add", "--update", ".") scope_of_action = "all unstaged files" elif selection.menu_text == ADD_ALL_FILES: self.git("add", "--all") scope_of_action = "all files" elif selection.is_untracked: self.git("add", "--", selection.filename) scope_of_action = "`{}`".format(selection.filename) else: self.git("add", "--update", "--", selection.filename) scope_of_action = "`{}`".format(selection.filename) sublime.status_message("Successfully added `{}`.".format( scope_of_action)) sublime.set_timeout_async(self.run_async, 0)
def __init__(self, repo_path=None, view=None): if self._initialized: return self._initialized = True self.regions = {} subclass_attrs = (getattr(self, attr) for attr in vars(self.__class__).keys()) self.partials = { attr.key: attr for attr in subclass_attrs if callable(attr) and hasattr(attr, "key") } for attr in vars(self.__class__).keys(): if attr.startswith("template"): setattr(self, attr, dedent(getattr(self, attr))) if view: self.view = view self.render(nuke_cursors=False) else: self.create_view(repo_path) sublime.set_timeout_async(self.on_new_dashboard, 0) if hasattr(self, "tab_size"): self.view.settings().set("tab_size", self.tab_size) interfaces[self.view.id()] = self
def launch_simulator(file_name): QUICK_V3_ROOT = _find_environment_variable("QUICK_V3_ROOT") if QUICK_V3_ROOT == None: sublime.message_dialog("please set environment variable 'QUICK_V3_ROOT'") return WORKDIR = get_workdir(file_name) if WORKDIR == None: return BIN = "" ARG = " -workdir %s -search-path %s/quick" % (WORKDIR, QUICK_V3_ROOT) def _windows(): os.system("taskkill /F /IM simulator.exe") return QUICK_V3_ROOT + "/tools/simulator/runtime/win32/simulator.exe" def _mac(): os.system("ps -x|grep simulator|xargs kill -9") # os.system("open /Applications/Xcode.app") # QUICK_V3_ROOT + "/tools/simulator/runtime/mac/Simulator.app/Contents/MacOS/Simulator" # "/Users/liangxie/Desktop/work/qgl/frameworks/cocos2d-x/tools/simulator/runtime/mac/Simulator.app/Contents/MacOS/Simulator" return QUICK_V3_ROOT + "/tools/simulator/runtime/mac/Simulator.app/Contents/MacOS/Simulator" # return QUICK_V3_ROOT + "../Desktop/work/qgl/runtime/mac/qgl Mac.app/Contents/MacOS/qgl Mac" if _isWindows(): BIN = _windows() if _is_mac(): BIN = _mac() # if _isLinux(): _linux() sublime.set_timeout_async(lambda:os.system(BIN + ARG), 0)
def run(self, edit): logger.info("run GtagsJumpToDefinitionCommand!") # get current word self.symbol_name = self.view.substr(self.view.word(self.view.sel()[0].a)) if len(self.symbol_name) != 0: sublime.set_timeout_async(self.jump_to_definition, 1)
def _with_open_file(self, filename, f): """Opens filename (relative to the plugin) in a new view, calls f(view) to perform the tests. """ window = sublime.active_window() path = os.path.join(plugin_path, filename) view = window.open_file(path) q = queue.Queue() def async_test_view(): try: # Wait for view to finish loading. for n in range(500): if view.is_loading(): time.sleep(0.01) else: break else: raise AssertionError('View never loaded.') # Run the tests on this view. f(view) except Exception as e: q.put(e) else: q.put(None) try: sublime.set_timeout_async(async_test_view, 0) msg = q.get() if msg: raise msg finally: window.focus_view(view) window.run_command('close_file')
def run(self, edit): self.output = '' # async run the build so sublime doesn't hang sublime.set_timeout_async(self.buildruncheck) sublime.set_timeout_async(self.printoutput)
def start_stdout_watcher(self): sdk = SDK() t = StdoutWatcher(self, sdk.path) # Thread dies with the main thread. t.daemon = True # XXX: This is necessary. If we call t.start() directly, ST hangs. sublime.set_timeout_async(t.start, 0)
def on_enter_directory(self, path): self.suggested_git_root = path if self.suggested_git_root and os.path.exists(os.path.join(self.suggested_git_root, ".git")): sublime.ok_cancel_dialog(RECLONE_CANT_BE_DONE) return sublime.set_timeout_async(self.do_clone, 0)
def run(self, filename=None, limit=6000, author=None, log_current_file=False): self._pagination = 0 self._filename = filename self._limit = limit self._author = author self._log_current_file = log_current_file sublime.set_timeout_async(self.run_async)
def run(self, edit, reset=False): ignore_whitespace = self.view.settings().get("git_savvy.diff_view.ignore_whitespace") show_word_diff = self.view.settings().get("git_savvy.diff_view.show_word_diff") if ignore_whitespace or show_word_diff: sublime.error_message("You have to be in a clean diff to stage.") return None # Filter out any cursors that are larger than a single point. cursor_pts = tuple(cursor.a for cursor in self.view.sel() if cursor.a == cursor.b) self.diff_starts = tuple(region.a for region in self.view.find_all("^diff")) self.diff_header_ends = tuple(region.b for region in self.view.find_all("^\+\+\+.+\n(?=@@)")) self.hunk_starts = tuple(region.a for region in self.view.find_all("^@@")) hunk_starts_following_headers = {region.b for region in self.view.find_all("^\+\+\+.+\n(?=@@)")} self.hunk_ends = sorted(list( # Hunks end when the next diff starts. set(self.diff_starts[1:]) | # Hunks end when the next hunk starts, except for hunks # immediately following diff headers. (set(self.hunk_starts) - hunk_starts_following_headers) | # The last hunk ends at the end of the file. set((self.view.size(), )) )) sublime.set_timeout_async(lambda: self.apply_diffs_for_pts(cursor_pts, reset), 0)
def apply_diffs_for_pts(self, cursor_pts, reset): in_cached_mode = self.view.settings().get("git_savvy.diff_view.in_cached_mode") # Apply the diffs in reverse order - otherwise, line number will be off. for pt in reversed(cursor_pts): hunk_diff = self.get_hunk_diff(pt) # The three argument combinations below result from the following # three scenarios: # # 1) The user is in non-cached mode and wants to stage a hunk, so # do NOT apply the patch in reverse, but do apply it only against # the cached/indexed file (not the working tree). # 2) The user is in non-cached mode and wants to undo a line/hunk, so # DO apply the patch in reverse, and do apply it both against the # index and the working tree. # 3) The user is in cached mode and wants to undo a line hunk, so DO # apply the patch in reverse, but only apply it against the cached/ # indexed file. # # NOTE: When in cached mode, no action will be taken when the user # presses SUPER-BACKSPACE. self.git( "apply", "-R" if (reset or in_cached_mode) else None, "--cached" if (in_cached_mode or not reset) else None, "-", stdin=hunk_diff ) sublime.set_timeout_async(lambda: self.view.run_command("gs_diff_refresh"))
def run_async(self, commit_message=None): if commit_message is None: view_text = self.view.substr(sublime.Region(0, self.view.size())) help_text = self.view.settings().get("git_savvy.commit_view.help_text") commit_message = view_text.split(help_text)[0] include_unstaged = self.view.settings().get("git_savvy.commit_view.include_unstaged") show_panel_overrides = \ sublime.load_settings("GitSavvy.sublime-settings").get("show_panel_for") self.git( "commit", "-q" if "commit" not in show_panel_overrides else None, "-a" if include_unstaged else None, "--amend" if self.view.settings().get("git_savvy.commit_view.amend") else None, "-F", "-", stdin=commit_message ) # ensure view is not already closed (i.e.: when "commit_on_close" enabled) is_commit_view = self.view.settings().get("git_savvy.commit_view") if is_commit_view and self.view.window(): self.view.window().focus_view(self.view) self.view.set_scratch(True) # ignore dirty on actual commit self.view.window().run_command("close_file") else: sublime.set_timeout_async( lambda: util.view.refresh_gitsavvy(sublime.active_window().active_view()))
def run(self, edit): # check whether the lua files suffix_setting = self.view.settings().get('syntax') file_suffix = suffix_setting.split('.')[0] if file_suffix[-3:].lower() != 'lua': return # get lines of replacement r = sublime.Region(0, self.view.size()) self.view.unfold(r) # get characters of view lines = [] for region in self.view.lines(r): cache = self.view.substr(region) if len(cache) == 0: cache = ' ' lines.append(cache) # get cursor position before the replacement selection = self.view.sel()[0].b row, col = self.view.rowcol(selection) # replace the content after format print("Run Lua Format") self.view.replace(edit, r, lua_format(lines, get_settings())) # set tab_size from lua-format-setting self.view.run_command("set_setting", {"setting": "tab_size", "value": get_settings().get('tab_size', 4)}) # deal cursor position selection = self.view.full_line(self.view.text_point(row - 1, 0)).b cursor_pos = sublime.Region(selection, selection) regions = self.view.sel() regions.clear() regions.add(cursor_pos) sublime.set_timeout_async(lambda: self.view.show(cursor_pos), 0)
def on_selection(id): if id == -1: return selection = menu_options[id] if not selection.requires_action: return elif selection.menu_text == COMMIT: self.window.run_command("gs_quick_commit") return elif selection.menu_text == ADD_ALL_UNSTAGED_FILES: self.git("add", "--update", ".") scope_of_action = "all unstaged files" elif selection.menu_text == ADD_ALL_FILES: self.git("add", "--all") scope_of_action = "all files" elif selection.is_untracked: self.git("add", "--", selection.filename) scope_of_action = "`{}`".format(selection.filename) else: self.git("add", "--update", "--", selection.filename) scope_of_action = "`{}`".format(selection.filename) sublime.status_message("Successfully added `{}`.".format( scope_of_action)) util.view.refresh_gitsavvy(self.window.active_view()) sublime.set_timeout_async(self.run_async, 0)
def show_result(result): diffs = [] not_fixed = "" has_changes = False # merge diffs. for command_result in result: if 'diff' in command_result: diffs.append(command_result['diff']) not_fixed += command_result['not_fixed'] has_changes = has_changes or command_result.get('has_changes') # show status message. message = 'AutoPep8: No issues to fix.' if has_changes: message = 'AutoPep8: Issues were fixed.' sublime.status_message(message) show_error_panel(not_fixed) # show diff. if diffs: new_view('utf-8', '\n'.join(diffs)) sublime.set_timeout_async( lambda: sublime.status_message(''), STATUS_MESSAGE_TIMEOUT)
def run(self, i): if not self.thread.is_alive(): if hasattr(self.thread, 'result') and not self.thread.result: sublime.status_message('') return # After thread is end, display feedback to end user # according to response result = self.api.result if isinstance(result, dict) and "success" in result and not result["success"]: if self.open_console: util.show_output_panel(message.SEPRATE.format(util.format_error_message(result))) settings = context.get_settings() delay_seconds = settings["delay_seconds_for_hidden_output_panel_when_failed"] sublime.set_timeout_async(util.hide_output_panel, delay_seconds * 1000) else: sublime.status_message(self.success_message) return before = i % self.size after = (self.size - 1) - before sublime.status_message('%s [%s=%s]' % \ (self.message, ' ' * before, ' ' * after)) if not after: self.addend = -1 if not before: self.addend = 1 i += self.addend sublime.set_timeout(lambda: self.run(i), 100)
def start_command(self, file_name, use_bundler=False): is_legal, file_path, arguments = PathHelper.get_file(file_name, self.window) if is_legal: sublime.set_timeout_async(lambda file_path=file_path,bundle=use_bundler, args=arguments: self.start_command_async(file_path, bundle, *args), 0) else: sublime.message_dialog("File: " + file_path+" does not exists")
def init(self) -> None: """Initialize this project anagonda """ if self.AVAILABLE is True: self.install_tools() def monitor(): start = time.time() while not self.__tools_instaled() and time.time() - start <= 300: # noqa time.sleep(0.5) if time.time() - start >= 300: sublime.message_dialog( 'Go utils not available for this project, look at the ' 'log panel to fix any issue with your system, then ' 'restart Sublime Text 3' ) else: self._projects[self._project_name]['anagonda'] = True if os.name != 'nt': sublime.set_timeout_async( lambda: sublime.active_window().run_command( 'anaconda_go_fill_browse'), 0 ) sublime.set_timeout_async(lambda: monitor(), 0)
def run(self): scriptPath = inspect.getframeinfo(inspect.currentframe()).filename scriptDir = os.path.dirname(scriptPath) os.chdir(scriptDir) files = ",".join(sorted(BrowsersyncState.watchPaths)) index = sorted(BrowsersyncState.startFiles)[BrowsersyncState.startFileIndex] server = os.path.dirname(index) index = index.replace(server + "\\", "") plat = sublime.platform() killMethod = { 'osx': 'killall -KILL node-osx', 'linux': 'pkill -x node-linux', 'windows': 'taskkill /im node-windows.exe /f /t' }.get(plat) os.system(killMethod) cmd = 'node-{0} browser_sync_launch.js "{1}" "{2}" "{3}"' cmd = cmd.format(plat, server,files, index) sublime.set_timeout_async(self.make_callback(cmd), 0)
def oracle(self, end_offset, begin_offset=None, mode="describe", callback=None): """ Builds the oracle shell command and calls it, returning it's output as a string. """ pos = "#" + str(end_offset) if begin_offset is not None: pos = "#%i,#%i" %(begin_offset, end_offset) env = get_setting("env") # Build oracle cmd. cmd = "export GOPATH=\"%(go_path)s\"; export PATH=%(path)s; oracle -pos=%(file_path)s:%(pos)s -format=%(output_format)s %(mode)s %(scope)s" % { "go_path": env["GOPATH"], "path": env["PATH"], "file_path": self.view.file_name(), "pos": pos, "output_format": get_setting("oracle_format"), "mode": mode, # TODO if scpoe is not set, use main.go under pwd or sublime project path. "scope": ' '.join(get_setting("oracle_scope"))} if "GOROOT" in env: gRoot = "export GOROOT=\"%s\"; " % env["GOROOT"] cmd = gRoot + cmd sublime.set_timeout_async(lambda: self.runInThread(cmd, callback), 0)
def run(self, edit): """Command to index open tab RF file and create db index table. Purpose of the command is create index, from the open tab. Index should contain all the resource and library imports and all global variables from variable tables and imported variable files. """ log_file = get_setting(SettingObject.log_file) python_binary = get_setting(SettingObject.python_binary) table_dir = get_setting(SettingObject.table_dir) makedirs(path.dirname(log_file), exist_ok=True) open_tab = self.view.file_name() if not open_tab: message = 'Not able to index because no tabs are active' sublime.status_message(message) return db_table_name = self.get_table_name(open_tab) if db_table_name: file_ = open(log_file, 'a') sublime.set_timeout_async(self.run_single_index( python_binary, table_dir, db_table_name, file_ ), 0) file_.close() message = update_current_view_index(self.view) sublime.status_message(message) else: message = 'Not able to index file: {0}'.format(open_tab) sublime.status_message(message)
def run(self, edit, action=None, clr_tests=False, text=None, sync_out=True, crash_line=None, value=None): v = self.view scope_name = v.scope_name(v.sel()[0].begin()).rstrip() file_syntax = scope_name.split()[0] if action == 'insert': v.insert(edit, v.sel()[0].begin(), text) elif action == 'make_opd': self.close_opds() self.create_opd(clr_tests=clr_tests, sync_out=sync_out) elif action == 'show_crash_line': pt = v.text_point(crash_line - 1, 0) v.erase_regions('crash_line') v.add_regions('crash_line', [sublime.Region(pt + 0, pt + 0)], \ 'variable.language.python', 'bookmark', \ sublime.DRAW_SOLID_UNDERLINE) sublime.set_timeout_async(lambda pt=pt: v.show_at_center(pt), 39) # print(pt) elif action == 'get_var_value': self.get_var_value() elif action == 'show_var_value': self.show_var_value(value) elif action == 'toggle_using_debugger': self.toggle_using_debugger() elif action == 'sync_opdebugs': w = v.window() layout = w.get_layout() def slow_hide(w=w, layout=layout): if layout['cols'][1] < 1: layout['cols'][1] += 0.001 w.set_layout(layout) sublime.set_timeout(slow_hide, 1) else: layout['cols'][1] = 1 w.set_layout(layout) print('stopped') if len(layout['cols']) == 3: if layout['cols'][1] != 1: # hide opd panel self.ruler_opd_panel = min(layout['cols'][1], 0.93) layout['cols'][1] = 1 # <This Region May be uncomment> #for x in w.views_in_group(1): # x.run_command('test_manager', {'action': 'hide_text'}) # < / > # slow_hide() w.set_layout(layout) else: # show opd panel layout['cols'][1] = self.ruler_opd_panel need_x = self.ruler_opd_panel # < This Region May be uncomment > #for x in w.views_in_group(1): # x.run_command('test_manager', {'action': 'show_text'}) # < / > w.set_layout(layout)
def async_do(f, progress_msg="Evernote operation", done_msg=None): if not done_msg: done_msg = progress_msg + ': ' + "done!" status = {'done': False, 'i': 0} def do_stuff(s): try: f() except: pass finally: s['done'] = True def progress(s): if s['done']: sublime.status_message(done_msg) else: i = s['i'] bar = "... [%s=%s]" % (' '*i, ' '*(7-i)) sublime.status_message(progress_msg + bar) s['i'] = (i + 1) % 8 sublime.set_timeout(lambda: progress(s), 100) sublime.set_timeout(lambda: progress(status), 0) sublime.set_timeout_async(lambda: do_stuff(status), 0)
def scroll_to(self, coords): pattern = r".{{40}} \| {lineno: >4} ".format(lineno=coords[0] + 1) corresponding_region = self.view.find(pattern, 0) blame_view_pt = corresponding_region.b self.view.sel().add(sublime.Region(blame_view_pt, blame_view_pt)) sublime.set_timeout_async(lambda: self.view.show_at_center(blame_view_pt), 0)
def run(self, branch=None): sublime.set_timeout_async(lambda: self.run_async(branch), 0)
def run(self, edit): sublime.set_timeout_async(self.run_async)
def run(self, edit, force=False): self.force = force sublime.set_timeout_async(self.run_async, 0)
def _plugin_loaded(): sublime.set_timeout_async(load)
def run(self, edit, nuke_cursors=False): sublime.set_timeout_async(self.run_async, 0) self.nuke_cursors = nuke_cursors
def run(self): sublime.set_timeout_async(self.run_async, 0)
def run(self, remote_branch=None): sublime.set_timeout_async(lambda: self.run_async(remote_branch))
def detect_left_ansi(self, view): sublime.set_timeout_async(partial(self.check_left_ansi, view), 50)
def callback(self, folder): def remove_folder(): sampy_manager.remove_folder(folder) sublime.set_timeout_async(remove_folder, 0)
def generate_menus(**kwargs): """Asynchronously call generate_menus_async.""" sublime.set_timeout_async(generate_menus_async, 0)
def run(self, *args, commit_hash=None, file_path=None, **kwargs): if commit_hash: self.do_action(commit_hash, file_path=file_path, **kwargs) else: sublime.set_timeout_async( lambda: self.run_async(file_path=file_path, **kwargs))
def update_build_status(self, view): sublime.set_timeout_async(lambda: self.update_build_status_async(view))
def run(self, edit, host=None, path=None, defaultHost=DEFAULT_HOST, defaultPath=DEFAULT_PATH): window = self.view.window() # If no host or path was passed in, show a prompt for the user to choose if host is None or path is None: def on_done_host(host): def on_done_path(path): # Once the user has chosen a host and path, re-run the command with the new values window.active_view().run_command("remote_download", {"host": host, "path": path}) window.show_input_panel( "Enter a file path to download:", defaultPath.format(**TEMPLATE_ARGS), on_done=on_done_path, on_change=None, on_cancel=None) window.show_input_panel( "Enter a host name to download from:", defaultHost.format(**TEMPLATE_ARGS), on_done=on_done_host, on_change=None, on_cancel=None) return host = host.format(**TEMPLATE_ARGS) path = path.format(**TEMPLATE_ARGS) # Will store the downloaded file as bytes file = None # Try to download file `TRIES' times before giving up for i in range(TRIES): # If scp returns a non-0 code, an error is raised and caught try: # -B ensures scp will fail if a password is asked for file = subprocess.check_output(["scp", "-B", "{}:{}".format(host, path), "/dev/stdout"]) break except subprocess.CalledProcessError as err: if err.returncode == 0: raise(err) else: # The file couldn't be downloaded and an error message is shown to the user sublime.error_message("The file at {}:{} couldn't be downloaded.".format(host, path)) return # A temporary file is made on disk to store the downloaded file filename = RemoteDownloadCommand.makeTmpFile(path, file) # Open a new tab for the file (or open a pre-existing one) view = window.open_file(filename) # openFile is run once the view is done loading def openFile(): if view.is_loading(): # If it's not done loading, try again in 200 ms sublime.set_timeout_async(openFile, 200) else: # Set up settings for the file for easier uploading later view.settings().set("remote_edit_tmp_file", filename) view.settings().set("remote_edit_origin", "{}:{}".format(host, path)) view.settings().set("remote_edit_is_remote", True) view.set_status("remote_edit_status", "Uplaoding to {}:{}".format(host, path)) sublime.set_timeout_async(openFile, 0)
def run(self, edit): sublime.set_timeout_async(self.run_release, 0)
def on_post_text_command(self, view, command_name, args): # print("on_post_text_command, command:", command_name, "args: ", args) if command_name == "replace_completion_with_next_completion": self._replace_completion_with_next_completion = False if command_name in [ "left_delete", "commit_completion", "insert_best_completion", "replace_completion_with_next_completion" ]: self._stop_completion = True view.hide_popup() if command_name in [ "commit_completion", "insert_best_completion", "replace_completion_with_next_completion" ]: current_location = view.sel()[0].end() previous_location = self._last_query_location end_of_line = view.line( sublime.Region(current_location, current_location)) substitution = view.substr( sublime.Region(previous_location, current_location)) existing_choice = next( (x for x in self._results if x["new_prefix"] == self._completion_prefix + substitution), None) if existing_choice is not None: if existing_choice["old_suffix"].strip(): # print("existing_choice:", json.dumps(existing_choice)) # print("old_suffix: ", existing_choice["old_suffix"]) # print("new_suffix: ", existing_choice["new_suffix"]) end_search_location = min( current_location + len(substitution) + len(existing_choice["new_suffix"]), end_of_line.end()) start_search_location = current_location + len( existing_choice["new_suffix"]) after_substitution = view.substr( sublime.Region(start_search_location, end_search_location)) # print("substitution: ", substitution) # print("after_substitution: ", after_substitution) old_suffix_index = after_substitution.find( existing_choice["old_suffix"]) if old_suffix_index != -1: start_erase_location = start_search_location + old_suffix_index args = { "begin": start_erase_location, "end": start_erase_location + len(existing_choice["old_suffix"]), "old_suffix": existing_choice["old_suffix"] } view.run_command("tab_nine_post_substitution", args) if command_name in ["insert_snippet"]: # print("running insert snippet") def _run_compete(): view.run_command( 'auto_complete', { 'api_completions_only': False, 'disable_auto_insert': True, 'next_completion_if_showing': True, 'auto_complete_commit_on_tab': True, }) view.run_command('hide_auto_complete') sublime.set_timeout_async(_run_compete, 0) return
def run(self, *args, commit_hash=None): sublime.set_timeout_async(lambda: self.run_async(self.file_path), 0)
def run(self, edit, **kwargs): sublime.set_timeout_async(lambda: self.run_async(**kwargs), 0)
def run(self, edit, src=None, write=True, defaultHost=DEFAULT_HOST, defaultPath=DEFAULT_PATH): window = self.view.window() view = self.view settings = view.settings() # If no src was passed, try to get it from the file's settings or prompt the user if that fails if src is None: src = settings.get("remote_edit_origin") if src is None: # Prompt the user for a host and path name to upload to def on_done_host(host): def on_done_path(path): # Re-run the command with the new values view.run_command("remote_upload", {"src": "{}:{}".format(host, path)}) window.show_input_panel( "Enter a path to upload file to:", defaultPath.format(**TEMPLATE_ARGS), on_done=on_done_path, on_change=None, on_cancel=None) window.show_input_panel( "Enter a host name to upload to:", defaultHost.format(**TEMPLATE_ARGS), on_done=on_done_host, on_change=None, on_cancel=None) return src = src.format(**TEMPLATE_ARGS) # Update the file's settings to be able to upload without having to re-choose in the future settings.set("remote_edit_origin", src) settings.set("remote_edit_is_remote", True) view.set_status("remote_edit_status", "Uploading to {}".format(src)) # Get the location of the on-disk copy of the file diskLoc = view.file_name() or settings.get("remote_edit_tmp_file") # If it couldn't be found, make a new temporary file to store it if diskLoc is None: write = True diskLoc = RemoteDownloadCommand.makeTmpFile(src.split(":")[1], view.substr(sublime.Region(0, view.size())), write=False) settings.set("remote_edit_tmp_file", diskLoc) # Shows "Uploading..." in the status bar to show the user stuff is happening window.status_message("Uploading...") # doUpload is done asynchronously to prevent freezing def doUpload(): # If `write' is True, write to the temporary file before saving (may not be necessary if the user saved manually) if write: diskFile = open(diskLoc, "w+") diskFile.write(view.substr(sublime.Region(0, view.size()))) diskFile.close() # Try `TRIES' number of times to upload for i in range(TRIES): try: subprocess.check_output(["scp", "-B", diskLoc, src]) window.status_message("Uploaded successfully") break except subprocess.CalledProcessError as err: if err.returncode == 0: raise(err) else: # Show an error if the upload failed sublime.error_message("The file at {}:{} couldn't be uploaded.".format(src, path)) sublime.set_timeout_async(doUpload, 0)
def main_thread(callback, *args, **kwargs): sublime.set_timeout_async(functools.partial(callback, *args, **kwargs), 0)
def on_query_completions(self, view, prefix, locations): # print("in on_query_completions") if not view.match_selector(locations[0], "source | text"): return ([], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) last_region = view.substr( sublime.Region(max(locations[0] - 2, 0), locations[0])).rstrip() if last_region in ["", os.linesep]: # print("empty character query: ") return ([], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) if self._replace_completion_with_next_completion == True: self._replace_completion_with_next_completion = False return self._completions if self._last_query_location == locations[ 0] and self._last_location is None: # print("last location is None") return self._completions self._last_query_location = locations[0] self._completion_prefix = prefix old_prefix = None if self._last_location != locations[0]: temp_location = self._last_location self._last_location = locations[0] def _run_complete(): request = { "Autocomplete": { "before": self.before, "after": self.after, "filename": view.file_name(), "region_includes_beginning": self.region_includes_beginning, "region_includes_end": self.region_includes_end, "max_num_results": 5, } } response = tabnine_proc.request(request) if response is None: self._results = [] self._user_message = [] return # print("-----------") # print("response: ", json.dumps(response)) # print("-----------") self._results = response["results"] self._user_message = response["user_message"] old_prefix = response["old_prefix"] if len(self._results) < 1: return if self._results and self._user_message and view.window(): view.window().status_message(" ".join(self._user_message)) elif view.window(): view.window().status_message("TabNine") view.run_command( 'auto_complete', { 'api_completions_only': False, 'disable_auto_insert': True, 'next_completion_if_showing': True, 'auto_complete_commit_on_tab': True, }) view.run_command('hide_auto_complete') sublime.set_timeout_async(_run_complete, 0) return ([], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS) if self._last_location == locations[0]: self._last_location = None if len(self._results) == 1 and old_prefix is None: existing = view.substr( sublime.Region(max(locations[0] - (len(prefix) + 2), 0), locations[0])) is_tabNine_command = existing == "::{}".format(prefix) if is_tabNine_command: view.show_popup( self._results[0]["new_prefix"], sublime.COOPERATE_WITH_AUTO_COMPLETE, location=locations[0], max_width=1500, max_height=1200, on_navigate=webbrowser.open, ) else: view.hide_popup() self._completions = [ (r.get("new_prefix") + "\t" + r.get("detail", "TabNine"), r.get("new_prefix") + "$0" + r.get("new_suffix", "")) for r in self._results ] # print("completions:", self._completions) flags = sublime.INHIBIT_WORD_COMPLETIONS if len(self._completions) > 0: flags = 0 return (self._completions, flags)
def run(self): sublime.set_timeout_async(lambda: self.do_push())
def show(self): if self.ask_remote_first: show_remote_panel(lambda remote: sublime.set_timeout_async( lambda: self.on_remote_selection(remote), 100)) else: self.select_branch(remote=None)
def run(self, *args, **kwargs): sublime.set_timeout_async(lambda: self.run_async(*args, **kwargs))
def run(self, edit): self.interface = ui.get_interface(self.view.id()) sublime.set_timeout_async(self.run_async, 0)
def edit_project(self, project): def on_open(): self.window.open_file(self.project_file_name(project)) sublime.set_timeout_async(on_open, 100)
def plugin_loaded(): global settings settings = sublime.load_settings(SETTINGS_FILE) if settings.get('connect_on_startup'): sublime.set_timeout_async(partial(connect, silent=True), 0)
def next_flash(): view.erase_regions(cls._UNRESOLVED_KEY) sublime.set_timeout_async( lambda: cls.flash_invalid(view, points, times - 1), cls._FLASH_INTERVAL)
def run(self, commit_hash, file_path): self._commit_hash = commit_hash self._file_path = file_path sublime.set_timeout_async(self.run_async)
def on_query_completions(self, view, prefix, locations): def _run_complete(): response = autocomplete( self.before, self.after, view.file_name(), self.region_includes_beginning, self.region_includes_end, ) if response is None: self._results = [] self._user_message = [] return logger.debug("--- response ---") logger.jsonstr(response) logger.debug("--- end response ---") self._results = response["results"] self._user_message = response["user_message"] self._old_prefix = response["old_prefix"] if len(self._results) < 1: return if self._results and self._user_message and view.window(): view.window().status_message(" ".join(self._user_message)) view.run_command( "auto_complete", { "api_completions_only": True, "disable_auto_insert": True, "next_completion_if_showing": False, "auto_complete_commit_on_tab": True, }, ) EMPTY_COMPLETION_LIST = ( [], sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS, ) if should_return_empty_list(view, locations, prefix): return EMPTY_COMPLETION_LIST if is_tabnine_disabled(view): return EMPTY_COMPLETION_LIST if prefix.strip() == "" else None if self._replace_completion_with_next_completion: self._replace_completion_with_next_completion = False return self.get_completions_with_flags() if self._last_query_location == locations[ 0] and self._last_location is None: if len(self._completions) == 0 and prefix == "": self._last_location = locations[0] active_view().run_command("hide_auto_complete") sublime.set_timeout_async(_run_complete, 0) return EMPTY_COMPLETION_LIST if self.has_competions(): return (self._completions, sublime.INHIBIT_WORD_COMPLETIONS) else: return EMPTY_COMPLETION_LIST self._last_query_location = locations[0] self._completion_prefix = prefix self._old_prefix = None if self._last_location != locations[0]: self._last_location = locations[0] active_view().run_command("hide_auto_complete") sublime.set_timeout_async(_run_complete, 0) return EMPTY_COMPLETION_LIST if self._last_location == locations[0]: self._last_location = None self.handle_tabnine_commands(view, locations, prefix) self._completions = self.get_completion() logger.debug("completions: {}".format(self._completions)) return self.get_completions_with_flags()
def open_in_new_window(self, project): self.check_project(project) self.close_project(project) sublime.set_timeout_async( lambda: subl(["-n", self.project_file_name(project)]), 500)