def test_multiple_variables(self):
iterator = VariableIterator('${1} @{2} and %{3}', identifiers='$@%')
assert_equal(list(iterator), [('', '${1}', ' @{2} and %{3}'),
(' ', '@{2}', ' and %{3}'),
(' and ', '%{3}', '')])
assert_equal(bool(iterator), True)
assert_equal(len(iterator), 3)
def tokenize_variables(self):
if self.type not in Token.ALLOW_VARIABLES:
return self._tokenize_no_variables()
variables = VariableIterator(self.value)
if not variables:
return self._tokenize_no_variables()
return self._tokenize_variables(variables)
def test_can_be_iterated_many_times(self):
iterator = VariableIterator('one ${var} here', identifiers='$')
assert_equal(list(iterator), [('one ', '${var}', ' here')])
assert_equal(list(iterator), [('one ', '${var}', ' here')])
assert_equal(bool(iterator), True)
assert_equal(bool(iterator), True)
assert_equal(len(iterator), 1)
assert_equal(len(iterator), 1)
def parse(self, string):
args = []
name_regexp = ['^']
for before, variable, string in VariableIterator(string, identifiers='$'):
name, pattern = self._get_name_and_pattern(variable[2:-1])
args.append(name)
name_regexp.extend([re.escape(before), '(%s)' % pattern])
name_regexp.extend([re.escape(string), '$'])
return self._compile_regexp(name_regexp), args
def _format_template(self, template, args):
iterator = VariableIterator(template, identifiers='$')
variables = len(iterator)
if not variables or variables != len(args):
return template, tuple(args)
temp = []
for before, variable, after in iterator:
temp.extend([before, args.pop(0)])
temp.append(after)
return ''.join(temp), ()
def _format_template(self, template, arguments):
variables = VariableIterator(template, identifiers='$')
count = len(variables)
if count == 0 or count != len(arguments):
return template, arguments
temp = []
for (before, _, after), arg in zip(variables, arguments):
temp.extend([before, arg])
temp.append(after)
return ''.join(temp), ()
def _read_embedded_args_and_regexp(self, string):
args = []
full_pattern = ['^']
for before, variable, string in VariableIterator(string,
identifiers='$'):
variable, pattern = self._get_regexp_pattern(variable[2:-1])
args.append('${%s}' % variable)
full_pattern.extend([re.escape(before), '(%s)' % pattern])
full_pattern.extend([re.escape(string), '$'])
return args, self._compile_regexp(full_pattern)
def _escape_variables(self, default):
if contains_variable(default, '$&@%'):
escaped_var = ''
for before, variable, remaining in VariableIterator(
default, ignore_errors=True):
if contains_variable(remaining, '$&@%'):
remaining = ''
escaped_var = '%s%s\\%s%s' % (escaped_var, before, variable,
remaining)
default = escaped_var
return default
def split_from_equals(string):
from robot.variables import VariableIterator
if not is_string(string) or '=' not in string:
return string, None
variables = VariableIterator(string, ignore_errors=True)
if not variables and '\\' not in string:
return tuple(string.split('=', 1))
try:
index = _find_split_index(string, variables)
except ValueError:
return string, None
return string[:index], string[index+1:]
def tokenize_variables(self):
"""Tokenizes possible variables in token value.
Yields the token itself if the token does not allow variables (see
:attr:`Token.ALLOW_VARIABLES`) or its value does not contain
variables. Otherwise yields variable tokens as well as tokens
before, after, or between variables so that they have the same
type as the original token.
"""
if self.type not in Token.ALLOW_VARIABLES:
return self._tokenize_no_variables()
variables = VariableIterator(self.value)
if not variables:
return self._tokenize_no_variables()
return self._tokenize_variables(variables)
def test_one_variable(self):
iterator = VariableIterator('one ${var} here', identifiers='$')
assert_equal(list(iterator), [('one ', '${var}', ' here')])
assert_equal(bool(iterator), True)
assert_equal(len(iterator), 1)
def test_no_variables(self):
iterator = VariableIterator('no vars here', identifiers='$')
assert_equal(list(iterator), [])
assert_equal(bool(iterator), False)
assert_equal(len(iterator), 0)
