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)))