def __init__(self, user_options):
self._user_options = user_options
self._filetype_completers = dict()
self._filetype_completers_lock = threading.Lock()
self._gencomp = GeneralCompleterStore(self._user_options)
class ServerState(object):
def __init__(self, user_options):
self._user_options = user_options
self._filetype_completers = dict()
self._filetype_completers_lock = threading.Lock()
self._gencomp = GeneralCompleterStore(self._user_options)
@property
def user_options(self):
return self._user_options
def Shutdown(self):
with self._filetype_completers_lock:
for completer in self._filetype_completers.values():
if completer:
completer.Shutdown()
self._gencomp.Shutdown()
def _GetFiletypeCompleterForFiletype(self, filetype):
with self._filetype_completers_lock:
try:
return self._filetype_completers[filetype]
except KeyError:
pass
module_path = PathToFiletypeCompleterPluginLoader(filetype)
completer = None
supported_filetypes = set([filetype])
if os.path.exists(module_path):
module = LoadPythonSource(filetype, module_path)
completer = module.GetCompleter(self._user_options)
if completer:
supported_filetypes.update(completer.SupportedFiletypes())
for supported_filetype in supported_filetypes:
self._filetype_completers[supported_filetype] = completer
return completer
def GetFiletypeCompleter(self, current_filetypes):
completers = [
self._GetFiletypeCompleterForFiletype(filetype)
for filetype in current_filetypes
]
for completer in completers:
if completer:
return completer
raise ValueError(
'No semantic completer exists for filetypes: {0}'.format(
current_filetypes))
def GetLoadedFiletypeCompleters(self):
with self._filetype_completers_lock:
return set([
completer
for completer in itervalues(self._filetype_completers)
if completer
])
def FiletypeCompletionAvailable(self, filetypes):
try:
self.GetFiletypeCompleter(filetypes)
return True
except Exception as e:
_logger.exception(e)
return False
def FiletypeCompletionUsable(self, filetypes):
return (self.CurrentFiletypeCompletionEnabled(filetypes)
and self.FiletypeCompletionAvailable(filetypes))
def ShouldUseFiletypeCompleter(self, request_data):
"""
Determines whether or not the semantic completer should be called, and
returns an indication of the reason why. Specifically, returns a tuple:
( should_use_completer_now, was_semantic_completion_forced ), where:
- should_use_completer_now: if True, the semantic engine should be used
- was_semantic_completion_forced: if True, the user requested "forced"
semantic completion
was_semantic_completion_forced is always False if should_use_completer_now
is False
"""
filetypes = request_data['filetypes']
if self.FiletypeCompletionUsable(filetypes):
if ForceSemanticCompletion(request_data):
# use semantic, and it was forced
return (True, True)
else:
# was not forced. check the conditions for triggering
return (self.GetFiletypeCompleter(filetypes).ShouldUseNow(
request_data), False)
# don't use semantic, ignore whether or not the user requested forced
# completion
return (False, False)
def GetGeneralCompleter(self):
return self._gencomp
def CurrentFiletypeCompletionEnabled(self, current_filetypes):
filetype_to_disable = self._user_options[
'filetype_specific_completion_to_disable']
if '*' in filetype_to_disable:
return False
else:
return not all(
[x in filetype_to_disable for x in current_filetypes])
class ServerState(object):
def __init__(self, user_options):
self._user_options = user_options
self._filetype_completers = {}
self._filetype_completers_lock = threading.Lock()
self._gencomp = GeneralCompleterStore(self._user_options)
@property
def user_options(self):
return self._user_options
def Shutdown(self):
with self._filetype_completers_lock:
for completer in self._filetype_completers.values():
if completer:
completer.Shutdown()
self._gencomp.Shutdown()
def _GetFiletypeCompleterForFiletype(self, filetype):
with self._filetype_completers_lock:
try:
return self._filetype_completers[filetype]
except KeyError:
pass
try:
module = import_module(
'ycmd.completers.{}.hook'.format(filetype))
completer = module.GetCompleter(self._user_options)
except ImportError:
completer = None
if completer is None:
completer = _GetGenericLSPCompleter(self._user_options,
filetype)
supported_filetypes = {filetype}
if completer:
supported_filetypes.update(completer.SupportedFiletypes())
for supported_filetype in supported_filetypes:
if supported_filetype not in self._filetype_completers:
self._filetype_completers[supported_filetype] = completer
return completer
def GetFiletypeCompleter(self, current_filetypes):
completers = [
self._GetFiletypeCompleterForFiletype(filetype)
for filetype in current_filetypes
]
for completer in completers:
if completer:
return completer
raise ValueError(
'No semantic completer exists for filetypes: {0}'.format(
current_filetypes))
def GetLoadedFiletypeCompleters(self):
with self._filetype_completers_lock:
return {
completer
for completer in itervalues(self._filetype_completers)
if completer
}
def FiletypeCompletionAvailable(self, filetypes):
try:
self.GetFiletypeCompleter(filetypes)
return True
except Exception:
LOGGER.exception('Semantic completion not available for %s',
filetypes)
return False
def FiletypeCompletionUsable(self, filetypes):
return (self.CurrentFiletypeCompletionEnabled(filetypes)
and self.FiletypeCompletionAvailable(filetypes))
def ShouldUseFiletypeCompleter(self, request_data):
"""Determines whether or not the semantic completer should be called."""
filetypes = request_data['filetypes']
if not self.FiletypeCompletionUsable(filetypes):
# don't use semantic, ignore whether or not the user requested forced
# completion
return False
if request_data['force_semantic']:
# use semantic, and it was forced
return True
# was not forced. check the conditions for triggering
return self.GetFiletypeCompleter(filetypes).ShouldUseNow(request_data)
def GetGeneralCompleter(self):
return self._gencomp
def CurrentFiletypeCompletionEnabled(self, current_filetypes):
filetype_to_disable = self._user_options[
'filetype_specific_completion_to_disable']
if '*' in filetype_to_disable:
return False
else:
return not all(x in filetype_to_disable for x in current_filetypes)
class ServerState( object ):
def __init__( self, user_options ):
self._user_options = user_options
self._filetype_completers = {}
self._filetype_completers_lock = threading.Lock()
self._gencomp = GeneralCompleterStore( self._user_options )
@property
def user_options( self ):
return self._user_options
def Shutdown( self ):
with self._filetype_completers_lock:
for completer in self._filetype_completers.itervalues():
if completer:
completer.Shutdown()
self._gencomp.Shutdown()
def _GetFiletypeCompleterForFiletype( self, filetype ):
with self._filetype_completers_lock:
try:
return self._filetype_completers[ filetype ]
except KeyError:
pass
module_path = PathToFiletypeCompleterPluginLoader( filetype )
completer = None
supported_filetypes = [ filetype ]
if os.path.exists( module_path ):
module = imp.load_source( filetype, module_path )
completer = module.GetCompleter( self._user_options )
if completer:
supported_filetypes.extend( completer.SupportedFiletypes() )
for supported_filetype in supported_filetypes:
self._filetype_completers[ supported_filetype ] = completer
return completer
def GetFiletypeCompleter( self, current_filetypes ):
completers = [ self._GetFiletypeCompleterForFiletype( filetype )
for filetype in current_filetypes ]
for completer in completers:
if completer:
return completer
raise ValueError( 'No semantic completer exists for filetypes: {0}'.format(
current_filetypes ) )
def FiletypeCompletionAvailable( self, filetypes ):
try:
self.GetFiletypeCompleter( filetypes )
return True
except:
return False
def FiletypeCompletionUsable( self, filetypes ):
return ( self.CurrentFiletypeCompletionEnabled( filetypes ) and
self.FiletypeCompletionAvailable( filetypes ) )
def ShouldUseGeneralCompleter( self, request_data ):
return self._gencomp.ShouldUseNow( request_data )
def ShouldUseFiletypeCompleter( self, request_data ):
filetypes = request_data[ 'filetypes' ]
if self.FiletypeCompletionUsable( filetypes ):
return ( ForceSemanticCompletion( request_data ) or
self.GetFiletypeCompleter( filetypes ).ShouldUseNow(
request_data ) )
return False
def GetGeneralCompleter( self ):
return self._gencomp
def CurrentFiletypeCompletionEnabled( self, current_filetypes ):
filetype_to_disable = self._user_options[
'filetype_specific_completion_to_disable' ]
if '*' in filetype_to_disable:
return False
else:
return not all([ x in filetype_to_disable for x in current_filetypes ])
class ServerState:
def __init__(self, user_options):
self._user_options = user_options
self._filetype_completers = {}
self._filetype_completers_lock = threading.Lock()
self._gencomp = GeneralCompleterStore(self._user_options)
@property
def user_options(self):
return self._user_options
def Shutdown(self):
with self._filetype_completers_lock:
for completer in self._filetype_completers.values():
if completer:
completer.Shutdown()
self._gencomp.Shutdown()
def _GetFiletypeCompleterForFiletype(self, filetype):
with self._filetype_completers_lock:
try:
return self._filetype_completers[filetype]
except KeyError:
pass
completer = _GetGenericLSPCompleter(self._user_options, filetype)
if completer is None:
try:
module = import_module(
f'ycmd.completers.{ filetype }.hook')
completer = module.GetCompleter(self._user_options)
except ImportError:
completer = None
supported_filetypes = {filetype}
if completer:
supported_filetypes.update(completer.SupportedFiletypes())
for supported_filetype in supported_filetypes:
if supported_filetype not in self._filetype_completers:
self._filetype_completers[supported_filetype] = completer
return completer
def GetFiletypeCompleter(self, current_filetypes):
completers = [
self._GetFiletypeCompleterForFiletype(filetype)
for filetype in current_filetypes
]
for completer in completers:
if completer:
return completer
raise ValueError(
f'No semantic completer exists for filetypes: { current_filetypes }'
)
def GetLoadedFiletypeCompleters(self):
with self._filetype_completers_lock:
return {
completer
for completer in self._filetype_completers.values()
if completer
}
def FiletypeCompletionAvailable(self, filetypes, silent=False):
"""Returns True if there is a ycmd semantic completer defined for any
filetype in the list |filetypes|. Otherwise, returns False and prints an
error to the log file, unless silent = True."""
try:
self.GetFiletypeCompleter(filetypes)
return True
except Exception:
if not silent:
LOGGER.exception('Semantic completion not available for %s',
filetypes)
return False
def FiletypeCompletionUsable(self, filetypes, silent=False):
"""Return True if ycmd supports semantic compltion for any filetype in the
list |filetypes| and those filetypes are not disabled by user options."""
return (self.CurrentFiletypeCompletionEnabled(filetypes)
and self.FiletypeCompletionAvailable(filetypes, silent))
def ShouldUseFiletypeCompleter(self, request_data):
"""Determines whether or not the semantic completion should be called for
completion request."""
filetypes = request_data['filetypes']
if not self.FiletypeCompletionUsable(filetypes):
# don't use semantic, ignore whether or not the user requested forced
# completion as that's not relevant to signatures.
return False
if request_data['force_semantic']:
# use semantic, and it was forced
return True
filetype_completer = self.GetFiletypeCompleter(filetypes)
# was not forced. check the conditions for triggering
return filetype_completer.ShouldUseNow(request_data)
def GetGeneralCompleter(self):
return self._gencomp
def CurrentFiletypeCompletionEnabled(self, current_filetypes):
"""Return False if all filetypes in the list |current_filetypes| are
disabled by the user option 'filetype_specific_completion_to_disable'."""
filetype_to_disable = self._user_options[
'filetype_specific_completion_to_disable']
if '*' in filetype_to_disable:
return False
else:
return not all(x in filetype_to_disable for x in current_filetypes)
def __init__( self, user_options ):
self._user_options = user_options
self._filetype_completers = {}
self._gencomp = GeneralCompleterStore( self._user_options )