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
