def ResponseArrive(self, response): if self.response_queue is None: # user have no intention to get request's response. return logger.debug("<---" + str(response)) self.response_queue.put(response)
def InstallEngine(self, engine_pack_name): engine_info = {} try: if type(engine_pack_name) is dict: sys.path.append(engine_pack_name['dir']) module_obj = importlib.import_module(engine_pack_name['name']) engine_name = engine_pack_name['name'] else: engine_name = engine_pack_name module_obj = importlib.import_module(engine_pack_name) obj = module_obj.Operate(engine_name) obj.engine_name = engine_name engine_info['engine_obj'] = obj except Exception as e: logger.exception(e) return False engine_info['handler_queue'] = queue.Queue() engine_info['res_queue'] = queue.Queue() engine_info['name'] = engine_pack_name threading.Thread(target=self.EngineCallbackThread, args=(engine_info, ), daemon=True).start() threading.Thread(target=self.EngineEventHandler, args=(engine_info, ), daemon=True).start() logger.debug("installed engine %s" % (engine_info)) self.engine_dict[engine_pack_name] = engine_info return self.engine_dict[engine_pack_name]
def OnTextChanged(self, context): params = context['params'] filetype = params['file_type'] if filetype not in self.parser or filetype not in self.highlight: return text = params['buffer_content'] obj = self.parser[filetype] obj.UpdateBuffer(text) res = obj.GetSematicToken() to_vim = [] color_info = self.highlight[filetype] if 'color' in color_info: for item in res: is_defined = True for color_item in self.highlight[filetype]['color']: for color in color_item[0]: if color not in item[ 'tokenModifiers'] and color != item['type']: is_defined = False break if is_defined: item['color'] = color_item[1] to_vim.append(item) break logger.debug(to_vim) if params['change_mode'] == 'n': # normal mode pass
def FallBack(): global g_event_handle_thread global request_list content2 = '' logger.debug('Started RPC') while True: try: content = ReadStdIn() content2 = content2 + content content_split = content2.split('\n') lens = len(content_split) if lens == 1: continue else: content2 = content_split[lens - 1] i = 0 while i < (lens - 1): if content_split[i] == '': continue context = json.loads(content_split[i]) if context['type'] == 'event': g_event_handle_thread.put(context) elif context['type'] == 'fallback': re_id = context['request_id'] if re_id not in request_list: continue request_list[re_id].put(context) else: pass i += 1 except Exception as e: logger.exception(e) raise
def OnCompletion(self, context): if context['params']['buffer_id'] != rpc.DoCall( 'ECY#rpc#rpc_event#GetBufferIDNotChange'): logger.debug('filter a outdate context.') return False context = self.default_engine.OnCompletion(context) return context
def _on_item_seleted_cb(self, res): if 'error' in res: self._show_msg(res['error']['message']) return if res['callback_additional_data'] != self.current_seleted_item: logger.debug('Outdate item resolve.') return res = res['result'] results_format = { 'abbr': '', 'word': '', 'kind': '', 'menu': '', 'info': '', 'user_data': '' } document = [] if 'documentation' in res: document.extend(self._format_markupContent(res['documentation'])) detail = [] if 'detail' in res: if type(res['detail']) is str: detail = res['detail'].split('\n') elif type(res['detail']) is list: detail = res['detail'] results_format['menu'] = detail results_format['info'] = document rpc.DoCall('ECY#preview_windows#Show', [results_format])
def _annalysis(self, context): self.cached_items = [] params = context['params'] buffer_content = params['buffer_content'] buffer_content = '\n'.join(buffer_content) items_list = lex(buffer_content, self.current_lexer) results_list = [] for tup in items_list: if len(tup[1]) == 1: continue # the results_format must at least contain the following keys. logger.debug(tup) results_format = { 'abbr': '', 'word': '', 'kind': '', 'menu': '', 'info': '', 'user_data': '' } results_format['word'] = tup[1] if len(tup[1]) > 30: results_format['abbr'] = str(tup[1])[:30] else: results_format['abbr'] = tup[1] results_format['kind'] = str(tup[0])[6:] results_list.append(results_format) self.cached_items = results_list
def OnCompletion(self, context): context['trigger_key'] = self.trigger_key params = context['params'] uri = params['buffer_path'] uri = self._lsp.PathToUri(uri) start_position = params['buffer_position'] current_cache = self._is_need_to_update(context, r'[\#\:\w+]') current_start_postion = { 'line': start_position['line'], 'character': current_cache['current_colum'] } if 'is_vim_lsp_callback' not in params: logger.debug('request') params['vim_lsp_position'] = current_start_postion params['buffer_content'] = '' rpc.DoCall('ECY#vim_lsp#main#Request', [params]) return self.results_list = [] return_data = params['response'] logger.debug(return_data) if return_data is None: return if return_data['result'] is None: return # self.is_InComplete = return_data['result']['isIncomplete'] for item in return_data['result']['items']: results_format = { 'abbr': '', 'word': '', 'kind': '', 'menu': '', 'info': '', 'user_data': '' } results_format['kind'] = self._lsp.GetKindNameByNumber( item['kind']) item_name = item['label'] results_format['abbr'] = item_name results_format['word'] = item_name self.results_list.append(results_format) context['show_list'] = self.results_list return context
def _handle_log_msg(self): while 1: try: response = self._lsp.GetRequestOrNotification( 'window/logMessage') msg = response['params']['message'] if msg.find('compile_commands') != -1: # clangd 12+ self._show_msg(msg.split('\n')) logger.debug(response) except Exception as e: logger.exception(e)
def CodeActionCallback(self, context): params = context['params'] context = params['context'] if context != self.code_action_cache or 'result' not in context: logger.debug('filtered a CodeActionCallback.') return res = context['result'] seleted_item = res[params['seleted_item']] if 'edit' in seleted_item: res = workspace_edit.WorkspaceEdit(seleted_item['edit']) self._do_action(res) if 'command' in seleted_item: pass # TODO
def GetSource(self, event): params = event['params'] current_buffer_nr = params['current_buffer_nr'] buffer_line_list = rpc.DoCall('ECY#utils#GetBufferContent', [current_buffer_nr]) logger.debug(buffer_line_list) i = 0 self.items = [] for item in buffer_line_list: self.items.append({'abbr': str(item), 'line': i}) i += 1 return self.items
def LogStderr(self): while self.IsServerAlive(): temp = self._sub_object.stderr.readline() temp = str(temp.decode("UTF-8")) data = { 'method': 'window/logMessage', 'params': { 'message': temp, 'type': 5 } } temp = {'server_id': self.server_id, 'data': json.dumps(data)} if self.is_log_stderr: self.__queue.put(temp) logger.debug("server dead.")
def _get_registerCapability(self): while True: try: jobs = self._lsp.GetRequestOrNotification( 'client/registerCapability') params = jobs['params'] for item in params['registrations']: logger.debug(item) method = item['method'] if method == 'workspace/didChangeWorkspaceFolders': if 'workspace' not in self.capabilities: self.capabilities['workspace'] = {} self.capabilities['workspace'][ 'workspaceFolders'] = True self._lsp._build_response(None, item['id']) except Exception as e: logger.exception(e)
def _handler(self, event): callback_name = event['callback_name'] event_id = int(event['id']) if event_id not in g_context: return "event_id not in g_context" obj = g_context[event_id]['obj'] if not hasattr(obj, callback_name): return "has no " + callback_name if callback_name == 'Closed' and 'key' in event and 'key_bind' in g_context[ event_id]: key = event['key'] key_bind = g_context[event_id]['key_bind'] if key in key_bind: fuc = key_bind[key] logger.debug(fuc) fuc(event) fuc = getattr(obj, callback_name) return fuc(event)
def _handle_edit(self): while 1: try: response = self._lsp.GetRequestOrNotification( 'workspace/applyEdit') try: res = workspace_edit.WorkspaceEdit( response['params']['edit']) self._do_action(res) applied = True except Exception as e: logger.exception(e) applied = False logger.debug(response) self._lsp.applyEdit_response(response['id'], applied) except Exception as e: logger.exception(e)
def OnItemSeleted(self, context): if 'completionProvider' not in self.capabilities or \ 'resolveProvider' not in self.capabilities['completionProvider'] \ or self.capabilities['completionProvider']['resolveProvider'] is False: logger.debug('OnItemSeleted is not supported.') return ECY_item_index = context['params']['ECY_item_index'] if (len(self.results_list) - 1) < ECY_item_index: logger.debug('OnItemSeleted wrong') return self.current_seleted_item = self.results_list[ECY_item_index] self._lsp.completionItem_resolve( self.current_seleted_item).GetResponse( callback=self._on_item_seleted_cb, callback_additional_data=self.current_seleted_item)
def OnCompletion(self, context): params = context['params'] buffer_path = params['buffer_path'] start_position = params['buffer_position'] context['regex'] = self.refresh_regex context['is_filter'] = False current_position_cache = utils.IsNeedToUpdate(context, self.refresh_regex) if len(current_position_cache['filter_words']) <= 1: return candidates = self.checker.candidates( current_position_cache['filter_words']) logger.debug(current_position_cache['filter_words']) if len(candidates) == 0: return self.results_list = [] for item in candidates: results_format = { 'abbr': '', 'word': '', 'kind': '', 'match_point': [], 'menu': '', 'info': '', 'user_data': '' } results_format['abbr'] = item + ' ' results_format['word'] = item results_format['kind'] = 'Word' self.results_list.append(results_format) logger.debug(self.results_list) context['show_list'] = self.results_list return context
def StartJob(self, cmd, argvs=None): try: if type(cmd) is list: cmd = " ".join(cmd) logger.debug(cmd) if argvs is not None: if type(argvs) is list: argvs = " ".join(argvs) cmd += ' ' + argvs logger.debug("real cmd: " + str(cmd)) process_obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) self.server_count += 1 process_hanlder = ThreadOfJob(self.server_count, process_obj, self._queue) # stdin threading.Thread(target=process_hanlder.Start, daemon=True).start() # stderr threading.Thread(target=process_hanlder.LogStderr, daemon=True).start() self.server_info[self.server_count] = {} self.server_info[self.server_count]['cmd'] = cmd self.server_info[self.server_count]['proc_object'] = process_obj self.server_info[ self.server_count]['thread_object'] = process_hanlder except Exception as e: logger.exception(e) return None return self.server_count
def _update_root(self, context=None): self.root_path = rpc.DoCall('ECY#rooter#GetCurrentBufferWorkSpace') self.root_path = self.root_path.replace('\\', '/') if context is None: return try: self.exists_regex = [] buffer_path = context['params']['buffer_path'] while True: temp = os.path.dirname(buffer_path) if buffer_path == temp: break buffer_path = temp temp = buffer_path + '/.gitignore' if os.path.exists(temp): with open(temp, encoding="utf8") as f: for item in f.read().split('\n'): if item == '': continue self.exists_regex.append(item) break logger.debug(self.exists_regex) except: pass
def GetStartCMD(self): if self.starting_cmd is None: self.starting_cmd = utils.GetEngineConfig(self.engine_name, 'cmd') if self.starting_cmd is None or self.starting_cmd == '': self.starting_cmd = utils.GetInstallerConfig(self.engine_name) logger.debug('installer info:' + str(self.starting_cmd)) if 'cmd' in self.starting_cmd: self.starting_cmd = self.starting_cmd['cmd'] logger.debug('using installer cmd') else: self.starting_cmd = utils.GetEngineConfig( self.engine_name, 'cmd2') if self.starting_cmd is None or self.starting_cmd == '': raise ValueError("missing cmd.") logger.debug('using cmd2') else: logger.debug('using user setting cmd')
if g_args.debug_log and not IS_INSTALL: if g_args.log_path is None: output_log_dir = BASE_DIR + '/ECY_debug.log' else: output_log_dir = g_args.log_path fileHandler = logging.FileHandler(output_log_dir, mode="w", encoding="utf-8") formatter = logging.Formatter( '%(asctime)s %(filename)s:%(lineno)d | %(message)s') fileHandler.setFormatter(formatter) logger.addHandler(fileHandler) logger.setLevel(logging.DEBUG) logger.debug(BASE_DIR) def main(): if IS_INSTALL: from ECY_installer import install_cli if g_args.install is not None: install_cli.Install(g_args.install) else: install_cli.UnInstall(g_args.install) else: rpc.BlindEvent(engines.Mannager()) rpc.Daemon() if __name__ == '__main__':
def BlindEvent(classs): global blind_event_instance blind_event_instance = classs logger.debug('BlindEvent')
def OnCompletion(self, context): if 'show_list' not in context: logger.debug('missing params. "show_list"') return params = context['params'] current_line = params['buffer_line'] current_line = bytes(current_line, encoding='utf-8') context['next_key'] = str( current_line[params['buffer_position']['colum']:], encoding='utf-8') context['prev_key'] = str( current_line[:params['buffer_position']['colum']], encoding='utf-8') if 'regex' in context: regex = context['regex'] else: # default one regex = r'[\w+]' current_colum, filter_words, last_key = utils.MatchFilterKeys( context['prev_key'], regex) context['filter_key'] = filter_words context['filter_key_len'] = len(filter_words) context['start_position'] = { 'line': params['buffer_position']['line'], 'colum': current_colum } ######################## # completion resolve # ######################## i = 0 for item in context['show_list']: item['ECY_item_index'] = i i += 1 if 'is_filter' not in context: context['is_filter'] = True if context['is_filter']: res_list = self.fuzzy_match.FilterItems( context['filter_key'], context['show_list'], isindent=self.is_indent, isreturn_match_point=self.is_indent) if 'must_show' not in context: if 'trigger_key' in context: if last_key in context['trigger_key']: context['must_show'] = True else: context['must_show'] = False else: context['must_show'] = False # show_list_len = self.show_list_len - len(res_list) if len(res_list) == 0: res_list = self.fuzzy_match.FilterItems( context['filter_key'], context['buffer_show_list'], isindent=self.is_indent, isreturn_match_point=self.is_indent) context['show_list'] = res_list rpc.DoCall('ECY#completion#Open', [context])
def _diagnosis_analysis(self, params): results_list = [] file_path = self._lsp.UriToPath(params['uri']) if file_path == '': logger.debug("empty file_path") return results_list for item in params['diagnostics']: ranges = item['range'] start_line = ranges['start']['line'] + 1 start_colum = ranges['start']['character'] end_line = ranges['end']['line'] + 1 end_colum = ranges['end']['character'] pos_string = '[%s, %s]' % (str(start_line), str(start_colum)) position = { 'line': start_line, 'range': { 'start': { 'line': start_line, 'colum': start_colum }, 'end': { 'line': end_line, 'colum': end_colum } } } diagnosis = [] if type(item['message']) is str: diagnosis = item['message'].split('\n') elif type(item['message']) is list: diagnosis = item['message'] if 'severity' in item: if item['severity'] == 1: kind = 1 else: kind = 2 else: kind = 1 kind_name = self._lsp.GetDiagnosticSeverity(kind) temp = [{ 'name': '1', 'content': { 'abbr': diagnosis } }, { 'name': '2', 'content': { 'abbr': kind_name } }, { 'name': '3', 'content': { 'abbr': file_path } }, { 'name': '4', 'content': { 'abbr': pos_string } }] temp = { 'items': temp, 'type': 'diagnosis', 'file_path': file_path, 'kind': kind, 'diagnostics': diagnosis, 'position': position } results_list.append(temp) return results_list
def OnCompletion(self, context): params = context['params'] buffer_path = params['buffer_path'] start_position = params['buffer_position'] context['show_list'] = self.results_list context['trigger_key'] = self.trigger_key context['regex'] = self.refresh_regex2 current_position_cache = utils.IsNeedToUpdate(context, self.refresh_regex2) current_start_postion = { 'line': start_position['line'], 'character': current_position_cache['current_colum'] } if current_start_postion == self.current_position_cache: return context self.current_position_cache = current_start_postion temp = context['params']['buffer_position']['colum'] context['params']['buffer_position']['colum'] = current_position_cache[ 'current_colum'] current_position_cache = utils.IsNeedToUpdate(context, self.refresh_regex) context['params']['buffer_position']['colum'] = temp try_dir = current_position_cache['filter_words'] self.results_list = [] logger.debug(try_dir) if len(try_dir) == 0: return if try_dir[0] in self.workspace_symbol: try_dir = self.root_path + try_dir[1:] elif try_dir[0] == '.': try_dir = self._handle_dot(try_dir, buffer_path) if utils.GetCurrentOS() == 'Windows': try_dir = try_dir.replace('\\', '/') logger.debug(try_dir) dir_list = self.try_listdir(try_dir) for item in dir_list: results_format = { 'abbr': '', 'word': '', 'kind': '', 'menu': '', 'info': '', 'user_data': '' } item_name = item results_format['abbr'] = item_name results_format['word'] = item_name path = try_dir + item if os.path.isdir(path): results_format['kind'] = '[Dir]' elif os.path.isfile(path): results_format['kind'] = '[File]' elif os.path.isabs(path): results_format['kind'] = '[Abs]' elif os.path.islink(path): results_format['kind'] = '[Link]' results_format['info'] = path self.results_list.append(results_format) context['show_list'] = self.results_list return context