def test_ParseVariables(self):
tests = [
{
'in': ([{
'a': 'A'
}, {
'b': '${a}'
}], {}, {}, {}),
'out': {
'a': 'A',
'b': 'A'
}
},
]
for test in tests:
with patch('vimspector.utils.AskForInput',
side_effect=RuntimeError):
self.assertDictEqual(utils.ParseVariables(*test['in']),
test['out'])
def test_ParseVariables( self ):
tests = [
{
'AskForInput': RuntimeError,
'in': ( [ { 'a': 'A' }, { 'b': '${a}' } ], {}, {}, {} ),
'out': { 'a': 'A', 'b': 'A' }
},
# List of vars, interdependent
{
'AskForInput': [ 'first', 'third' ],
'in': ( [
{
'first': '${first:first}',
},
{
'second': 'second, ${first}',
'third': '${first:last} and ${third:third}',
},
{
'fourth': '${first}, ${second} and ${third}'
}
], {}, {}, {} ),
'out': {
'first': 'first',
'second': 'second, first',
'third': 'first and third',
'fourth': 'first, second, first and first and third'
}
},
]
for test in tests:
with patch( 'vimspector.utils.AskForInput',
side_effect = test[ 'AskForInput' ] ):
self.assertDictEqual( utils.ParseVariables( *test[ 'in' ] ),
test[ 'out' ] )
def Start(self, launch_variables=None):
# We mutate launch_variables, so don't mutate the default argument.
# https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments
if launch_variables is None:
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)
filetypes = utils.GetBufferFiletypes(vim.current.buffer)
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 not gadget_config_file or not os.path.exists(
gadget_config_file):
continue
with open(gadget_config_file, 'r') as f:
adapters.update(json.load(f).get('adapters') or {})
for launch_config_file in PathsToAllConfigFiles(
VIMSPECTOR_HOME, current_file, filetypes):
self._logger.debug(
f'Reading configurations from: {launch_config_file}')
if not launch_config_file or not os.path.exists(
launch_config_file):
continue
with open(launch_config_file, 'r') as f:
database = json.load(f)
adapters.update(database.get('adapters') or {})
configurations.update(database.get('configurations' or {}))
if not configurations:
utils.UserMessage('Unable to find any debug configurations. '
'You need to tell vimspector how to launch your '
'application.')
return
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(configurations.keys()))
if not configuration_name or configuration_name not in configurations:
return
if launch_config_file:
self._workspace_root = os.path.dirname(launch_config_file)
else:
self._workspace_root = os.path.dirname(current_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=None):
# We mutate launch_variables, so don't mutate the default argument.
# https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments
if launch_variables is None:
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)
filetypes = utils.GetBufferFiletypes(vim.current.buffer)
configurations = {}
adapters = {}
glob.glob(install.GetGadgetDir(VIMSPECTOR_HOME))
for gadget_config_file in PathsToAllGadgetConfigs(
VIMSPECTOR_HOME, current_file):
self._logger.debug(f'Reading gadget config: {gadget_config_file}')
if not gadget_config_file or not os.path.exists(
gadget_config_file):
continue
with open(gadget_config_file, 'r') as f:
a = json.loads(minify(f.read())).get('adapters') or {}
adapters.update(a)
for launch_config_file in PathsToAllConfigFiles(
VIMSPECTOR_HOME, current_file, filetypes):
self._logger.debug(
f'Reading configurations from: {launch_config_file}')
if not launch_config_file or not os.path.exists(
launch_config_file):
continue
with open(launch_config_file, 'r') as f:
database = json.loads(minify(f.read()))
adapters.update(database.get('adapters') or {})
configurations.update(database.get('configurations' or {}))
if not configurations:
utils.UserMessage('Unable to find any debug configurations. '
'You need to tell vimspector how to launch your '
'application.')
return
if 'configuration' in launch_variables:
configuration_name = launch_variables.pop('configuration')
elif (len(configurations) == 1
and next(iter(configurations.values())).get("autoselect", True)):
configuration_name = next(iter(configurations.keys()))
else:
# Find a single configuration with 'default' True and autoselect not False
defaults = {
n: c
for n, c in configurations.items()
if c.get('default', False) is True
and c.get('autoselect', True) is not False
}
if len(defaults) == 1:
configuration_name = next(iter(defaults.keys()))
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted(configurations.keys()))
if not configuration_name or configuration_name not in configurations:
return
if launch_config_file:
self._workspace_root = os.path.dirname(launch_config_file)
else:
self._workspace_root = os.path.dirname(current_file)
configuration = configurations[configuration_name]
adapter = configuration.get('adapter')
if isinstance(adapter, str):
adapter_dict = adapters.get(adapter)
if adapter_dict is None:
suggested_gadgets = installer.FindGadgetForAdapter(adapter)
if suggested_gadgets:
response = utils.AskForInput(
f"The specified adapter '{adapter}' is not "
"installed. Would you like to install the following gadgets? ",
' '.join(suggested_gadgets))
if response:
new_launch_variables = dict(launch_variables)
new_launch_variables[
'configuration'] = configuration_name
installer.RunInstaller(
self._api_prefix,
False, # Don't leave open
*shlex.split(response),
then=lambda: self.Start(new_launch_variables))
return
elif response is None:
return
utils.UserMessage(
f"The specified adapter '{adapter}' is not "
"available. Did you forget to run "
"'install_gadget.py'?",
persist=True,
error=True)
return
adapter = adapter_dict
# 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)
variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'workspaceFolder': self._workspace_root,
'gadgetDir': install.GetGadgetDir(VIMSPECTOR_HOME),
'file': current_file,
}
calculus = {
'relativeFile':
lambda: relpath(current_file, self._workspace_root),
'fileBasename':
lambda: os.path.basename(current_file),
'fileBasenameNoExtension':
lambda: splitext(os.path.basename(current_file))[0],
'fileDirname':
lambda: os.path.dirname(current_file),
'fileExtname':
lambda: 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,
'unusedLocalPort':
utils.GetUnusedLocalPort,
}
# 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)
variables.update(launch_variables)
try:
variables.update(
utils.ParseVariables(adapter.get('variables', {}), variables,
calculus, USER_CHOICES))
variables.update(
utils.ParseVariables(configuration.get('variables', {}),
variables, calculus, USER_CHOICES))
utils.ExpandReferencesInDict(configuration, variables, calculus,
USER_CHOICES)
utils.ExpandReferencesInDict(adapter, variables, calculus,
USER_CHOICES)
except KeyboardInterrupt:
self._Reset()
return
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)
def Start( self, launch_variables = {} ):
self._logger.info( "User requested start debug session with %s",
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
#
# 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
current_file = utils.GetBufferFilepath( vim.current.buffer )
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': os.path.relpath( current_file, self._workspace_root ),
'fileBasename': os.path.basename( current_file ),
'fileBasenameNoExtension':
os.path.splitext( os.path.basename( current_file ) )[ 0 ],
'fileDirname': os.path.dirname( current_file ),
'fileExtname':
os.path.splitext( os.path.basename( current_file ) )[ 1 ],
'cwd': os.getcwd(),
}
self._variables.update(
utils.ParseVariables( adapter.get( 'variables', {} ),
self._variables ) )
self._variables.update(
utils.ParseVariables( configuration.get( 'variables', {} ),
self._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 )
