b9bb788a2a
There appear to be timing issues for the diag requests. Somehow, we're sending out-of-date diagnostics and then not updating the UI when things change. That needs to be fixed.
283 lines
9.5 KiB
Python
283 lines
9.5 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2011, 2012, 2013 Strahinja Val Markovic <val@markovic.io>
|
|
#
|
|
# This file is part of YouCompleteMe.
|
|
#
|
|
# YouCompleteMe is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# YouCompleteMe is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import abc
|
|
import ycm_core
|
|
from ycm.utils import ToUtf8IfNeeded
|
|
from ycm.completers.completer_utils import TriggersForFiletype
|
|
|
|
NO_USER_COMMANDS = 'This completer does not define any commands.'
|
|
|
|
class Completer( object ):
|
|
"""A base class for all Completers in YCM.
|
|
|
|
Here's several important things you need to know if you're writing a custom
|
|
Completer. The following are functions that the Vim part of YCM will be
|
|
calling on your Completer:
|
|
|
|
ShouldUseNow() is called with the start column of where a potential completion
|
|
string should start and the current line (string) the cursor is on. For
|
|
instance, if the user's input is 'foo.bar' and the cursor is on the 'r' in
|
|
'bar', start_column will be the 0-based index of 'b' in the line. Your
|
|
implementation of ShouldUseNow() should return True if your semantic completer
|
|
should be used and False otherwise.
|
|
|
|
This is important to get right. You want to return False if you can't provide
|
|
completions because then the identifier completer will kick in, and that's
|
|
better than nothing.
|
|
|
|
Note that it's HIGHLY likely that you want to override the ShouldUseNowInner()
|
|
function instead of ShouldUseNow() directly (although chances are that you
|
|
probably won't have any need to override either). ShouldUseNow() will call
|
|
your *Inner version of the function and will also make sure that the
|
|
completion cache is taken into account. You'll see this pattern repeated
|
|
throughout the Completer API; YCM calls the "main" version of the function and
|
|
that function calls the *Inner version while taking into account the cache.
|
|
|
|
The cache is important and is a nice performance boost. When the user types in
|
|
"foo.", your completer will return a list of all member functions and
|
|
variables that can be accessed on the "foo" object. The Completer API caches
|
|
this list. The user will then continue typing, let's say "foo.ba". On every
|
|
keystroke after the dot, the Completer API will take the cache into account
|
|
and will NOT re-query your completer but will in fact provide fuzzy-search on
|
|
the candidate strings that were stored in the cache.
|
|
|
|
ComputeCandidates() is the main entry point when the user types. For
|
|
"foo.bar", the user query is "bar" and completions matching this string should
|
|
be shown. It should return the list of candidates. The format of the result
|
|
can be a list of strings or a more complicated list of dictionaries. Use
|
|
ycm.server.responses.BuildCompletionData to build the detailed response. See
|
|
clang_completer.py to see how its used in practice.
|
|
|
|
Again, you probably want to override ComputeCandidatesInner().
|
|
|
|
You also need to implement the SupportedFiletypes() function which should
|
|
return a list of strings, where the strings are Vim filetypes your completer
|
|
supports.
|
|
|
|
clang_completer.py is a good example of a "complicated" completer that A good
|
|
example of a simple completer is ultisnips_completer.py.
|
|
|
|
The On* functions are provided for your convenience. They are called when
|
|
their specific events occur. For instance, the identifier completer collects
|
|
all the identifiers in the file in OnFileReadyToParse() which gets called when
|
|
the user stops typing for 2 seconds (Vim's CursorHold and CursorHoldI events).
|
|
|
|
One special function is OnUserCommand. It is called when the user uses the
|
|
command :YcmCompleter and is passed all extra arguments used on command
|
|
invocation (e.g. OnUserCommand(['first argument', 'second'])). This can be
|
|
used for completer-specific commands such as reloading external
|
|
configuration.
|
|
When the command is called with no arguments you should print a short summary
|
|
of the supported commands or point the user to the help section where this
|
|
information can be found.
|
|
|
|
Override the Shutdown() member function if your Completer subclass needs to do
|
|
custom cleanup logic on server shutdown."""
|
|
|
|
__metaclass__ = abc.ABCMeta
|
|
|
|
def __init__( self, user_options ):
|
|
self.user_options = user_options
|
|
self.min_num_chars = user_options[ 'min_num_of_chars_for_completion' ]
|
|
self.triggers_for_filetype = TriggersForFiletype(
|
|
user_options[ 'semantic_triggers' ] )
|
|
self.completions_future = None
|
|
self._completions_cache = None
|
|
|
|
|
|
# It's highly likely you DON'T want to override this function but the *Inner
|
|
# version of it.
|
|
def ShouldUseNow( self, request_data ):
|
|
inner_says_yes = self.ShouldUseNowInner( request_data )
|
|
if not inner_says_yes:
|
|
self._completions_cache = None
|
|
|
|
previous_results_were_empty = ( self._completions_cache and
|
|
self._completions_cache.CacheValid(
|
|
request_data[ 'line_num' ],
|
|
request_data[ 'start_column' ] ) and
|
|
not self._completions_cache.raw_completions )
|
|
return inner_says_yes and not previous_results_were_empty
|
|
|
|
|
|
def ShouldUseNowInner( self, request_data ):
|
|
current_line = request_data[ 'line_value' ]
|
|
start_column = request_data[ 'start_column' ]
|
|
line_length = len( current_line )
|
|
if not line_length or start_column - 1 >= line_length:
|
|
return False
|
|
|
|
filetype = self._CurrentFiletype( request_data[ 'filetypes' ] )
|
|
triggers = self.triggers_for_filetype[ filetype ]
|
|
|
|
for trigger in triggers:
|
|
index = -1
|
|
trigger_length = len( trigger )
|
|
while True:
|
|
line_index = start_column + index
|
|
if line_index < 0 or current_line[ line_index ] != trigger[ index ]:
|
|
break
|
|
|
|
if abs( index ) == trigger_length:
|
|
return True
|
|
index -= 1
|
|
return False
|
|
|
|
|
|
def QueryLengthAboveMinThreshold( self, request_data ):
|
|
query_length = request_data[ 'column_num' ] - request_data[ 'start_column' ]
|
|
return query_length >= self.min_num_chars
|
|
|
|
|
|
# It's highly likely you DON'T want to override this function but the *Inner
|
|
# version of it.
|
|
def ComputeCandidates( self, request_data ):
|
|
if not self.ShouldUseNow( request_data ):
|
|
return []
|
|
|
|
if ( request_data[ 'query' ] and
|
|
self._completions_cache and
|
|
self._completions_cache.CacheValid( request_data[ 'line_num' ],
|
|
request_data[ 'start_column' ] ) ):
|
|
return self.FilterAndSortCandidates(
|
|
self._completions_cache.raw_completions,
|
|
request_data[ 'query' ] )
|
|
else:
|
|
self._completions_cache = CompletionsCache()
|
|
self._completions_cache.raw_completions = self.ComputeCandidatesInner(
|
|
request_data )
|
|
self._completions_cache.line = request_data[ 'line_num' ]
|
|
self._completions_cache.column = request_data[ 'start_column' ]
|
|
return self._completions_cache.raw_completions
|
|
|
|
|
|
def ComputeCandidatesInner( self, request_data ):
|
|
pass
|
|
|
|
|
|
def DefinedSubcommands( self ):
|
|
return []
|
|
|
|
|
|
def UserCommandsHelpMessage( self ):
|
|
subcommands = self.DefinedSubcommands()
|
|
if subcommands:
|
|
return ( 'Supported commands are:\n' +
|
|
'\n'.join( subcommands ) +
|
|
'\nSee the docs for information on what they do.' )
|
|
else:
|
|
return 'This Completer has no supported subcommands.'
|
|
|
|
|
|
def FilterAndSortCandidates( self, candidates, query ):
|
|
if not candidates:
|
|
return []
|
|
|
|
# We need to handle both an omni_completer style completer and a server
|
|
# style completer
|
|
if 'words' in candidates:
|
|
candidates = candidates[ 'words' ]
|
|
|
|
sort_property = ''
|
|
if 'word' in candidates[ 0 ]:
|
|
sort_property = 'word'
|
|
elif 'insertion_text' in candidates[ 0 ]:
|
|
sort_property = 'insertion_text'
|
|
|
|
matches = ycm_core.FilterAndSortCandidates(
|
|
candidates,
|
|
sort_property,
|
|
ToUtf8IfNeeded( query ) )
|
|
|
|
return matches
|
|
|
|
|
|
def OnFileReadyToParse( self, request_data ):
|
|
pass
|
|
|
|
|
|
def OnBufferVisit( self, request_data ):
|
|
pass
|
|
|
|
|
|
def OnBufferUnload( self, request_data ):
|
|
pass
|
|
|
|
|
|
def OnInsertLeave( self, request_data ):
|
|
pass
|
|
|
|
|
|
def OnUserCommand( self, arguments, request_data ):
|
|
raise NotImplementedError( NO_USER_COMMANDS )
|
|
|
|
|
|
def OnCurrentIdentifierFinished( self, request_data ):
|
|
pass
|
|
|
|
|
|
def GetDiagnosticsForCurrentFile( self, request_data ):
|
|
return []
|
|
|
|
|
|
def GetDetailedDiagnostic( self ):
|
|
pass
|
|
|
|
|
|
def GettingCompletions( self ):
|
|
return False
|
|
|
|
|
|
def _CurrentFiletype( self, filetypes ):
|
|
supported = self.SupportedFiletypes()
|
|
|
|
for filetype in filetypes:
|
|
if filetype in supported:
|
|
return filetype
|
|
|
|
return filetypes[0]
|
|
|
|
|
|
@abc.abstractmethod
|
|
def SupportedFiletypes( self ):
|
|
pass
|
|
|
|
|
|
def DebugInfo( self, request_data ):
|
|
return ''
|
|
|
|
|
|
def Shutdown( self ):
|
|
pass
|
|
|
|
|
|
class CompletionsCache( object ):
|
|
def __init__( self ):
|
|
self.line = -1
|
|
self.column = -1
|
|
self.raw_completions = []
|
|
self.filtered_completions = []
|
|
|
|
|
|
def CacheValid( self, current_line, start_column ):
|
|
return current_line == self.line and start_column == self.column
|
|
|
|
|