splitter.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
from robotide.lib.robot.utils import is_string, py2to3
 
 
class VariableSplitter():
 
    def __init__(self, string, identifiers='$@%&*'):
        self.identifieridentifier = None
        self.basebase = None
        self.itemsitems = []
        self.startstart = -1
        self.endend = -1
        self._identifiers_identifiers = identifiers
        self._may_have_internal_variables_may_have_internal_variables = False
        if not is_string(string):
            self._max_end_max_end = -1
            return
        self._max_end_max_end = len(string)
        if self._split_split(string):
            self._finalize_finalize()
 
    def get_replaced_variable(self, replacer):
        if self._may_have_internal_variables_may_have_internal_variables:
            base = replacer.replace_string(self.basebase)
        else:
            base = self.basebase
        # This omits possible variable items.
        return '%s{%s}' % (self.identifieridentifier, base)
 
    def is_variable(self):
        return bool(self.identifieridentifier and self.basebase and
                    self.startstart == 0 and self.endend == self._max_end_max_end)
 
    def is_list_variable(self):
        return bool(self.identifieridentifier == '@' and self.basebase and
                    self.startstart == 0 and self.endend == self._max_end_max_end and
                    not self.itemsitems)
 
    def is_dict_variable(self):
        return bool(self.identifieridentifier == '&' and self.basebase and
                    self.startstart == 0 and self.endend == self._max_end_max_end and
                    not self.itemsitems)
 
    def _finalize(self):
        self.identifieridentifier = self._variable_chars_variable_chars[0]
        self.basebase = ''.join(self._variable_chars_variable_chars[2:-1])
        self.endend = self.startstart + len(self._variable_chars_variable_chars)
        if self.itemsitems:
            self.endend += len(''.join(self.itemsitems)) + 2 * len(self.itemsitems)
 
    def _split(self, string):
        start_index, max_index = self._find_variable_find_variable(string)
        if start_index == -1:
            return False
        self.startstart = start_index
        self._open_curly_open_curly = 1
        self._state_state = self._variable_state_variable_state
        self._variable_chars_variable_chars = [string[start_index], '{']
        self._item_chars_item_chars = []
        self._string_string = string
        start_index += 2
        for index, char in enumerate(string[start_index:], start=start_index):
            try:
                self._state_state(char, index)
            except StopIteration:
                break
            if index == max_index and not self._scanning_item_scanning_item():
                break
        return True
 
    def _scanning_item(self):
        return self._state_state in (self._waiting_item_state_waiting_item_state, self._item_state_item_state)
 
    def _find_variable(self, string):
        max_end_index = string.rfind('}')
        if max_end_index == -1:
            return -1, -1
        if self._is_escaped_is_escaped(string, max_end_index):
            return self._find_variable_find_variable(string[:max_end_index])
        start_index = self._find_start_index_find_start_index(string, 1, max_end_index)
        if start_index == -1:
            return -1, -1
        return start_index, max_end_index
 
    def _find_start_index(self, string, start, end):
        while True:
            index = string.find('{', start, end) - 1
            if index < 0:
                return -1
            if self._start_index_is_ok_start_index_is_ok(string, index):
                return index
            start = index + 2
 
    def _start_index_is_ok(self, string, index):
        return (string[index] in self._identifiers_identifiers
                and not self._is_escaped_is_escaped(string, index))
 
    def _is_escaped(self, string, index):
        escaped = False
        while index > 0 and string[index-1] == '\\':
            index -= 1
            escaped = not escaped
        return escaped
 
    def _variable_state(self, char, index):
        self._variable_chars_variable_chars.append(char)
        if char == '}' and not self._is_escaped_is_escaped(self._string_string, index):
            self._open_curly_open_curly -= 1
            if self._open_curly_open_curly == 0:
                if not self._can_have_item_can_have_item():
                    raise StopIteration
                self._state_state = self._waiting_item_state_waiting_item_state
        elif char in self._identifiers_identifiers:
            self._state_state = self._internal_variable_start_state_internal_variable_start_state
 
    def _can_have_item(self):
        return self._variable_chars_variable_chars[0] in '$@&'
 
    def _internal_variable_start_state(self, char, index):
        self._state_state = self._variable_state_variable_state
        if char == '{':
            self._variable_chars_variable_chars.append(char)
            self._open_curly_open_curly += 1
            self._may_have_internal_variables_may_have_internal_variables = True
        else:
            self._variable_state_variable_state(char, index)
 
    def _waiting_item_state(self, char, index):
        if char != '[':
            raise StopIteration
        self._state_state = self._item_state_item_state
 
    def _item_state(self, char, index):
        if char != ']':
            self._item_chars_item_chars.append(char)
            return
        self.itemsitems.append(''.join(self._item_chars_item_chars))
        self._item_chars_item_chars = []
        # Don't support nested item access with olf @ and & syntax.
        # In RF 3.2 old syntax is to be deprecated and in RF 3.3 it
        # will be reassigned to mean using variable in list/dict context.
        if self._variable_chars_variable_chars[0] in '@&':
            raise StopIteration
        self._state_state = self._waiting_item_state_waiting_item_state
 
 
@py2to3
class VariableIterator():
 
    def __init__(self, string, identifiers='$@%&*'):
        self._string_string = string
        self._identifiers_identifiers = identifiers
 
    def __iter__(self):
        string = self._string_string
        while True:
            var = VariableSplitter(string, self._identifiers_identifiers)
            if var.identifier is None:
                break
            before = string[:var.start]
            variable = '%s{%s}' % (var.identifier, var.base)
            string = string[var.end:]
            yield before, variable, string
 
    def __len__(self):
        return sum(1 for _ in self)
 
    def __nonzero__(self):
        try:
            next(iter(self))
        except StopIteration:
            return False
        else:
            return True