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.
 
from __future__ import absolute_import
 
import os
import re
from fnmatch import fnmatchcase
from random import randint
from string import ascii_lowercase, ascii_uppercase, digits
 
 
from robotide.lib.robot.api import logger
from robotide.lib.robot.utils import (is_bytes, is_string, is_truthy, is_unicode, lower,
                         unic, Utf8Reader, PY3)
from robotide.lib.robot.version import get_version
 
 
 
class String():
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
    ROBOT_LIBRARY_VERSION = get_version()
 
    
    def convert_to_lowercase(self, string):
        # Custom `lower` needed due to IronPython bug. See its code and
        # comments for more details.
        return lower(string)
 
    
    def convert_to_uppercase(self, string):
        return string.upper()
 
    
    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 PY3 and is_unicode(bytes):
            raise TypeError('Can not decode strings on Python 3.')
        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 Utf8Reader(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):
        if not is_truthy(partial_match):
            pattern = '^%s$' % pattern
        return self._get_matching_lines_get_matching_lines(string, re.compile(pattern).search)
 
    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):
        regexp = re.compile(pattern)
        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):
        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))
 
    
    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):
        for pattern in patterns:
            string = self.replace_string_using_regexpreplace_string_using_regexp(string, pattern, '')
        return string
 
    
    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)
 
    
    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
        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]
 
    
    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 not a string.", 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_unicode(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_lowercase(self, string, msg=None):
        if not string.islower():
            self._fail_fail(msg, "'%s' is not lowercase.", string)
 
    
    def should_be_uppercase(self, string, msg=None):
        if not string.isupper():
            self._fail_fail(msg, "'%s' is not uppercase.", string)
 
    
    def should_be_titlecase(self, string, msg=None):
        if not string.istitle():
            self._fail_fail(msg, "'%s' is not titlecase.", 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(unic(item) for item in items)
        raise AssertionError(message)