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 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), '$']) name = self._compile_regexp(name_regexp) if args else None return name, args
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)
def test_can_be_iterated_many_times(self): iterator = VariableIterator('one ${var} here', identifiers='$') assert_equals(list(iterator), [('one ', '${var}', ' here')]) assert_equals(list(iterator), [('one ', '${var}', ' here')]) assert_equals(len(iterator), 1) assert_equals(len(iterator), 1)
def test_multiple_variables(self): iterator = VariableIterator('${1} @{2} and %{3}', identifiers='$@%') assert_equals(list(iterator), [('', '${1}', ' @{2} and %{3}'), (' ', '@{2}', ' and %{3}'), (' and ', '%{3}', '')]) assert_equals(len(iterator), 3)