def test_is_dict_variable(self): for no in [ '', 'xxx', '&{var} not alone', r'\@{notvar}', r'\\&{var}', '&{var}xx}', '&{x}&{y}', '${scalar}', '@{list}', '&{x}[k]' ]: assert_false(search_variable(no).is_dict_variable) assert_true(search_variable('&{dict}').is_dict_variable)
def test_is_dict_variable(self): for ok in DICTS: assert is_dict_variable(ok) assert search_variable(ok).is_dict_variable() assert is_dict_variable(ok + '[item]') assert not is_dict_variable(' ' + ok) assert not is_dict_variable(ok + '=') for nok in NOKS + SCALARS + LISTS: assert not is_dict_variable(nok) assert not search_variable(nok, ignore_errors=True).is_dict_variable()
def _escape_variables(self, value): result = '' match = search_variable(value) while match: result += r'%s\%s{%s}' % (match.before, match.identifier, self._escape_variables(match.base)) for item in match.items: result += '[%s]' % self._escape_variables(item) match = search_variable(match.after) return result + match.string
def test_is_scalar_assign(self): for ok in SCALARS: assert is_scalar_assign(ok) assert search_variable(ok).is_scalar_assign() assert is_scalar_assign(ok + '=', allow_assign_mark=True) assert is_scalar_assign(ok + ' =', allow_assign_mark=True) assert not is_scalar_assign(ok + '[item]') assert not is_scalar_assign(' ' + ok) for nok in NOK_ASSIGNS + LISTS + DICTS: assert not is_scalar_assign(nok) assert not search_variable(nok, ignore_errors=True).is_scalar_assign()
def test_is_variable(self): for ok in SCALARS + LISTS + DICTS: assert is_variable(ok) assert is_variable(ok + '[item]') assert search_variable(ok).is_variable() assert not is_variable(' ' + ok) assert not is_variable(ok + '=') for nok in NOKS: assert not is_variable(nok) assert not search_variable(nok, identifiers='$@&', ignore_errors=True).is_variable()
def test_is_variable(self): for no in [ '', 'xxx', '${var} not alone', r'\${notvar}', r'\\${var}', '${var}xx}', '${x}${y}' ]: assert_false(search_variable(no).is_variable, no) for yes in [ '${var}', r'${var$\{}', '${var${internal}}', '@{var}', '@{var}[0]' ]: assert_true(search_variable(yes).is_variable, yes)
def validate(self): name = self.get_value(Token.VARIABLE) match = search_variable(name, ignore_errors=True) if not match.is_assign(allow_assign_mark=True): self.errors += ("Invalid variable name '%s'." % name, ) if match.is_dict_assign(allow_assign_mark=True): self._validate_dict_items()
def lex(self): name = self.statement[0] values = self.statement[1:] match = search_variable(name.value, ignore_errors=True) if match.is_assign(allow_assign_mark=True): self._valid_variable(name, values) else: self._invalid_variable(name, values) if match.is_dict_assign(allow_assign_mark=True): self._validate_dict_items(values)
def _test(self, inp, variable=None, start=0, items=None, internal=False, identifiers=_identifiers, ignore_errors=False): if isinstance(items, str): items = (items, ) elif items is None: items = () else: items = tuple(items) if variable is None or ignore_errors: identifier = base = None start = end = -1 is_var = is_list_var = is_dict_var = False else: identifier = variable[0] base = variable[2:-1] end = start + len(variable) is_var = inp == variable is_list_var = is_var and inp[0] == '@' is_dict_var = is_var and inp[0] == '&' if items: items_str = ''.join('[%s]' % i for i in items) end += len(items_str) is_var = inp == '%s%s' % (variable, items_str) match = search_variable(inp, identifiers, ignore_errors) assert_equal(match.base, base, '%r base' % inp) assert_equal(match.start, start, '%r start' % inp) assert_equal(match.end, end, '%r end' % inp) assert_equal(match.before, inp[:start] if start != -1 else inp) assert_equal(match.match, inp[start:end] if end != -1 else None) assert_equal(match.after, inp[end:] if end != -1 else None) assert_equal(match.identifier, identifier, '%r identifier' % inp) assert_equal(match.items, items, '%r item' % inp) assert_equal(match.internal_variables, internal, '%r internal' % inp) assert_equal(match.is_variable, is_var) assert_equal(match.is_list_variable, is_list_var) assert_equal(match.is_dict_variable, is_dict_var)
def _is_valid_dict_item(self, item): name, value = split_from_equals(item) return value is not None or search_variable(item).is_dict_variable
def _is_dict_var(self, arg): return (is_string(arg) and arg[:2] == '&{' and arg[-1] == '}' and search_variable(arg).is_dict_variable)