def _update_snippets(self, context):
if 'file_type' in context:
file_type = context['file_type']
else:
file_type = rpc.DoCall('ECY#utils#GetCurrentBufferFileType')
if file_type in self.snippet_cache:
return
snippets = rpc.DoCall('ECY#utils#GetUltiSnippets')
if snippets == {}:
return
results_list = []
for trigger, snippet in snippets.items():
results_format = {
'abbr': '',
'word': '',
'kind': '',
'menu': '',
'info': '',
'user_data': ''
}
results_format['word'] = trigger
results_format['abbr'] = trigger
results_format['kind'] = '[Snippet]'
description = snippet['description']
if not description == '':
results_format['menu'] = description
results_list.append(results_format)
self.snippet_cache[file_type] = results_list
def DoCodeAction(self, context):
params = context['params']
uri = self._lsp.PathToUri(params['buffer_path'])
ranges = params['buffer_range']
start_position = ranges['start']
end_position = ranges['end']
self.code_action_cache = None
res = self._lsp.codeAction(
uri,
start_position,
end_position,
diagnostic=self._diagnosis_cache).GetResponse()
if len(res) == 0 or res is None:
rpc.DoCall('ECY#utils#echo', ['Nothing to act.'])
return
if 'error' in res:
self._show_msg(res['error']['message'])
return
res = res['result']
context['result'] = res
self.code_action_cache = context
rpc.DoCall('ECY#code_action#Do', [context])
return context
def OnHover(self, context):
if 'hoverProvider' not in self.capabilities:
self._show_msg('Hover is not supported.')
return
params = context['params']
uri = params['buffer_path']
uri = self._lsp.PathToUri(uri)
start_position = params['buffer_position']
position = {
'line': start_position['line'],
'character': start_position['colum']
}
res = self._lsp.hover(position, uri).GetResponse()
if 'error' in res:
self._show_msg(res['error']['message'])
return
res = res['result']
if res is None:
res = {}
content = []
if 'contents' in res:
content = self._format_markupContent(res['contents'])
if content == []:
self._show_msg('Nothing to show')
return
rpc.DoCall('ECY#hover#Open', [content])
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 FoldingRange(self, context):
if 'foldingRangeProvider' not in self.capabilities:
self._show_not_support_msg('FoldingRange')
return
params = context['params']
path = params['buffer_path']
start_position = params['buffer_position']
is_current_line = params['is_current_line']
uri = self._lsp.PathToUri(path)
res = self._lsp.foldingRange(uri).GetResponse()
res = res['result']
if res is None:
self._show_msg('Nothing to fold.')
return
i = 0
if is_current_line:
for item in res:
if item['startLine'] <= start_position['line'] and item[
'endLine'] >= start_position['line']:
break
i += 1
res = {'res': res}
res['path'] = path
res['is_current_line'] = is_current_line
res['buffer_position'] = start_position
res['seleting_folding_range'] = i
rpc.DoCall('ECY#folding_range#Do', [res])
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 DocumentLink(self, context):
if 'documentLinkProvider' not in self.capabilities:
return
params = context['params']
path = params['buffer_path']
uri = self._lsp.PathToUri(path)
res = self._lsp.documentLink(uri).GetResponse()
res = res['result']
if 'error' in res:
self._show_msg(res['error']['message'])
return
if res is None:
return
for item in res:
if 'target' in item:
item['target']['path'] = self._lsp.UriToPath(
item['target']['uri'])
res = {'res': res}
res['buffer_path'] = path
res['buffer_id'] = params['buffer_id']
rpc.DoCall('ECY#document_link#Do', [res])
def CheckEngine(self, context):
params = context['params']
to_be_check_engine_list = params['engine_list']
res = {}
for item in to_be_check_engine_list:
temp = self._get_engine_obj(item)
if temp == self.default_engine_name:
res[item] = [
'{Error} Engine not exists or having critical errors.'
]
else:
check_res = self.CallFunction(temp, 'Check', item, context)
if check_res is None:
res[item] = ['{Warning} Has no check function.']
elif 'res' not in check_res or type(
check_res['res']) is not list:
res[item] = ["{Error} ECY can NOT parse engine's return."]
else:
res[item] = check_res['res']
returns = []
i = 0
for item in res:
returns.append('%s. Engine name: [%s] \n' % (str(i), item))
returns.extend(res[item])
returns.append('\n')
i += 1
rpc.DoCall('ECY#utils#show', [returns, 'buffer', 'ECY_check'])
def OnCompletion(self, context):
file_type = rpc.DoCall('ECY#utils#GetCurrentBufferFileType')
context['file_type'] = file_type
self._update_snippets(context)
if file_type not in self.snippet_cache:
return
context['show_list'] = self.snippet_cache[file_type]
return context
def ReadFileContent(path):
# open a file; if it's not exists or have no right to operate them raise a error
res = rpc.DoCall('ECY#utils#IsFileOpenedInVim', [path, 'return_list'])
if res is False:
with open(path, 'r+', encoding='utf-8') as f:
content = f.read()
f.close()
res = content.split('\n')
return res
def OpenFZF(self, context):
engine = context['params']['engines']
if engine not in self.loaded_engiens:
self._show_msg("Wrong engine_name '%s'" % engine)
return
self.fzf_rpc.new(self.New(self.loaded_engiens[engine].Operate,
context))
rpc.DoCall('OpenPopupWindows')
return context
def _rename_callabck(self, context):
if 'rename_id' not in context or context[
'rename_id'] not in self.rename_info:
return
rename_info = self.rename_info[context['rename_id']]
if 'is_quit' in context and context['is_quit']:
pass # return
else:
rpc.DoCall('ECY#code_action#ApplyEdit', [rename_info['res']])
del self.rename_info[context['rename_id']]
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 _change_workspace_folder(self, context):
if 'workspace' not in self.capabilities or 'workspaceFolders' not in self.capabilities[
'workspace'] or not self.capabilities['workspace'][
'workspaceFolders']:
return
path = rpc.DoCall('ECY#rooter#GetCurrentBufferWorkSpace')
if path not in self.workspace_cache and path != '':
self.workspace_cache.append(path)
add_workspace = {'uri': self._lsp.PathToUri(path), 'name': path}
self._lsp.didChangeWorkspaceFolders(add_workspace=[add_workspace])
def _do_action(self, res):
for item in res:
if 'text' in res[item]:
res[item]['new_text_len'] = len(res[item]['text'])
del res[item]['text']
self.workspace_edit_undo = copy.deepcopy(res)
for item in res:
if 'undo_text' in res[item]:
del res[item]['undo_text']
rpc.DoCall('ECY#utils#ApplyTextEdit', [res])
def GetSource(self, event):
params = event['params']
buffers_list = rpc.DoCall('ECY#utils#GetBufferPath')
add_list = []
self.items = []
for item in buffers_list:
item = item.replace('\\', '/')
name = utils.GetAbbr(item, add_list)
add_list.append(name)
self.items.append({'abbr': name, 'path': item})
return self.items
def _get_diagnosis(self):
while True:
try:
temp = self._lsp.GetRequestOrNotification(
'textDocument/publishDiagnostics')
self._diagnosis_cache = temp['params']['diagnostics']
lists = self._diagnosis_analysis(temp['params'])
rpc.DoCall('ECY#diagnostics#PlaceSign', [{
'engine_name': self.engine_name,
'res_list': lists
}])
except Exception as e:
logger.exception(e)
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 _handle_file_status(self):
# clangd 8+
while 1:
try:
response = self._lsp.GetRequestOrNotification(
'textDocument/clangd.fileStatus')
res_path = response['params']['uri']
res_path = self._lsp.UriToPath(res_path)
current_buffer_path = rpc.DoCall(
'ECY#utils#GetCurrentBufferPath')
if res_path == current_buffer_path:
self._show_msg(response['params']['state'])
except:
pass
def _goto_response(self, res):
if 'error' in res:
self._show_msg(res['error']['message'])
return
res = res['result']
if res is None:
res = []
if len(res) == 0:
self._show_msg("No position to go.")
return
for item in res:
if 'uri' in item:
item['path'] = self._lsp.UriToPath(item['uri'])
rpc.DoCall('ECY#goto#Do', [res])
def _signature_help(self, res):
if 'error' in res:
self._show_msg(res['error']['message'])
return
res = res['result']
if res is None:
return
# if len(res['signatures']) == 0:
# return
# i = 0
# content = []
# for item in res['signatures']:
# content.append("%s. %s" % (i, item['label']))
# hilight_str = []
# if 'activeSignature' in res and res['activeSignature'] is not None:
# hilight_str.append("%s\." % (res['activeSignature']))
# activeSignature = res['activeSignature']
# else:
# activeSignature = {}
# if 'activeParameter' in res and res['activeParameter'] is not None:
# try:
# activeParameter = res['parameters'][res['activeParameter']]
# hilight_str.append("%s" % (activeParameter))
# except:
# activeParameter = {}
# else:
# activeParameter = {}
# if 'documentation' in activeParameter:
# content.extend(
# self._format_markupContent(activeParameter['documentation']))
# if 'documentation' in activeSignature:
# content.extend(
# self._format_markupContent(activeSignature['documentation']))
if len(res) != 0:
rpc.DoCall('ECY#signature_help#Show', [res])
def SelectionRange(self, context):
if 'selectionRangeProvider' not in self.capabilities:
self._show_not_support_msg('SelectionRange')
return
params = context['params']
path = params['buffer_path']
uri = self._lsp.PathToUri(path)
start_position = params['buffer_position']
position = {
'line': start_position['line'],
'character': start_position['colum']
}
res = self._lsp.selectionRange(position, uri).GetResponse()
res = res['result']
if res is not None:
res = res[0]
res['path'] = path
rpc.DoCall('ECY#selete_range#Do', [res])
def _handle_diagnosis(self):
reporter = PyflakesDiagnosticReport('')
self.document_id = -1
while 1:
try:
context = self._diagnosis_queue.get()
params = context['params']
if params['buffer_id'] <= self.document_id:
continue
self.document_id = params['buffer_id']
text_string = '\n'.join(params['buffer_content'])
reporter.SetContent(text_string)
pyflakes_api.check(text_string,
params['buffer_path'],
reporter=reporter)
res = reporter.GetDiagnosis()
rpc.DoCall('ECY#diagnostics#PlaceSign', [{
'engine_name': self.engine_name,
'res_list': res
}])
time.sleep(1)
except Exception as e:
logger.exception(e)
break
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 _open_vertically(self, event):
res = event['res']
if res == {}:
return
rpc.DoCall('ClosePopupWindows2')
rpc.DoCall('ECY#utils#OpenFile', [res['path'], 'x'])
def _open_in_new_tab(self, event):
res = event['res']
if res == {}:
return
rpc.DoCall('ClosePopupWindows2')
rpc.DoCall('ECY#utils#OpenFile', [res['path'], 't'])
def GetEngineConfig(engine_name, opt_name):
viml_engine_config = rpc.DoCall('ECY#engine_config#GetEngineConfig',
[engine_name, opt_name])
return viml_engine_config
def GetInstallerConfig(installer_name): # return {} if it is not installed.
temp = rpc.DoCall('ECY#engine_config#GetInstallerInfo', [installer_name])
return temp
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 Closed(self, event):
res = event['res']
if res != {}:
pass
rpc.DoCall('ECho', [str(event)])
