String.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.
 
import os
import re
from fnmatch import fnmatchcase
from random import randint
from string import ascii_lowercase, ascii_uppercase, digits
 
from robot.api import logger
from robot.api.deco import keyword
from robot.utils import (FileReader, is_bytes, is_string, is_truthy,
                         parse_re_flags, safe_str, type_name)
from robot.version import get_version
 
 
 
class String:
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
    ROBOT_LIBRARY_VERSION = get_version()
 
    
    def convert_to_lower_case(self, string):
        return string.lower()
 
    
    def convert_to_upper_case(self, string):
        return string.upper()
 
    @keyword(types=None)
    
    def convert_to_title_case(self, string, exclude=None):
        if not is_string(string):
            raise TypeError('This keyword works only with Unicode strings.')
        if is_string(exclude):
            exclude = [e.strip() for e in exclude.split(',')]
        elif not exclude:
            exclude = []
        exclude = [re.compile('^%s$' % e) for e in exclude]
 
        def title(word):
            if any(e.match(word) for e in exclude) or not word.islower():
                return word
            for index, char in enumerate(word):
                if char.isalpha():
                    return word[:index] + word[index].title() + word[index+1:]
            return word
 
        tokens = re.split(r'(\s+)', string, flags=re.UNICODE)
        return ''.join(title(token) for token in tokens)
 
    
    def encode_string_to_bytes(self, string, encoding, errors='strict'):
        return bytes(string.encode(encoding, errors))
 
    
    def decode_bytes_to_string(self, bytes, encoding, errors='strict'):
        if is_string(bytes):
            raise TypeError('Cannot decode strings.')
        return bytes.decode(encoding, errors)
 
    
    def format_string(self, template, *positional, **named):
        if os.path.isabs(template) and os.path.isfile(template):
            template = template.replace('/', os.sep)
            logger.info('Reading template from file <a href="%s">%s</a>.'
                        % (template, template), html=True)
            with FileReader(template) as reader:
                template = reader.read()
        return template.format(*positional, **named)
 
    
    def get_line_count(self, string):
        count = len(string.splitlines())
        logger.info('%d lines' % count)
        return count
 
    
    def split_to_lines(self, string, start=0, end=None):
        start = self._convert_to_index_convert_to_index(start, 'start')
        end = self._convert_to_index_convert_to_index(end, 'end')
        lines = string.splitlines()[start:end]
        logger.info('%d lines returned' % len(lines))
        return lines
 
    
    def get_line(self, string, line_number):
        line_number = self._convert_to_integer_convert_to_integer(line_number, 'line_number')
        return string.splitlines()[line_number]
 
    
    def get_lines_containing_string(self, string, pattern, case_insensitive=False):
        if is_truthy(case_insensitive):
            pattern = pattern.lower()
            contains = lambda line: pattern in line.lower()
        else:
            contains = lambda line: pattern in line
        return self._get_matching_lines_get_matching_lines(string, contains)
 
    
    def get_lines_matching_pattern(self, string, pattern, case_insensitive=False):
        if is_truthy(case_insensitive):
            pattern = pattern.lower()
            matches = lambda line: fnmatchcase(line.lower(), pattern)
        else:
            matches = lambda line: fnmatchcase(line, pattern)
        return self._get_matching_lines_get_matching_lines(string, matches)
 
    
    def get_lines_matching_regexp(self, string, pattern, partial_match=False, flags=None):
        if is_truthy(partial_match):
            match = re.compile(pattern, flags=parse_re_flags(flags)).search
        else:
            match = re.compile(pattern + '$', flags=parse_re_flags(flags)).match
        return self._get_matching_lines_get_matching_lines(string, match)
 
    def _get_matching_lines(self, string, matches):
        lines = string.splitlines()
        matching = [line for line in lines if matches(line)]
        logger.info('%d out of %d lines matched' % (len(matching), len(lines)))
        return '\n'.join(matching)
 
    
    def get_regexp_matches(self, string, pattern, *groups, flags=None):
        regexp = re.compile(pattern, flags=parse_re_flags(flags))
        groups = [self._parse_group_parse_group(g) for g in groups]
        return [m.group(*groups) for m in regexp.finditer(string)]
 
    def _parse_group(self, group):
        try:
            return int(group)
        except ValueError:
            return group
 
    
    def replace_string(self, string, search_for, replace_with, count=-1):
        count = self._convert_to_integer_convert_to_integer(count, 'count')
        return string.replace(search_for, replace_with, count)
 
    
    def replace_string_using_regexp(self, string, pattern, replace_with, count=-1, flags=None):
        count = self._convert_to_integer_convert_to_integer(count, 'count')
        # re.sub handles 0 and negative counts differently than string.replace
        if count == 0:
            return string
        return re.sub(pattern, replace_with, string, max(count, 0), flags=parse_re_flags(flags))
 
    
    def remove_string(self, string, *removables):
        for removable in removables:
            string = self.replace_stringreplace_string(string, removable, '')
        return string
 
    
    def remove_string_using_regexp(self, string, *patterns, flags=None):
        for pattern in patterns:
            string = self.replace_string_using_regexpreplace_string_using_regexp(string, pattern, '', flags=flags)
        return string
 
    @keyword(types=None)
    
    def split_string(self, string, separator=None, max_split=-1):
        if separator == '':
            separator = None
        max_split = self._convert_to_integer_convert_to_integer(max_split, 'max_split')
        return string.split(separator, max_split)
 
    @keyword(types=None)
    
    def split_string_from_right(self, string, separator=None, max_split=-1):
        if separator == '':
            separator = None
        max_split = self._convert_to_integer_convert_to_integer(max_split, 'max_split')
        return string.rsplit(separator, max_split)
 
    
    def split_string_to_characters(self, string):
        return list(string)
 
    
    def fetch_from_left(self, string, marker):
        return string.split(marker)[0]
 
    
    def fetch_from_right(self, string, marker):
        return string.split(marker)[-1]
 
    
    def generate_random_string(self, length=8, chars='[LETTERS][NUMBERS]'):
        if length == '':
            length = 8
        if isinstance(length, str) and re.match(r'^\d+-\d+$', length):
            min_length, max_length = length.split('-')
            length = randint(self._convert_to_integer_convert_to_integer(min_length, "length"),
                             self._convert_to_integer_convert_to_integer(max_length, "length"))
        else:
            length = self._convert_to_integer_convert_to_integer(length, 'length')
        for name, value in [('[LOWER]', ascii_lowercase),
                            ('[UPPER]', ascii_uppercase),
                            ('[LETTERS]', ascii_lowercase + ascii_uppercase),
                            ('[NUMBERS]', digits)]:
            chars = chars.replace(name, value)
        maxi = len(chars) - 1
        return ''.join(chars[randint(0, maxi)] for _ in range(length))
 
    
    def get_substring(self, string, start, end=None):
        start = self._convert_to_index_convert_to_index(start, 'start')
        end = self._convert_to_index_convert_to_index(end, 'end')
        return string[start:end]
 
    @keyword(types=None)
    
    def strip_string(self, string, mode='both', characters=None):
        try:
            method = {'BOTH': string.strip,
                      'LEFT': string.lstrip,
                      'RIGHT': string.rstrip,
                      'NONE': lambda characters: string}[mode.upper()]
        except KeyError:
            raise ValueError("Invalid mode '%s'." % mode)
        return method(characters)
 
    
    def should_be_string(self, item, msg=None):
        if not is_string(item):
            self._fail_fail(msg, "'%s' is %s, not a string.", item, type_name(item))
 
    
    def should_not_be_string(self, item, msg=None):
        if is_string(item):
            self._fail_fail(msg, "'%s' is a string.", item)
 
    
    def should_be_unicode_string(self, item, msg=None):
        if not is_string(item):
            self._fail_fail(msg, "'%s' is not a Unicode string.", item)
 
    
    def should_be_byte_string(self, item, msg=None):
        if not is_bytes(item):
            self._fail_fail(msg, "'%s' is not a byte string.", item)
 
    
    def should_be_lower_case(self, string, msg=None):
        if not string.islower():
            self._fail_fail(msg, "'%s' is not lower case.", string)
 
    
    def should_be_upper_case(self, string, msg=None):
        if not string.isupper():
            self._fail_fail(msg, "'%s' is not upper case.", string)
 
    @keyword(types=None)
    
    def should_be_title_case(self, string, msg=None, exclude=None):
        if string != self.convert_to_title_caseconvert_to_title_case(string, exclude):
            self._fail_fail(msg, "'%s' is not title case.", string)
 
    def _convert_to_index(self, value, name):
        if value == '':
            return 0
        if value is None:
            return None
        return self._convert_to_integer_convert_to_integer(value, name)
 
    def _convert_to_integer(self, value, name):
        try:
            return int(value)
        except ValueError:
            raise ValueError("Cannot convert '%s' argument '%s' to an integer."
                             % (name, value))
 
    def _fail(self, message, default_template, *items):
        if not message:
            message = default_template % tuple(safe_str(item) for item in items)
        raise AssertionError(message)