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 )
class CompletionRequest(BaseRequest):
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 CompletionStartColumn(self):
return self._completion_start_column
def Start(self, query):
self.request_data["query"] = query
self._response_future = self.PostDataToHandlerAsync(self.request_data, "completions", TIMEOUT_SECONDS)
def Done(self):
return self._response_future.done()
def Response(self):
if not self._response_future:
return []
try:
return [_ConvertCompletionDataToVimData(x) for x in JsonFromFuture(self._response_future)]
except Exception as e:
vimsupport.PostVimMessage(str(e))
return []
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})
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( { '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( self._filepath )
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 Start( self ):
request_data = BuildRequestData()
if self._extra_data:
request_data.update( self._extra_data )
request_data.update( {
'command_arguments': self._arguments
} )
self._response = self.PostDataToHandler( request_data,
'run_completer_command' )
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.PostVimMessage( 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 __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():
return BaseRequest.PostDataToHandler( BuildRequestData(),
'defined_subcommands' )
else:
return []
def GetDefinedSubcommands(self):
with HandleServerException():
return BaseRequest.PostDataToHandler(BuildRequestData(),
'defined_subcommands')
return []
def BuildRequestData_AddWorkingDir_test(*args):
assert_that(BuildRequestData(), has_entry('working_dir', '/some/dir'))
def Start( self ):
request_data = BuildRequestData()
request_data.update( { 'filetypes': self.filetypes } )
with HandleServerException():
self._response = self.PostDataToHandler( request_data,
'semantic_completion_available' )
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 BuildRequestData_AddWorkingDirWithFileName_test(*args):
assert_that(BuildRequestData('foo'), has_entry('working_dir', '/some/dir'))
def Start(self):
request_data = BuildRequestData()
with HandleServerException(display=False):
self._response = self.PostDataToHandler(request_data, 'debug_info')
def BuildRequestData_AddWorkingDir_test(*args):
current_buffer = VimBuffer('foo')
with MockVimBuffers([current_buffer], current_buffer, (1, 1)):
assert_that(BuildRequestData(), has_entry('working_dir', '/some/dir'))
def GetDefinedSubcommands( self ):
request = BaseRequest()
subcommands = request.PostDataToHandler( BuildRequestData(),
'defined_subcommands' )
return subcommands if subcommands else []
class CommandRequest(BaseRequest):
def __init__(self,
arguments,
buffer_command='same-buffer',
extra_data=None):
super(CommandRequest, self).__init__()
self._arguments = _EnsureBackwardsCompatibility(arguments)
self._command = arguments and arguments[0]
self._buffer_command = buffer_command
self._extra_data = extra_data
self._response = None
self._request_data = None
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 Response(self):
return self._response
def RunPostCommandActionsIfNeeded(self, modifiers):
if not self.Done() or self._response is None:
return
# If not a dictionary or a list, the response is necessarily a
# scalar: boolean, number, string, etc. In this case, we print
# it to the user.
if not isinstance(self._response, (dict, list)):
return self._HandleBasicResponse()
if 'fixits' in self._response:
return self._HandleFixitResponse()
if 'message' in self._response:
return self._HandleMessageResponse()
if 'detailed_info' in self._response:
return self._HandleDetailedInfoResponse()
# The only other type of response we understand is GoTo, and that is the
# only one that we can't detect just by inspecting the response (it should
# either be a single location or a list)
return self._HandleGotoResponse(modifiers)
def StringResponse(self):
# Retuns a supporable public API version of the response. The reason this
# exists is that the ycmd API here is wonky as it originally only supported
# text-responses and now has things like fixits and such.
#
# The supportable public API is basically any text-only response. All other
# response types are returned as empty strings
if not self.Done():
raise RuntimeError("Response is not ready")
# Completer threw an error ?
if self._response is None:
return ""
# If not a dictionary or a list, the response is necessarily a
# scalar: boolean, number, string, etc. In this case, we print
# it to the user.
if not isinstance(self._response, (dict, list)):
return str(self._response)
if 'message' in self._response:
return self._response['message']
if 'detailed_info' in self._response:
return self._response['detailed_info']
# The only other type of response we understand is 'fixits' and GoTo. We
# don't provide string versions of them.
return ""
def _HandleGotoResponse(self, modifiers):
if isinstance(self._response, list):
vimsupport.SetQuickFixList(
[_BuildQfListItem(x) for x in self._response])
vimsupport.OpenQuickFixList(focus=True, autoclose=True)
else:
vimsupport.JumpToLocation(self._response['filepath'],
self._response['line_num'],
self._response['column_num'], modifiers,
self._buffer_command)
def _HandleFixitResponse(self):
if not len(self._response['fixits']):
vimsupport.PostVimMessage('No fixits found for current line',
warning=False)
else:
try:
fixit_index = 0
# When there are multiple fixit suggestions, present them as a list to
# the user hand have her choose which one to apply.
fixits = self._response['fixits']
if len(fixits) > 1:
fixit_index = vimsupport.SelectFromList(
"Multiple FixIt suggestions are available at this location. "
"Which one would you like to apply?",
[fixit['text'] for fixit in fixits])
chosen_fixit = fixits[fixit_index]
if chosen_fixit['resolve']:
self._request_data.update({'fixit': chosen_fixit})
response = self.PostDataToHandler(self._request_data,
'resolve_fixit')
fixits = response['fixits']
assert len(fixits) == 1
chosen_fixit = fixits[0]
vimsupport.ReplaceChunks(chosen_fixit['chunks'],
silent=self._command == 'Format')
except RuntimeError as e:
vimsupport.PostVimMessage(str(e))
def _HandleBasicResponse(self):
vimsupport.PostVimMessage(self._response, warning=False)
def _HandleMessageResponse(self):
vimsupport.PostVimMessage(self._response['message'], warning=False)
def _HandleDetailedInfoResponse(self):
vimsupport.WriteToPreviewWindow(self._response['detailed_info'])
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 _BuildRequestDataSubstitute():
data = BuildRequestData(include_buffer_data=False)
data['start_column'] = base.CompletionStartColumn()
return data
def Start( self ):
request_data = BuildRequestData()
if self._extra_data:
request_data.update( self._extra_data )
with HandleServerException( display = False ):
self._response = self.PostDataToHandler( request_data, 'debug_info' )
def __init__(self):
super(MessagesPoll, self).__init__()
self._request_data = BuildRequestData()
self._response_future = None
class CommandRequest(BaseRequest):
def __init__(self, arguments, extra_data=None, silent=False):
super(CommandRequest, self).__init__()
self._arguments = _EnsureBackwardsCompatibility(arguments)
self._command = arguments and arguments[0]
self._extra_data = extra_data
self._response = None
self._request_data = None
self._response_future = None
self._silent = silent
self._bufnr = extra_data.pop('bufnr', None) if extra_data else None
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 Done(self):
return bool(self._response_future) and self._response_future.done()
def Response(self):
if self._response is None and self._response_future is not None:
# Block
self._response = self.HandleFuture(
self._response_future, display_message=not self._silent)
return self._response
def RunPostCommandActionsIfNeeded(self,
modifiers,
buffer_command=DEFAULT_BUFFER_COMMAND):
# This is a blocking call if not Done()
self.Response()
if self._response is None:
# An exception was raised and handled.
return
# If not a dictionary or a list, the response is necessarily a
# scalar: boolean, number, string, etc. In this case, we print
# it to the user.
if not isinstance(self._response, (dict, list)):
return self._HandleBasicResponse()
if 'fixits' in self._response:
return self._HandleFixitResponse()
if 'message' in self._response:
return self._HandleMessageResponse()
if 'detailed_info' in self._response:
return self._HandleDetailedInfoResponse()
# The only other type of response we understand is GoTo, and that is the
# only one that we can't detect just by inspecting the response (it should
# either be a single location or a list)
return self._HandleGotoResponse(buffer_command, modifiers)
def StringResponse(self):
# Retuns a supporable public API version of the response. The reason this
# exists is that the ycmd API here is wonky as it originally only supported
# text-responses and now has things like fixits and such.
#
# The supportable public API is basically any text-only response. All other
# response types are returned as empty strings
# This is a blocking call if not Done()
self.Response()
# Completer threw an error ?
if self._response is None:
return ""
# If not a dictionary or a list, the response is necessarily a
# scalar: boolean, number, string, etc. In this case, we print
# it to the user.
if not isinstance(self._response, (dict, list)):
return str(self._response)
if 'message' in self._response:
return self._response['message']
if 'detailed_info' in self._response:
return self._response['detailed_info']
# The only other type of response we understand is 'fixits' and GoTo. We
# don't provide string versions of them.
return ""
def _HandleGotoResponse(self, buffer_command, modifiers):
if isinstance(self._response, list):
vimsupport.SetQuickFixList(
[vimsupport.BuildQfListItem(x) for x in self._response])
vimsupport.OpenQuickFixList(focus=True, autoclose=True)
else:
vimsupport.JumpToLocation(self._response['filepath'],
self._response['line_num'],
self._response['column_num'], modifiers,
buffer_command)
def _HandleFixitResponse(self):
if not len(self._response['fixits']):
vimsupport.PostVimMessage('No fixits found for current line',
warning=False)
else:
try:
fixit_index = 0
# If there is more than one fixit, we need to ask the user which one
# should be applied.
#
# If there's only one, triggered by the FixIt subcommand (as opposed to
# `RefactorRename`, for example) and whose `kind` is not `quicfix`, we
# still need to as the user for confirmation.
fixits = self._response['fixits']
if (len(fixits) > 1
or (len(fixits) == 1 and self._command == 'FixIt'
and fixits[0].get('kind') != 'quickfix')):
fixit_index = vimsupport.SelectFromList(
"FixIt suggestion(s) available at this location. "
"Which one would you like to apply?",
[fixit['text'] for fixit in fixits])
chosen_fixit = fixits[fixit_index]
if chosen_fixit['resolve']:
self._request_data.update({'fixit': chosen_fixit})
response = self.PostDataToHandler(self._request_data,
'resolve_fixit')
if response is None:
return
fixits = response['fixits']
assert len(fixits) == 1
chosen_fixit = fixits[0]
vimsupport.ReplaceChunks(chosen_fixit['chunks'],
silent=self._command == 'Format')
except RuntimeError as e:
vimsupport.PostVimMessage(str(e))
def _HandleBasicResponse(self):
vimsupport.PostVimMessage(self._response, warning=False)
def _HandleMessageResponse(self):
vimsupport.PostVimMessage(self._response['message'], warning=False)
def _HandleDetailedInfoResponse(self):
vimsupport.WriteToPreviewWindow(self._response['detailed_info'])
def Start(self):
request_data = BuildRequestData()
request_data.update({'filetypes': self.filetypes})
self._response = self.PostDataToHandler(
request_data, 'semantic_completion_available')
def _BuildRequestDataSubstitute():
return BuildRequestData(start_column=base.CompletionStartColumn(),
include_buffer_data=False)
