def Start(self):
if self._bufnr is not None:
self._request_data = BuildRequestData(self._bufnr)
else:
self._request_data = BuildRequestData()
if self._extra_data:
self._request_data.update(self._extra_data)
self._request_data.update({'command_arguments': self._arguments})
self._response_future = self.PostDataToHandlerAsync(
self._request_data, 'run_completer_command')
def Start(self):
request_data = BuildRequestData()
if self._extra_data:
request_data.update(self._extra_data)
self._response = self.PostDataToHandler(request_data,
'debug_info',
display_message=False)
def Start(self):
self._request_data = BuildRequestData()
if self._extra_data:
self._request_data.update(self._extra_data)
self._request_data.update({'command_arguments': self._arguments})
self._response = self.PostDataToHandler(self._request_data,
'run_completer_command')
def Request(self, force=False):
if self._request and not self.Ready():
return True
# Check to see if the buffer ranges would actually change anything visible.
# This avoids a round-trip for every single line scroll event
if (not force
and self.tick == vimsupport.GetBufferChangedTick(self._bufnr)
and vimsupport.VisibleRangeOfBufferOverlaps(
self._bufnr, self._last_requested_range)):
return False # don't poll
# We're requesting changes, so the existing results are now invalid
self._latest_inlay_hints = []
# FIXME: This call is duplicated in the call to VisibleRangeOfBufferOverlaps
# - remove the expansion param
# - look up the actual visible range, then call this function
# - if not overlapping, do the factor expansion and request
self._last_requested_range = vimsupport.RangeVisibleInBuffer(
self._bufnr)
self.tick = vimsupport.GetBufferChangedTick(self._bufnr)
request_data = BuildRequestData(self._bufnr)
request_data.update({'range': self._last_requested_range})
self._request = InlayHintsRequest(request_data)
self._request.Start()
return True
def ShowDetailedDiagnostic( self ):
detailed_diagnostic = BaseRequest().PostDataToHandler(
BuildRequestData(), 'detailed_diagnostic' )
if detailed_diagnostic and 'message' in detailed_diagnostic:
vimsupport.PostVimMessage( detailed_diagnostic[ 'message' ],
warning = False )
def SendRequest(self):
if self._request and not self.IsResponseReady():
return
self.tick = vimsupport.GetBufferChangedTick(self._bufnr)
self._request = SemanticTokensRequest(BuildRequestData())
self._request.Start()
def Start(self, silent=False):
self._request_data = BuildRequestData()
if self._extra_data:
self._request_data.update(self._extra_data)
self._request_data.update({'command_arguments': self._arguments})
self._response = self.PostDataToHandler(self._request_data,
'run_completer_command',
display_message=not silent)
def ShowDetailedDiagnostic(self):
with HandleServerException():
detailed_diagnostic = BaseRequest.PostDataToHandler(
BuildRequestData(), 'detailed_diagnostic')
if 'message' in detailed_diagnostic:
vimsupport.PostVimMessage(detailed_diagnostic['message'],
warning=False)
def Start(self):
request_data = BuildRequestData()
request_data.update({'filetypes': self.filetypes})
try:
self._response = self.PostDataToHandler(
request_data, 'semantic_completion_available')
except (ServerError, ReadTimeout) as e:
HandleServerException(e)
def Start(self):
request_data = BuildRequestData()
if self._extra_data:
request_data.update(self._extra_data)
request_data['event_name'] = self._event_name
self._response_future = self.PostDataToHandlerAsync(
request_data, 'event_notification')
def Start(self):
request_data = BuildRequestData()
request_data.update({
'completer_target': self._completer_target,
'command_arguments': self._arguments
})
with HandleServerException():
self._response = self.PostDataToHandler(request_data,
'run_completer_command')
def __init__(self, extra_data=None):
super(CompletionRequest, self).__init__()
self._completion_start_column = base.CompletionStartColumn()
# This field is also used by the omni_completion_request subclass
self.request_data = BuildRequestData(self._completion_start_column)
if extra_data:
self.request_data.update(extra_data)
def GetDefinedSubcommands(self):
if self.IsServerAlive():
try:
return BaseRequest.PostDataToHandler(BuildRequestData(),
'defined_subcommands')
except ServerError:
return []
else:
return []
def ShowDetailedDiagnostic(self):
if not self.IsServerAlive():
return
try:
debug_info = BaseRequest.PostDataToHandler(BuildRequestData(),
'detailed_diagnostic')
if 'message' in debug_info:
vimsupport.EchoText(debug_info['message'])
except ServerError as e:
vimsupport.PostVimMessage(str(e))
def Start(self):
request_data = BuildRequestData()
request_data.update({
'completer_target': self._completer_target,
'command_arguments': self._arguments
})
try:
self._response = self.PostDataToHandler(request_data,
'run_completer_command')
except ServerError as e:
vimsupport.PostMultiLineNotice(e)
def Start(self):
request_data = BuildRequestData()
request_data.update({
'completer_target': self._completer_target,
'command_arguments': self._arguments
})
try:
self._response = self.PostDataToHandler(request_data,
'run_completer_command')
except (ServerError, ReadTimeout) as e:
HandleServerException(e)
def SendRequest( self ):
if self._request and not self.IsResponseReady():
return
self.tick = vimsupport.GetBufferChangedTick( self._bufnr )
request: dict = BuildRequestData( self._bufnr )
request.update( {
'range': vimsupport.RangeVisibleInBuffer( self._bufnr )
} )
self._request = SemanticTokensRequest( request )
self._request.Start()
def SendCompletionRequest( self, force_semantic = False ):
request_data = BuildRequestData()
request_data[ 'force_semantic' ] = force_semantic
if not self.NativeFiletypeCompletionUsable():
wrapped_request_data = RequestWrap( request_data )
if self._omnicomp.ShouldUseNow( wrapped_request_data ):
self._latest_completion_request = OmniCompletionRequest(
self._omnicomp, wrapped_request_data )
self._latest_completion_request.Start()
return
self._AddExtraConfDataIfNeeded( request_data )
self._latest_completion_request = CompletionRequest( request_data )
self._latest_completion_request.Start()
def DebugInfo(self):
if self.IsServerAlive():
debug_info = BaseRequest.PostDataToHandler(BuildRequestData(),
'debug_info')
else:
debug_info = 'Server crashed, no debug info from server'
debug_info += '\nServer running at: {0}'.format(
BaseRequest.server_location)
debug_info += '\nServer process ID: {0}'.format(self._server_popen.pid)
if self._server_stderr or self._server_stdout:
debug_info += '\nServer logfiles:\n {0}\n {1}'.format(
self._server_stdout, self._server_stderr)
return debug_info
def CreateCompletionRequest(self, force_semantic=False):
request_data = BuildRequestData()
if (not self.NativeFiletypeCompletionAvailable()
and self.CurrentFiletypeCompletionEnabled()):
wrapped_request_data = RequestWrap(request_data)
if self._omnicomp.ShouldUseNow(wrapped_request_data):
self._latest_completion_request = OmniCompletionRequest(
self._omnicomp, wrapped_request_data)
return self._latest_completion_request
self._AddExtraConfDataIfNeeded(request_data)
if force_semantic:
request_data['force_semantic'] = True
self._latest_completion_request = CompletionRequest(request_data)
return self._latest_completion_request
def SendCompletionRequest(self, force_semantic=False):
request_data = BuildRequestData()
request_data['force_semantic'] = force_semantic
if (not self.NativeFiletypeCompletionAvailable()
and self.CurrentFiletypeCompletionEnabled()):
wrapped_request_data = RequestWrap(request_data)
if self._omnicomp.ShouldUseNow(wrapped_request_data):
self._latest_completion_request = OmniCompletionRequest(
self._omnicomp, wrapped_request_data)
self._latest_completion_request.Start()
return
request_data['working_dir'] = utils.GetCurrentDirectory()
self._AddExtraConfDataIfNeeded(request_data)
self._latest_completion_request = CompletionRequest(request_data)
self._latest_completion_request.Start()
def ShowDetailedDiagnostic( self, message_in_popup ):
detailed_diagnostic = BaseRequest().PostDataToHandler(
BuildRequestData(), 'detailed_diagnostic' )
if detailed_diagnostic and 'message' in detailed_diagnostic:
message = detailed_diagnostic[ 'message' ]
if message_in_popup and vimsupport.VimSupportsPopupWindows():
window = vim.current.window
buffer_number = vimsupport.GetCurrentBufferNumber()
diags_on_this_line = self._buffers[ buffer_number ].DiagnosticsForLine(
window.cursor[ 0 ] )
lines = message.split( '\n' )
available_columns = vimsupport.GetIntValue( '&columns' )
col = window.cursor[ 1 ] + 1
if col > available_columns - 2: # -2 accounts for padding.
col = 0
options = {
'col': col,
'padding': [ 0, 1, 0, 1 ],
'maxwidth': available_columns,
'close': 'click',
'fixed': 0,
'highlight': 'ErrorMsg',
'border': [ 1, 1, 1, 1 ],
# Close when moving cursor
'moved': 'expr',
}
popup_func = 'popup_atcursor'
for diag in diags_on_this_line:
if message == diag[ 'text' ]:
popup_func = 'popup_create'
prop = vimsupport.GetTextPropertyForDiag( buffer_number,
window.cursor[ 0 ],
diag )
options.update( {
'textpropid': prop[ 'id' ],
'textprop': prop[ 'type' ],
} )
options.pop( 'col' )
vim.eval( f'{ popup_func }( { lines }, { options } )' )
else:
vimsupport.PostVimMessage( message, warning = False )
def Start(self):
request_data = BuildRequestData()
request_data.update({'filetypes': self.filetypes})
self._response = self.PostDataToHandler(
request_data, 'semantic_completion_available')
def test_BuildRequestData_AddWorkingDir( self, *args ):
current_buffer = VimBuffer( 'foo' )
with MockVimBuffers( [ current_buffer ], [ current_buffer ] ):
assert_that( BuildRequestData(), has_entry( 'working_dir', '/some/dir' ) )
def GetDefinedSubcommands(self):
with HandleServerException():
return BaseRequest.PostDataToHandler(BuildRequestData(),
'defined_subcommands')
return []
def Start(self):
request_data = BuildRequestData()
with HandleServerException(display=False):
self._response = self.PostDataToHandler(request_data, 'debug_info')
def BuildRequestData_AddWorkingDirWithFileName_test(*args):
current_buffer = VimBuffer('foo')
with MockVimBuffers([current_buffer], [current_buffer]):
assert_that(BuildRequestData(current_buffer.number),
has_entry('working_dir', '/some/dir'))
def __init__(self):
super(MessagesPoll, self).__init__()
self._request_data = BuildRequestData()
self._response_future = None
def GetDefinedSubcommands(self):
if self._IsServerAlive():
return BaseRequest.PostDataToHandler(BuildRequestData(),
'defined_subcommands')
else:
return []
def GetDefinedSubcommands( self ):
subcommands = BaseRequest().PostDataToHandler( BuildRequestData(),
'defined_subcommands' )
return subcommands if subcommands else []
