def PathsToAllConfigFiles( vimspector_base, current_file, filetypes ):
for ft in filetypes + [ '_all' ]:
for p in sorted( glob.glob(
os.path.join( install.GetConfigDirForFiletype( vimspector_base, ft ),
'*.json' ) ) ):
yield p
for ft in filetypes:
yield utils.PathToConfigFile( f'.vimspector.{ft}.json',
os.path.dirname( current_file ) )
yield utils.PathToConfigFile( '.vimspector.json',
os.path.dirname( current_file ) )
def PathsToAllGadgetConfigs( vimspector_base, current_file ):
yield install.GetGadgetConfigFile( vimspector_base )
for p in sorted( glob.glob(
os.path.join( install.GetGadgetConfigDir( vimspector_base ),
'*.json' ) ) ):
yield p
yield utils.PathToConfigFile( '.gadgets.json',
os.path.dirname( current_file ) )
def Start(self, configuration=None):
self._configuration = None
self._adapter = None
launch_config_file = utils.PathToConfigFile('.vimspector.json')
if not launch_config_file:
utils.UserMessage(
'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application')
return
with open(launch_config_file, 'r') as f:
database = json.load(f)
launch_config = database.get('configurations')
adapters = database.get('adapters')
if not configuration:
if len(launch_config) == 1:
configuration = next(iter(launch_config.keys()))
else:
configuration = utils.SelectFromList(
'Which launch configuration?', list(launch_config.keys()))
if not configuration:
return
utils.ExpandReferencesInDict(
launch_config[configuration],
{'workspaceRoot': os.path.dirname(launch_config_file)})
adapter = launch_config[configuration].get('adapter')
if isinstance(adapter, str):
adapter = adapters.get(adapter)
utils.ExpandReferencesInDict(
adapter,
{'workspaceRoot': os.path.dirname(launch_config_file)})
self._StartWithConfiguration(launch_config[configuration], adapter)
def Start( self, launch_variables = {} ):
self._logger.info( "User requested start debug session with %s",
launch_variables )
self._configuration = None
self._adapter = None
current_file = utils.GetBufferFilepath( vim.current.buffer )
launch_config_file = utils.PathToConfigFile(
'.vimspector.json',
os.path.dirname( current_file ) )
if not launch_config_file:
utils.UserMessage( 'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application.' )
return
with open( launch_config_file, 'r' ) as f:
database = json.load( f )
configurations = database.get( 'configurations' )
adapters = {}
glob.glob( install.GetGadgetDir( VIMSPECTOR_HOME, install.GetOS() ) )
for gadget_config_file in PathsToAllGadgetConfigs( VIMSPECTOR_HOME,
current_file ):
self._logger.debug( f'Reading gadget config: {gadget_config_file}' )
if gadget_config_file and os.path.exists( gadget_config_file ):
with open( gadget_config_file, 'r' ) as f:
adapters.update( json.load( f ).get( 'adapters' ) or {} )
adapters.update( database.get( 'adapters' ) or {} )
if 'configuration' in launch_variables:
configuration_name = launch_variables.pop( 'configuration' )
elif len( configurations ) == 1:
configuration_name = next( iter( configurations.keys() ) )
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted( list( configurations.keys() ) ) )
if not configuration_name or configuration_name not in configurations:
return
self._workspace_root = os.path.dirname( launch_config_file )
configuration = configurations[ configuration_name ]
adapter = configuration.get( 'adapter' )
if isinstance( adapter, str ):
adapter = adapters.get( adapter )
# TODO: Do we want some form of persistence ? e.g. self._staticVariables,
# set from an api call like SetLaunchParam( 'var', 'value' ), perhaps also a
# way to load .vimspector.local.json which just sets variables
#
# Additional vars as defined by VSCode:
#
# ${workspaceFolder} - the path of the folder opened in VS Code
# ${workspaceFolderBasename} - the name of the folder opened in VS Code
# without any slashes (/)
# ${file} - the current opened file
# ${relativeFile} - the current opened file relative to workspaceFolder
# ${fileBasename} - the current opened file's basename
# ${fileBasenameNoExtension} - the current opened file's basename with no
# file extension
# ${fileDirname} - the current opened file's dirname
# ${fileExtname} - the current opened file's extension
# ${cwd} - the task runner's current working directory on startup
# ${lineNumber} - the current selected line number in the active file
# ${selectedText} - the current selected text in the active file
# ${execPath} - the path to the running VS Code executable
def relpath( p, relative_to ):
if not p:
return ''
return os.path.relpath( p, relative_to )
def splitext( p ):
if not p:
return [ '', '' ]
return os.path.splitext( p )
self._variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'workspaceFolder': self._workspace_root,
'gadgetDir': install.GetGadgetDir( VIMSPECTOR_HOME, install.GetOS() ),
'file': current_file,
'relativeFile': relpath( current_file, self._workspace_root ),
'fileBasename': os.path.basename( current_file ),
'fileBasenameNoExtension':
splitext( os.path.basename( current_file ) )[ 0 ],
'fileDirname': os.path.dirname( current_file ),
'fileExtname': splitext( os.path.basename( current_file ) )[ 1 ],
# NOTE: this is the window-local cwd for the current window, *not* Vim's
# working directory.
'cwd': os.getcwd(),
}
# Pretend that vars passed to the launch command were typed in by the user
# (they may have been in theory)
USER_CHOICES.update( launch_variables )
self._variables.update( launch_variables )
self._variables.update(
utils.ParseVariables( adapter.get( 'variables', {} ),
self._variables,
USER_CHOICES ) )
self._variables.update(
utils.ParseVariables( configuration.get( 'variables', {} ),
self._variables,
USER_CHOICES ) )
utils.ExpandReferencesInDict( configuration,
self._variables,
USER_CHOICES )
utils.ExpandReferencesInDict( adapter,
self._variables,
USER_CHOICES )
if not adapter:
utils.UserMessage( 'No adapter configured for {}'.format(
configuration_name ), persist=True )
return
self._StartWithConfiguration( configuration, adapter )
def Start(self, launch_variables={}):
self._configuration = None
self._adapter = None
launch_config_file = utils.PathToConfigFile('.vimspector.json')
if not launch_config_file:
utils.UserMessage(
'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application')
return
with open(launch_config_file, 'r') as f:
database = json.load(f)
configurations = database.get('configurations')
adapters = {}
for gadget_config_file in [
install.GetGadgetConfigFile(VIMSPECTOR_HOME),
utils.PathToConfigFile('.gadgets.json')
]:
if gadget_config_file and os.path.exists(gadget_config_file):
with open(gadget_config_file, 'r') as f:
adapters.update(json.load(f).get('adapters') or {})
adapters.update(database.get('adapters') or {})
if len(configurations) == 1:
configuration_name = next(iter(configurations.keys()))
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted(list(configurations.keys())))
if not configuration_name or configuration_name not in configurations:
return
self._workspace_root = os.path.dirname(launch_config_file)
configuration = configurations[configuration_name]
adapter = configuration.get('adapter')
if isinstance(adapter, str):
adapter = adapters.get(adapter)
# TODO: Do we want some form of persistence ? e.g. self._staticVariables,
# set from an api call like SetLaunchParam( 'var', 'value' ), perhaps also a
# way to load .vimspector.local.json which just sets variables
self._variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'gadgetDir': install.GetGadgetDir(VIMSPECTOR_HOME, install.GetOS())
}
self._variables.update(
utils.ParseVariables(adapter.get('variables', {})))
self._variables.update(
utils.ParseVariables(configuration.get('variables', {})))
self._variables.update(launch_variables)
utils.ExpandReferencesInDict(configuration, self._variables)
utils.ExpandReferencesInDict(adapter, self._variables)
if not adapter:
utils.UserMessage(
'No adapter configured for {}'.format(configuration_name),
persist=True)
return
self._StartWithConfiguration(configuration, adapter)
