path: root/tools/refactoring/stringmanipulation.py

import string

# returns tuple, [success,updated_string] where the updated string has
# has one less (the first) occurance of match string
def removefirstoccurance( remove_string, match_string ):
    lowercase_string = remove_string.lower()
    lowercase_match_string = match_string.lower()
    lowest_index = lowercase_string.find(lowercase_match_string)
    if(lowest_index == -1):
        return [False,remove_string]
    past_match_index = lowest_index + len(lowercase_match_string)
    highest_index = len(remove_string)
    remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index]
    return [True,remove_string]

# returns a string with all occurances of match_string removed
def removealloccurances( remove_string, match_string ):
    return_value = [True, remove_string]
    while(return_value[0]):
        return_value = removefirstoccurance(return_value[1],match_string)
    return return_value[1]

# removes an occurance of match_string only if it's first in the string
# returns tuple [succes, new_string]
def removeprefix( remove_string, match_string ):
    lowercase_string = remove_string.lower()
    lowercase_match_string = match_string.lower()
    lowest_index = lowercase_string.find(lowercase_match_string)
    if(lowest_index == -1):
        return [False,remove_string]
    if(lowest_index != 0):
        return [False,remove_string]
    past_match_index = lowest_index + len(lowercase_match_string)
    highest_index = len(remove_string)
    remove_string = remove_string[0:lowest_index] + remove_string[past_match_index: highest_index]
#    print lowest_index
#    print past_match_index
    return [True,remove_string]

# removes multiple occurances of match string as long as they are first in
# the string
def removeallprefix( remove_string, match_string ):
    return_value = [True, remove_string]
    while(return_value[0]):
        return_value = removeprefix(return_value[1],match_string)
    return return_value[1]

# returns true if extensionstring is a correct extension
def isextension( extensionstring ):
    if(len(extensionstring) < 2):
        return False
    if(extensionstring[0] != '.'):
        return False
    if(extensionstring[1:len(extensionstring)-1].find('.') != -1):
        return False
    return True

# returns the index of start of the last occurance of match_string
def findlastoccurance( original_string, match_string ):
    search_index = original_string.find(match_string)
    found_index = search_index
    last_index = len(original_string) - 1
    while((search_index != -1) and (search_index < last_index)):
        search_index = original_string[search_index+1:last_index].find(match_string)
        if(search_index != -1):
            found_index = search_index
    return found_index

# changes extension from original_extension to new_extension
def changeextension( original_string, original_extension, new_extension):
    if(not isextension(original_extension)):
        return original_string
    if(not isextension(new_extension)):
        return original_string
    index = findlastoccurance(original_string, original_extension)
    if(index == -1):
        return original_string
    return_value = original_string[0:index] + new_extension
    return return_value

# wanted to do this with str.find however didnt seem to work so do it manually
# returns the index of the first capital letter
def findfirstcapitalletter( original_string ):
    for index in range(len(original_string)):
        if(original_string[index].lower() != original_string[index]):
            return index
    return -1


# replaces capital letters with underscore and lower case letter (except very
# first
def lowercasewithunderscore( original_string ):
# ignore the first letter since there should be no underscore in front of it
    if(len(original_string) < 2):
        return original_string
    return_value = original_string[1:len(original_string)]
    index = findfirstcapitalletter(return_value)
    while(index != -1):
        return_value = return_value[0:index] + \
                       '_' + \
                       return_value[index].lower() + \
                       return_value[index+1:len(return_value)]
        index = findfirstcapitalletter(return_value)
    return_value = original_string[0].lower() + return_value
    return return_value

# my table is a duplicate of strings
def removeduplicates( my_table ):
    new_table = []
    for old_string1, new_string1 in my_table:
        found = 0
        for old_string2, new_string2 in new_table:
            if(old_string1 == old_string2):
                found += 1
            if(new_string1 == new_string2):
                if(new_string1 == ''):
                    found += found
                else:
                    found += 1
            if(found == 1):
                print 'missmatching set, terminating program'
                print old_string1
                print new_string1
                print old_string2
                print new_string2
                quit()
            if(found == 2):
                break
        if(found == 0):
            new_table.append([old_string1,new_string1])
    return new_table

def removenochange( my_table ):
    new_table = []
    for old_string, new_string in my_table:
        if(old_string != new_string):
            new_table.append([old_string,new_string])
    return new_table

