def Subcommands_FixIt_Single_test(app):
fixit_test = PathToTestFile('testy', 'FixItTestCase.cs')
with WrapOmniSharpServer(app, fixit_test, wait_for_diags=False):
contents = ReadFile(fixit_test)
request = BuildRequest(completer_target='filetype_default',
command_arguments=['FixIt'],
line_num=4,
column_num=17,
contents=contents,
filetype='cs',
filepath=fixit_test)
response = app.post_json('/run_completer_command', request).json
LOGGER.debug('r = %s', response)
assert_that(
response,
has_entries({
'fixits':
contains_exactly(
has_entries({
'location':
LocationMatcher(fixit_test, 4, 17),
'chunks':
contains_exactly(
has_entries({
'replacement_text':
'var',
'range':
RangeMatcher(fixit_test, (4, 13), (4, 16))
}))
}))
}))
def _GetResponse(self, handler, request_data=None, method='POST'):
"""
Query racerd via HTTP
racerd returns JSON with 200 OK responses. 204 No Content responses occur
when no errors were encountered but no completions, definitions, or errors
were found.
"""
handler = ToBytes(handler)
method = ToBytes(method)
url = urljoin(ToBytes(self._racerd_host), handler)
parameters = self._ConvertToRacerdRequest(request_data)
body = ToBytes(json.dumps(parameters)) if parameters else bytes()
extra_headers = self._ExtraHeaders(method, handler, body)
LOGGER.debug('Making racerd request: %s %s %s %s', method, url,
extra_headers, body)
# Failing to wrap the method & url bytes objects in `native()` causes HMAC
# failures (403 Forbidden from racerd) for unknown reasons. Similar for
# request_hmac above.
response = requests.request(native(method),
native(url),
data=body,
headers=extra_headers)
response.raise_for_status()
if response.status_code == requests.codes.no_content:
return None
return response.json()
def _CallGlobalExtraConfMethod( function_name ):
global_ycm_extra_conf = _GlobalYcmExtraConfFileLocation()
if not ( global_ycm_extra_conf and
os.path.exists( global_ycm_extra_conf ) ):
LOGGER.debug( 'No global extra conf, not calling method %s', function_name )
return
try:
module = Load( global_ycm_extra_conf, force = True )
except Exception:
LOGGER.exception( 'Error occurred while loading global extra conf %s',
global_ycm_extra_conf )
return
if not module or not hasattr( module, function_name ):
LOGGER.debug( 'Global extra conf not loaded or no function %s',
function_name )
return
try:
LOGGER.info( 'Calling global extra conf method %s on conf file %s',
function_name,
global_ycm_extra_conf )
getattr( module, function_name )()
except Exception:
LOGGER.exception(
'Error occurred while calling global extra conf method %s '
'on conf file %s', function_name, global_ycm_extra_conf )
def SignatureHelp_TriggerParen_test(app):
filepath = PathToTestFile('testy', 'ContinuousTest.cs')
contents = ReadFile(filepath)
request = BuildRequest(line_num=10,
column_num=9,
filetypes=['cs'],
filepath=filepath,
contents=contents)
with WrapOmniSharpServer(app, filepath):
response = app.post_json('/signature_help', request).json
LOGGER.debug('response = %s', response)
assert_that(
response,
has_entries({
'errors':
empty(),
'signature_help':
has_entries({
'activeSignature':
0,
'activeParameter':
0,
'signatures':
contains(
SignatureMatcher(
'void ContinuousTest.Main(string[] args)',
[ParameterMatcher(25, 38)]))
})
}))
def _CallGlobalExtraConfMethod(function_name):
global_ycm_extra_conf = _GlobalYcmExtraConfFileLocation()
if not (global_ycm_extra_conf and os.path.exists(global_ycm_extra_conf)):
LOGGER.debug('No global extra conf, not calling method %s',
function_name)
return
try:
module = Load(global_ycm_extra_conf, force=True)
except Exception:
LOGGER.exception('Error occurred while loading global extra conf %s',
global_ycm_extra_conf)
return
if not module or not hasattr(module, function_name):
LOGGER.debug('Global extra conf not loaded or no function %s',
function_name)
return
try:
LOGGER.info('Calling global extra conf method %s on conf file %s',
function_name, global_ycm_extra_conf)
getattr(module, function_name)()
except Exception:
LOGGER.exception(
'Error occurred while calling global extra conf method %s '
'on conf file %s', function_name, global_ycm_extra_conf)
def test_SignatureHelp_TriggerComma(self, app):
filepath = PathToTestFile('testy', 'ContinuousTest.cs')
contents = ReadFile(filepath)
request = BuildRequest(line_num=17,
column_num=16,
filetypes=['cs'],
filepath=filepath,
contents=contents)
with WrapOmniSharpServer(app, filepath):
response = app.post_json('/signature_help', request).json
LOGGER.debug('response = %s', response)
assert_that(
response,
has_entries({
'errors':
empty(),
'signature_help':
has_entries({
'activeSignature':
0,
'activeParameter':
1,
'signatures':
contains_exactly(
SignatureMatcher(
'void ContinuousTest.MultiArg(int i, string s)',
[
ParameterMatcher(29, 34),
ParameterMatcher(36, 44)
]))
})
}))
def _GetResponse(self, handler, parameters={}, timeout=None):
""" Handle communication with server """
target = urljoin(self._ServerLocation(), handler)
LOGGER.debug('TX: %s', parameters)
response = requests.post(target, json=parameters, timeout=timeout)
LOGGER.debug('RX: %s', response.json())
return response.json()
def Subcommands_FixIt_Single_test(app):
fixit_test = PathToTestFile('testy', 'FixItTestCase.cs')
with WrapOmniSharpServer(app, fixit_test):
contents = ReadFile(fixit_test)
request = BuildRequest(completer_target='filetype_default',
command_arguments=['FixIt'],
line_num=4,
column_num=23,
contents=contents,
filetype='cs',
filepath=fixit_test)
response = app.post_json('/run_completer_command', request).json
LOGGER.debug('r = %s', response)
assert_that(
response,
has_entries({
'fixits':
contains(
has_entries({
'location':
LocationMatcher(fixit_test, 4, 23),
'chunks':
contains(
has_entries({
'replacement_text':
'\n {\n NewMethod();\n }\n\n'
' private static void NewMethod()\n {\r\n',
'range':
RangeMatcher(fixit_test, (3, 31), (4, 1))
}))
}))
}))
def GetCompletions():
request_data = RequestWrap(request.json)
do_filetype_completion = _server_state.ShouldUseFiletypeCompleter(
request_data)
LOGGER.debug('Using filetype completion: %s', do_filetype_completion)
errors = None
completions = None
if do_filetype_completion:
try:
filetype_completer = _server_state.GetFiletypeCompleter(
request_data['filetypes'])
completions = filetype_completer.ComputeCandidates(request_data)
except Exception as exception:
if request_data['force_semantic']:
# user explicitly asked for semantic completion, so just pass the error
# back
raise
# store the error to be returned with results from the identifier
# completer
LOGGER.exception(
'Exception from semantic completer (using general)')
stack = traceback.format_exc()
errors = [BuildExceptionResponse(exception, stack)]
if not completions and not request_data['force_semantic']:
completions = _server_state.GetGeneralCompleter().ComputeCandidates(
request_data)
return _JsonResponse(
BuildCompletionResponse(completions if completions else [],
request_data['start_column'],
errors=errors))
def Keepalive( check_interval_seconds ):
while True:
time.sleep( check_interval_seconds )
LOGGER.debug( 'Keeping subservers alive' )
loaded_completers = _server_state.GetLoadedFiletypeCompleters()
for completer in loaded_completers:
completer.ServerIsHealthy()
def Keepalive(check_interval_seconds):
while True:
time.sleep(check_interval_seconds)
LOGGER.debug('Keeping subservers alive')
loaded_completers = _server_state.GetLoadedFiletypeCompleters()
for completer in loaded_completers:
completer.ServerIsHealthy()
def _RestartServer(self):
LOGGER.debug('Restarting racerd')
with self._server_state_lock:
if self._ServerIsRunning():
self._StopServer()
self._StartServer()
LOGGER.debug('Racerd restarted')
def _RestartServer( self ):
LOGGER.debug( 'Restarting racerd' )
with self._server_state_lock:
if self._ServerIsRunning():
self._StopServer()
self._StartServer()
LOGGER.debug( 'Racerd restarted' )
def StartServer( self, request_data, project_directory = None ):
with self._server_state_mutex:
LOGGER.info( 'Starting jdt.ls Language Server...' )
if project_directory:
self._java_project_dir = project_directory
else:
self._java_project_dir = _FindProjectDir(
os.path.dirname( request_data[ 'filepath' ] ) )
self._workspace_path = _WorkspaceDirForProject(
self._java_project_dir,
self._use_clean_workspace )
command = [
PATH_TO_JAVA,
'-Dfile.encoding=UTF-8',
'-Declipse.application=org.eclipse.jdt.ls.core.id1',
'-Dosgi.bundles.defaultStartLevel=4',
'-Declipse.product=org.eclipse.jdt.ls.core.product',
'-Dlog.level=ALL',
'-jar', self._launcher_path,
'-configuration', self._launcher_config,
'-data', self._workspace_path,
]
LOGGER.debug( 'Starting java-server with the following command: %s',
command )
self._server_stderr = utils.CreateLogfile( 'jdt.ls_stderr_' )
with utils.OpenForStdHandle( self._server_stderr ) as stderr:
self._server_handle = utils.SafePopen( command,
stdin = PIPE,
stdout = PIPE,
stderr = stderr )
self._connection = (
language_server_completer.StandardIOLanguageServerConnection(
self._server_handle.stdin,
self._server_handle.stdout,
self.GetDefaultNotificationHandler() )
)
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except language_server_completer.LanguageServerConnectionTimeout:
LOGGER.error( 'jdt.ls failed to start, or did not connect '
'successfully' )
self.Shutdown()
return False
LOGGER.info( 'jdt.ls Language Server started' )
return True
def StartServer(self, request_data, project_directory=None):
with self._server_state_mutex:
LOGGER.info('Starting jdt.ls Language Server...')
if project_directory:
self._java_project_dir = project_directory
else:
self._java_project_dir = _FindProjectDir(
os.path.dirname(request_data['filepath']))
self._workspace_path = _WorkspaceDirForProject(
self._java_project_dir, self._use_clean_workspace)
command = [
PATH_TO_JAVA,
'-Dfile.encoding=UTF-8',
'-Declipse.application=org.eclipse.jdt.ls.core.id1',
'-Dosgi.bundles.defaultStartLevel=4',
'-Declipse.product=org.eclipse.jdt.ls.core.product',
'-Dlog.level=ALL',
'-jar',
self._launcher_path,
'-configuration',
self._launcher_config,
'-data',
self._workspace_path,
]
LOGGER.debug('Starting java-server with the following command: %s',
command)
self._server_stderr = utils.CreateLogfile('jdt.ls_stderr_')
with utils.OpenForStdHandle(self._server_stderr) as stderr:
self._server_handle = utils.SafePopen(command,
stdin=PIPE,
stdout=PIPE,
stderr=stderr)
self._connection = (
language_server_completer.StandardIOLanguageServerConnection(
self._server_handle.stdin, self._server_handle.stdout,
self.GetDefaultNotificationHandler()))
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except language_server_completer.LanguageServerConnectionTimeout:
LOGGER.error('jdt.ls failed to start, or did not connect '
'successfully')
self.Shutdown()
return False
LOGGER.info('jdt.ls Language Server started')
return True
def _StartServer( self, request_data ):
with self._server_state_mutex:
if self._server_started:
return
self._server_started = True
LOGGER.info( 'Starting Tern server...' )
self._SetServerProjectFileAndWorkingDirectory( request_data )
self._server_port = utils.GetUnusedLocalhostPort()
command = [ PATH_TO_NODE,
PATH_TO_TERN_BINARY,
'--port',
str( self._server_port ),
'--host',
SERVER_HOST,
'--persistent',
'--no-port-file' ]
if LOGGER.isEnabledFor( logging.DEBUG ):
command.append( '--verbose' )
LOGGER.debug( 'Starting tern with the following command: %s', command )
self._server_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stdout' ) )
self._server_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stderr' ) )
# We need to open a pipe to stdin or the Tern server is killed.
# See https://github.com/ternjs/tern/issues/740#issuecomment-203979749
# For unknown reasons, this is only needed on Windows and for Python
# 3.4+ on other platforms.
with utils.OpenForStdHandle( self._server_stdout ) as stdout:
with utils.OpenForStdHandle( self._server_stderr ) as stderr:
self._server_handle = utils.SafePopen(
command,
stdin = PIPE,
stdout = stdout,
stderr = stderr,
cwd = self._server_working_dir )
if self._ServerIsRunning():
LOGGER.info( 'Tern Server started with pid %d listening on port %d',
self._server_handle.pid, self._server_port )
LOGGER.info( 'Tern Server log files are %s and %s',
self._server_stdout, self._server_stderr )
self._do_tern_project_check = True
else:
LOGGER.warning( 'Tern server did not start successfully' )
def _StartServer( self, request_data ):
with self._server_state_mutex:
if self._server_started:
return
self._server_started = True
LOGGER.info( 'Starting Tern server...' )
self._SetServerProjectFileAndWorkingDirectory( request_data )
self._server_port = utils.GetUnusedLocalhostPort()
command = [ PATH_TO_NODE,
PATH_TO_TERN_BINARY,
'--port',
str( self._server_port ),
'--host',
SERVER_HOST,
'--persistent',
'--no-port-file' ]
if LOGGER.isEnabledFor( logging.DEBUG ):
command.append( '--verbose' )
LOGGER.debug( 'Starting tern with the following command: %s', command )
self._server_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stdout' ) )
self._server_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stderr' ) )
# We need to open a pipe to stdin or the Tern server is killed.
# See https://github.com/ternjs/tern/issues/740#issuecomment-203979749
# For unknown reasons, this is only needed on Windows and for Python
# 3.4+ on other platforms.
with utils.OpenForStdHandle( self._server_stdout ) as stdout:
with utils.OpenForStdHandle( self._server_stderr ) as stderr:
self._server_handle = utils.SafePopen(
command,
stdin = PIPE,
stdout = stdout,
stderr = stderr,
cwd = self._server_working_dir )
if self._ServerIsRunning():
LOGGER.info( 'Tern Server started with pid %d listening on port %d',
self._server_handle.pid, self._server_port )
LOGGER.info( 'Tern Server log files are %s and %s',
self._server_stdout, self._server_stderr )
self._do_tern_project_check = True
else:
LOGGER.warning( 'Tern server did not start successfully' )
def _ApplySuggestionsToFixIt(request_data, command):
LOGGER.debug('command = %s', command)
args = command['arguments']
text_edits = [{'range': args[0]['range'], 'newText': args[1]}]
uri = args[0]['uri']
return responses.FixIt(
responses.Location(request_data['line_num'],
request_data['column_num'],
request_data['filepath']),
language_server_completer.TextEditToChunks(request_data, uri,
text_edits), args[1])
def GetSettings(self, module, request_data):
if hasattr(module, 'Settings'):
settings = module.Settings(
filename=request_data['filepath'],
client_data=request_data['extra_conf_data'])
if settings is not None:
return settings
LOGGER.debug('No Settings function defined in %s', module.__file__)
return {}
def Subcommands_FixIt_Multi_test(app):
fixit_test = PathToTestFile('testy', 'FixItTestCase.cs')
with WrapOmniSharpServer(app, fixit_test):
contents = ReadFile(fixit_test)
request = BuildRequest(completer_target='filetype_default',
command_arguments=['FixIt'],
line_num=4,
column_num=27,
contents=contents,
filetype='cs',
filepath=fixit_test)
response = app.post_json('/run_completer_command', request).json
assert_that(
response,
has_entries({
'fixits':
contains(
has_entries({
'text': 'Introduce constant',
'command': has_entries({'index': 0}),
'resolve': True
}),
has_entries({
'text': 'Convert to binary',
'command': has_entries({'index': 1}),
'resolve': True
}),
has_entries({
'text': 'Convert to hex',
'command': has_entries({'index': 2}),
'resolve': True
}),
)
}))
request.pop('command_arguments')
request.update({'fixit': response['fixits'][1]})
response = app.post_json('/resolve_fixit', request).json
LOGGER.debug('r = %s', response)
assert_that(
response,
has_entries({
'fixits':
contains(
has_entries({
'location':
LocationMatcher(fixit_test, 4, 27),
'chunks':
contains(has_entries({
'replacement_text': '0b101',
}))
}))
}))
def _GetResponse( self, handler, parameters = {}, timeout = None ):
""" Handle communication with server """
target = urljoin( self._ServerLocation(), handler )
LOGGER.debug( 'TX (%s): %s', handler, parameters )
try:
response = urllib.request.urlopen(
target,
data = ToBytes( json.dumps( parameters ) ),
timeout = timeout )
response = json.loads( response.read() )
except urllib.error.HTTPError as response:
response = json.loads( response.fp.read() )
LOGGER.debug( 'RX: %s', response )
return response
def _PathToLauncherJar():
# The file name changes between version of eclipse, so we use a glob as
# recommended by the language server developers. There should only be one.
launcher_jars = glob.glob(
os.path.abspath(
os.path.join(LANGUAGE_SERVER_HOME, 'plugins',
'org.eclipse.equinox.launcher_*.jar')))
LOGGER.debug('Found launchers: %s', launcher_jars)
if not launcher_jars:
return None
return launcher_jars[0]
def _GetSettings(self, module, client_data):
# We don't warn the user if no extra conf file is found.
if module:
if hasattr(module, 'Settings'):
settings = module.Settings(language='python',
client_data=client_data)
if settings is not None:
return settings
LOGGER.debug('No Settings function defined in %s', module.__file__)
return {
# NOTE: this option is only kept for backward compatibility. Setting the
# Python interpreter path through the extra conf file is preferred.
'interpreter_path': self.user_options['python_binary_path']
}
def _GetSettings( self, module, client_data ):
# We don't warn the user if no extra conf file is found.
if module:
if hasattr( module, 'Settings' ):
settings = module.Settings( language = 'python',
client_data = client_data )
if settings is not None:
return settings
LOGGER.debug( 'No Settings function defined in %s', module.__file__ )
return {
# NOTE: this option is only kept for backward compatibility. Setting the
# Python interpreter path through the extra conf file is preferred.
'interpreter_path': self.user_options[ 'python_binary_path' ]
}
def _GetSysPath(self, request_data, environment):
settings = {'sys_path': []}
settings.update(self._SettingsForRequest(request_data))
settings['interpreter_path'] = environment.executable
settings['sys_path'].extend(environment.get_sys_path())
filepath = request_data['filepath']
module = extra_conf_store.ModuleForSourceFile(filepath)
# We don't warn the user if no extra conf file is found.
if module:
if hasattr(module, 'PythonSysPath'):
return module.PythonSysPath(**settings)
LOGGER.debug('No PythonSysPath function defined in %s',
module.__file__)
return settings['sys_path']
def _PathToLauncherJar():
# The file name changes between version of eclipse, so we use a glob as
# recommended by the language server developers. There should only be one.
launcher_jars = glob.glob(
os.path.abspath(
os.path.join(
LANGUAGE_SERVER_HOME,
'plugins',
'org.eclipse.equinox.launcher_*.jar' ) ) )
LOGGER.debug( 'Found launchers: %s', launcher_jars )
if not launcher_jars:
return None
return launcher_jars[ 0 ]
def ServerIsHealthy(self):
"""
Check if racerd is alive AND ready to serve requests.
"""
if not self._ServerIsRunning():
LOGGER.debug('Racerd not running')
return False
try:
self._GetResponse('/ping', method='GET')
return True
# Do NOT make this except clause more generic! If you need to catch more
# exception types, list them all out. Having `Exception` here caused FORTY
# HOURS OF DEBUGGING.
except requests.exceptions.ConnectionError:
LOGGER.exception('Failed to connect to racerd')
return False
def _GetSysPath( self, request_data, environment ):
settings = {
'sys_path': []
}
settings.update( self._SettingsForRequest( request_data ) )
settings[ 'interpreter_path' ] = environment.executable
settings[ 'sys_path' ].extend( environment.get_sys_path() )
filepath = request_data[ 'filepath' ]
module = extra_conf_store.ModuleForSourceFile( filepath )
# We don't warn the user if no extra conf file is found.
if module:
if hasattr( module, 'PythonSysPath' ):
return module.PythonSysPath( **settings )
LOGGER.debug( 'No PythonSysPath function defined in %s', module.__file__ )
return settings[ 'sys_path' ]
def ServerIsHealthy( self ):
"""
Check if racerd is alive AND ready to serve requests.
"""
if not self._ServerIsRunning():
LOGGER.debug( 'Racerd not running' )
return False
try:
self._GetResponse( '/ping', method = 'GET' )
return True
# Do NOT make this except clause more generic! If you need to catch more
# exception types, list them all out. Having `Exception` here caused FORTY
# HOURS OF DEBUGGING.
except requests.exceptions.ConnectionError:
LOGGER.exception( 'Failed to connect to racerd' )
return False
def GetSettings(self, module, request_data):
if hasattr(module, 'Settings'):
try:
settings = module.Settings(
language=self.Language(),
filename=request_data['filepath'],
client_data=request_data['extra_conf_data'])
except IgnoreExtraConf:
settings = None
if settings is not None:
return settings
LOGGER.debug('No Settings function defined in %s', module.__file__)
return {}
def EventNotification():
request_data = RequestWrap(request.json)
event_name = request_data['event_name']
LOGGER.debug('Event name: %s', event_name)
event_handler = 'On' + event_name
getattr(_server_state.GetGeneralCompleter(), event_handler)(request_data)
filetypes = request_data['filetypes']
response_data = None
if _server_state.FiletypeCompletionUsable(filetypes):
response_data = getattr(_server_state.GetFiletypeCompleter(filetypes),
event_handler)(request_data)
if response_data:
return _JsonResponse(response_data)
return _JsonResponse({})
def EventNotification():
LOGGER.info( 'Received event notification' )
request_data = RequestWrap( request.json )
event_name = request_data[ 'event_name' ]
LOGGER.debug( 'Event name: %s', event_name )
event_handler = 'On' + event_name
getattr( _server_state.GetGeneralCompleter(), event_handler )( request_data )
filetypes = request_data[ 'filetypes' ]
response_data = None
if _server_state.FiletypeCompletionUsable( filetypes ):
response_data = getattr( _server_state.GetFiletypeCompleter( filetypes ),
event_handler )( request_data )
if response_data:
return _JsonResponse( response_data )
return _JsonResponse( {} )
def SignatureHelp_MultipleSignatures_test( app ):
filepath = PathToTestFile( 'testy', 'ContinuousTest.cs' )
contents = ReadFile( filepath )
request = BuildRequest(
line_num = 18,
column_num = 15,
filetypes = [ 'cs' ],
filepath = filepath,
contents = contents )
with WrapOmniSharpServer( app, filepath ):
response = app.post_json( '/signature_help', request ).json
LOGGER.debug( 'response = %s', response )
assert_that( response, has_entries( {
'errors': empty(),
'signature_help': has_entries( {
'activeSignature': 0,
'activeParameter': 0,
'signatures': contains_exactly(
SignatureMatcher( 'void ContinuousTest.Overloaded(int i, int a)',
[ ParameterMatcher( 31, 36 ),
ParameterMatcher( 38, 43 ) ] ),
SignatureMatcher( 'void ContinuousTest.Overloaded(string s)',
[ ParameterMatcher( 31, 39 ) ] ),
)
} )
} ) )
request[ 'column_num' ] = 20
with WrapOmniSharpServer( app, filepath ):
response = app.post_json( '/signature_help', request ).json
LOGGER.debug( 'response = %s', response )
assert_that( response, has_entries( {
'errors': empty(),
'signature_help': has_entries( {
'activeSignature': 0,
'activeParameter': 1,
'signatures': contains_exactly(
SignatureMatcher( 'void ContinuousTest.Overloaded(int i, int a)',
[ ParameterMatcher( 31, 36 ),
ParameterMatcher( 38, 43 ) ] ),
SignatureMatcher( 'void ContinuousTest.Overloaded(string s)',
[ ParameterMatcher( 31, 39 ) ] ),
)
} )
} ) )
def SignatureHelp_NotAFunction_NoError_test( app ):
filepath = PathToTestFile( 'testy', 'ContinuousTest.cs' )
contents = ReadFile( filepath )
request = BuildRequest(
line_num = 19,
column_num = 7,
filetypes = [ 'cs' ],
filepath = filepath,
contents = contents )
with WrapOmniSharpServer( app, filepath ):
response = app.post_json( '/signature_help', request ).json
LOGGER.debug( 'response = %s', response )
assert_that( response, has_entries( {
'errors': empty(),
'signature_help': has_entries( {
'activeSignature': 0,
'activeParameter': 0,
'signatures': empty()
} )
} ) )
def _CollectExtensionBundles(extension_path):
extension_bundles = []
for extension_dir in extension_path:
if not os.path.isdir(extension_dir):
LOGGER.info('extension directory does not exist: {0}'.format(
extension_dir))
continue
for path in os.listdir(extension_dir):
path = os.path.join(extension_dir, path)
manifest_file = os.path.join(path, 'package.json')
if not os.path.isdir(path) or not os.path.isfile(manifest_file):
LOGGER.debug('{0} is not an extension directory'.format(path))
continue
manifest_json = utils.ReadFile(manifest_file)
try:
manifest = json.loads(manifest_json)
except ValueError:
LOGGER.exception(
'Could not load bundle {0}'.format(manifest_file))
continue
if ('contributes' not in manifest
or 'javaExtensions' not in manifest['contributes']
or not isinstance(
manifest['contributes']['javaExtensions'], list)):
LOGGER.info(
'Bundle {0} is not a java extension'.format(manifest_file))
continue
LOGGER.info('Found bundle: {0}'.format(manifest_file))
extension_bundles.extend([
os.path.join(path, p)
for p in manifest['contributes']['javaExtensions']
])
return extension_bundles
def _FindProjectDir( starting_dir ):
project_path = starting_dir
project_type = None
for folder in utils.PathsToAllParentFolders( starting_dir ):
for project_file, tail in _MakeProjectFilesForPath( folder ):
if os.path.isfile( project_file ):
project_path = folder
project_type = tail
break
if project_type:
break
if project_type:
# We've found a project marker file (like build.gradle). Search parent
# directories for that same project type file and find the topmost one as
# the project root.
LOGGER.debug( 'Found %s style project in %s. Searching for '
'project root:', project_type, project_path )
for folder in utils.PathsToAllParentFolders( os.path.join( project_path,
'..' ) ):
if os.path.isfile( os.path.join( folder, project_type ) ):
LOGGER.debug( ' %s is a parent project dir', folder )
project_path = folder
else:
break
LOGGER.debug( ' Project root is %s', project_path )
return project_path
def _FindProjectDir(starting_dir):
project_path = starting_dir
project_type = None
for folder in utils.PathsToAllParentFolders(starting_dir):
for project_file, tail in _MakeProjectFilesForPath(folder):
if os.path.isfile(project_file):
project_path = folder
project_type = tail
break
if project_type:
break
if project_type:
# We've found a project marker file (like build.gradle). Search parent
# directories for that same project type file and find the topmost one as
# the project root.
LOGGER.debug(
'Found %s style project in %s. Searching for '
'project root:', project_type, project_path)
for folder in utils.PathsToAllParentFolders(
os.path.join(project_path, '..')):
if os.path.isfile(os.path.join(folder, project_type)):
LOGGER.debug(' %s is a parent project dir', folder)
project_path = folder
else:
break
LOGGER.debug(' Project root is %s', project_path)
return project_path
def _GetJediProject(self, request_data, environment):
settings = {'sys_path': []}
settings.update(self._SettingsForRequest(request_data))
settings['interpreter_path'] = environment.executable
settings['sys_path'].extend(environment.get_sys_path())
filepath = request_data['filepath']
module = extra_conf_store.ModuleForSourceFile(filepath)
# We don't warn the user if no extra conf file is found.
if module:
if hasattr(module, 'PythonSysPath'):
settings['sys_path'] = module.PythonSysPath(**settings)
LOGGER.debug('No PythonSysPath function defined in %s',
module.__file__)
project_directory = settings.get('project_directory')
if not project_directory:
default_project = jedi.get_default_project(
os.path.dirname(request_data['filepath']))
project_directory = default_project._path
return jedi.Project(project_directory,
sys_path=settings['sys_path'],
environment_path=settings['interpreter_path'])
def GetCompletions():
LOGGER.info( 'Received completion request' )
request_data = RequestWrap( request.json )
do_filetype_completion = _server_state.ShouldUseFiletypeCompleter(
request_data )
LOGGER.debug( 'Using filetype completion: %s', do_filetype_completion )
errors = None
completions = None
if do_filetype_completion:
try:
completions = ( _server_state.GetFiletypeCompleter(
request_data[ 'filetypes' ] )
.ComputeCandidates( request_data ) )
except Exception as exception:
if request_data[ 'force_semantic' ]:
# user explicitly asked for semantic completion, so just pass the error
# back
raise
# store the error to be returned with results from the identifier
# completer
LOGGER.exception( 'Exception from semantic completer (using general)' )
stack = traceback.format_exc()
errors = [ BuildExceptionResponse( exception, stack ) ]
if not completions and not request_data[ 'force_semantic' ]:
completions = _server_state.GetGeneralCompleter().ComputeCandidates(
request_data )
return _JsonResponse(
BuildCompletionResponse( completions if completions else [],
request_data[ 'start_column' ],
errors = errors ) )
def _GetResponse( self, handler, request_data = None,
method = 'POST' ):
"""
Query racerd via HTTP
racerd returns JSON with 200 OK responses. 204 No Content responses occur
when no errors were encountered but no completions, definitions, or errors
were found.
"""
handler = ToBytes( handler )
method = ToBytes( method )
url = urljoin( ToBytes( self._racerd_host ), handler )
parameters = self._ConvertToRacerdRequest( request_data )
body = ToBytes( json.dumps( parameters ) ) if parameters else bytes()
extra_headers = self._ExtraHeaders( method, handler, body )
LOGGER.debug( 'Making racerd request: %s %s %s %s',
method,
url,
extra_headers,
body )
# Failing to wrap the method & url bytes objects in `native()` causes HMAC
# failures (403 Forbidden from racerd) for unknown reasons. Similar for
# request_hmac above.
response = requests.request( native( method ),
native( url ),
data = body,
headers = extra_headers )
response.raise_for_status()
if response.status_code == requests.codes.no_content:
return None
return response.json()
def Shutdown( self ): LOGGER.debug( 'Shutting down Tern server' ) self._StopServer()
def Shutdown(self):
LOGGER.debug('Shutting down Tern server')
self._StopServer()
