def _get_dict_variable_item(self, name, variable, key):
key = self.replace_scalar(key)
try:
return variable[key]
except KeyError:
raise VariableError("Dictionary '%s' has no key '%s'." %
(name, key))
except TypeError as err:
raise VariableError("Dictionary '%s' used with invalid key: %s" %
(name, err))
def _get_dict_variable_item(self, splitter):
name = splitter.get_replaced_variable(self)
variable = self._variables[name]
key = self.replace_scalar(splitter.index)
try:
return variable[key]
except KeyError:
raise VariableError("Dictionary variable '%s' has no key '%s'."
% (name, key))
except TypeError as err:
raise VariableError("Dictionary variable '%s' used with invalid key: %s"
% (name, err))
def _validate_value(self, value, identifier, name):
if identifier == '@':
if not is_list_like(value):
raise VariableError("Value of variable '%s' is not list or "
"list-like." % name)
return list(value)
if identifier == '&':
if not is_dict_like(value):
raise VariableError("Value of variable '%s' is not dictionary "
"or dictionary-like." % name)
return DotDict(value)
return value
def _get_list_variable_item(self, name, variable, index):
index = self.replace_string(index)
try:
index = self._parse_list_variable_index(index, name[0] == '$')
except ValueError:
raise VariableError("List '%s' used with invalid index '%s'." %
(name, index))
try:
return variable[index]
except IndexError:
raise VariableError("List '%s' has no item in index %d." %
(name, index))
def _get_list_variable_item(self, splitter):
name = splitter.get_replaced_variable(self)
variable = self._variables[name]
index = self.replace_string(splitter.index)
try:
index = int(index)
except ValueError:
raise VariableError("List variable '%s' used with invalid index '%s'."
% (name, index))
try:
return variable[index]
except IndexError:
raise VariableError("List variable '%s' has no item in index %d."
% (name, index))
def find(self, name):
match = self._match_extended(name[2:-1])
if match is None:
raise ValueError
base_name, extended = match.groups()
try:
variable = self._find_variable('${%s}' % base_name)
except DataError as err:
raise VariableError("Resolving variable '%s' failed: %s" %
(name, unicode(err)))
try:
return eval('_BASE_VAR_' + extended, {'_BASE_VAR_': variable})
except:
raise VariableError("Resolving variable '%s' failed: %s" %
(name, get_error_message()))
def _validate_value(self, value, identifier, name):
if identifier == '@':
if not is_list_like(value):
raise VariableError("Value of variable '%s' is not list or "
"list-like." % name)
# TODO: Is converting to list needed or would checking be enough?
# TODO: Check this and DotDict usage below in RF 3.1.
return list(value)
if identifier == '&':
if not is_dict_like(value):
raise VariableError("Value of variable '%s' is not dictionary "
"or dictionary-like." % name)
# TODO: Is converting to DotDict needed? Check in RF 3.1.
return DotDict(value)
return value
def _get_variable_item(self, name, variable, item):
if is_dict_like(variable):
return self._get_dict_variable_item(name, variable, item)
if is_list_like(variable):
return self._get_list_variable_item(name, variable, item)
raise VariableError("Variable '%s' is %s, not list or dictionary, "
"and thus accessing item '%s' from it is not "
"possible." % (name, type_name(variable), item))
def _get_return_value(self, variables, return_):
ret = self._handler.return_value if not return_ else return_.return_value
if not ret:
return None
contains_list_var = any(is_list_var(item) for item in ret)
try:
ret = variables.replace_list(ret)
except DataError as err:
raise VariableError(
'Replacing variables from keyword return value '
'failed: %s' % err.message)
if len(ret) != 1 or contains_list_var:
return ret
return ret[0]
def variable_not_found(name, candidates, msg=None, deco_braces=True):
"""Raise DataError for missing variable name.
Return recommendations for similar variable names if any are found.
"""
if msg is None:
msg = "Variable '%s' not found." % name
candidates = _decorate_candidates(name[0], candidates, deco_braces)
normalizer = partial(normalize,
ignore='$@%&*{}_',
caseless=True,
spaceless=True)
finder = RecommendationFinder(normalizer)
recommendations = finder.find_recommendations(name, candidates)
msg = finder.format_recommendations(msg, recommendations)
raise VariableError(msg)
def find(self, name):
validate_var(name, '$@&%')
identifier = name[0]
for finder in self._finders:
if identifier in finder.identifiers:
try:
value = finder.find(name)
except (KeyError, ValueError):
continue
try:
return self._validate_value(value, identifier, name)
except VariableError:
raise
except:
raise VariableError("Resolving variable '%s' failed: %s" %
(name, get_error_message()))
variable_not_found(name, self._store.data)
def _extended_assign(self, name, value, variables):
if name[0] != '$' or '.' not in name or name in variables:
return False
base, attr = self._split_extended_assign(name)
try:
var = variables[base]
except DataError:
return False
if not (self._variable_supports_extended_assign(var)
and self._is_valid_extended_attribute(attr)):
return False
try:
setattr(var, attr, value)
except:
raise VariableError("Setting attribute '%s' to variable '%s' "
"failed: %s" %
(attr, base, get_error_message()))
return True
def _raise(self, error):
raise VariableError('Cannot set variables: %s' % error)
def _raise_cannot_set_type(self, name, value, expected):
raise VariableError("Cannot set variable '%s': Expected %s-like value, "
"got %s." % (name, expected, type_name(value)))