# order table after size of the string (can be used to replace bigger strings
# first which is useful since smaller strings can be inside the bigger string)
# E.g. GIPS is a sub string of GIPSVE if we remove GIPS first GIPSVE will never
# be removed. N is small so no need for fancy sort algorithm. Use selection sort
def ordertablesizefirst( my_table ):
    for current_index in range(len(my_table)):
        biggest_string = 0
        biggest_string_index = -1
        for search_index in range(len(my_table)):
            if(search_index < current_index):
                continue
            length_of_string = len(my_table[search_index][0])
            if(length_of_string > biggest_string):
                biggest_string = length_of_string
                biggest_string_index = search_index
        if(biggest_string_index == -1):
            print 'sorting algorithm failed, program exit'
            quit()
        old_value = my_table[current_index]
        my_table[current_index] = my_table[biggest_string_index]
        my_table[biggest_string_index] = old_value
    return my_table

# returns true if string 1 or 2 is a substring of the other, assuming neither
# has whitespaces
def issubstring( string1, string2 ):
    if(len(string1) == 0):
        return -1
    if(len(string2) == 0):
        return -1
    large_string = string1
    small_string = string2
    if(len(string1) < len(string2)):
        large_string = string2
        small_string = string1

    for index in range(len(large_string)):
        large_sub_string = large_string[index:index+len(small_string)].lower()
        if(large_sub_string ==\
           small_string.lower()):
              return index
    return -1

#not_part_of_word_table = [' ','(',')','{','}',':','\t','*','&','/','[',']','.',',','\n']
#def ispartofword( char ):
#    for item in not_part_of_word_table:
#        if(char == item):
#            return False
#    return True

# must be numerical,_ or charachter
def ispartofword( char ):
    if(char.isalpha()):
        return True
    if(char.isalnum()):
        return True
    if(char == '_'):
        return True
    return False

# returns the index of the first letter in the word that the current_index
# is pointing to and the size of the word
def getword( line, current_index):
    if(current_index < 0):
        return []
    line = line.rstrip()
    if(len(line) <= current_index):
        return []
    if(line[current_index] == ' '):
        return []
    start_pos = current_index
    while start_pos >= 0:
        if(not ispartofword(line[start_pos])):
            start_pos += 1
            break
        start_pos -= 1
    if(start_pos == -1):
        start_pos = 0
    end_pos = current_index
    while end_pos < len(line):
        if(not ispartofword(line[end_pos])):
            break
        end_pos += 1
    return [start_pos,end_pos - start_pos]

# my table is a tuple [string1,string2] complement_to_table is just a list
# of strings to compare to string1
def complement( my_table, complement_to_table ):
    new_table = []
    for index in range(len(my_table)):
        found = False;
        for compare_string in complement_to_table:
            if(my_table[index][0].lower() == compare_string.lower()):
                found = True
        if(not found):
            new_table.append(my_table[index])
    return new_table

def removestringfromhead( line, remove_string):
    for index in range(len(line)):
        if(line[index:index+len(remove_string)] != remove_string):
            return line[index:index+len(line)]
    return ''

def removeccomment( line ):
    comment_string = '//'
    for index in range(len(line)):
        if(line[index:index+len(comment_string)] == comment_string):
            return line[0:index]
    return line

def whitespacestoonespace( line ):
    return ' '.join(line.split())

def fixabbreviations( original_string ):
    previouswascapital = (original_string[0].upper() == original_string[0])
    new_string = ''
    for index in range(len(original_string)):
        if(index == 0):
            new_string += original_string[index]
            continue
        if(original_string[index] == '_'):
            new_string += original_string[index]
            previouswascapital = False
            continue
        if(original_string[index].isdigit()):
            new_string += original_string[index]
            previouswascapital = False
            continue
        currentiscapital = (original_string[index].upper() == original_string[index])
        letter_to_add = original_string[index]
        if(previouswascapital and currentiscapital):
            letter_to_add = letter_to_add.lower()
        if(previouswascapital and (not currentiscapital)):
            old_letter = new_string[len(new_string)-1]
            new_string = new_string[0:len(new_string)-1]
            new_string += old_letter.upper()
        previouswascapital = currentiscapital
        new_string += letter_to_add
    return new_string

def replaceoccurances(old_string, replace_string, replace_with_string):
    if (len(replace_string) == 0):
        return old_string
    if (len(old_string) < len(replace_string)):
        return old_string
    # Simple implementation, could proably be done smarter
    new_string = ''
    for index in range(len(old_string)):
        #print new_string
        if(len(replace_string) > (len(old_string) - index)):
            new_string += old_string[index:index + len(old_string)]
            break
        match = (len(replace_string) > 0)
        for replace_index in range(len(replace_string)):
            if (replace_string[replace_index] != old_string[index + replace_index]):
                match = False
                break
        if (match):
            new_string += replace_with_string
            index =+ len(replace_string)
        else:
            new_string += old_string[index]
    return new_string