path: root/resources/tools/rename_robot_keywords.py

#!/usr/bin/python

# Copyright (c) 2017 Cisco and/or its affiliates.
# 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.

"""This script renames the given robot keywords in the given directory
recursively.

Example:

  ./rename_robot_keywords.py -i kws.csv -s ";" -d ~/ws/vpp/git/csit/ -vvv

  Input file "kws.csv" is CSV file exported from e.g. MS Excel. Its structure
  must be:

    <Old keyword name><separator><New keyword name>

  One keyword per line.

"""

import argparse
import sys
import re
from os import walk, rename
from os.path import join


def time_interval(func):
    """Decorator function to measure the time spent by the decorated function.

    :param func: Decorated function.
    :type func: Callable object.
    :returns: Wrapper function.
    :rtype: Callable object.
    """

    import time

    def wrapper(*args, **kwargs):
        start = time.clock()
        result = func(*args, **kwargs)
        stop = time.clock()
        print("\nRenaming done in {:.5g} seconds\n".
              format(stop - start))
        return result
    return wrapper


def get_files(path, extension):
    """Generates the list of files to process.

    :param path: Path to files.
    :param extension: Extension of files to process. If it is the empty string,
    all files will be processed.
    :type path: str
    :type extension: str
    :returns: List of files to process.
    :rtype: list
    """

    file_list = list()
    for root, dirs, files in walk(path):
        for filename in files:
            if extension:
                if filename.endswith(extension):
                    file_list.append(join(root, filename))
            else:
                file_list.append(join(root, filename))

    return file_list


def read_keywords(args):
    """This function reads the keywords from the input file and creates:

    - a dictionary where the key is the old name and the value is the new name,
      these keywords will be further processed.
    - a list of keywords which will not be processed, typically keywords with
    argument(s) in its names.
    - a list of duplicates - duplicated keyword names or names which are parts
    of another keyword name, they will not be processed.

    :param args:  Parsed arguments.
    :type args: ArgumentParser
    :returns: keyword names - dictionary where the key is the old name and the
    value is the new name; ignored keyword names - list of keywords which will
    not be processed; duplicates - duplicated keyword names or names which are
    parts of another keyword name, they will not be processed.
    :rtype: tuple(dict, list, list)
    """

    kw_names = dict()
    ignored_kw_names = list()
    duplicates = list()

    for line in args.input:
        old_name, new_name = line.split(args.separator)
        if '$' in old_name:
            ignored_kw_names.append((old_name, new_name[:-1]))
        elif old_name in kw_names.keys():
            duplicates.append((old_name, new_name[:-1]))
        else:
            kw_names[old_name] = new_name[:-1]

    # Remove duplicates:
    for old_name, _ in duplicates:
        new_name = kw_names.pop(old_name, None)
        if new_name:
            duplicates.append((old_name, new_name))

    # Find KW names which are parts of other KW names:
    for old_name in kw_names.keys():
        count = 0
        for key in kw_names.keys():
            if old_name in key:
                count += 1
            if old_name in kw_names[key]:
                if old_name != key:
                    count += 1
        if count > 1:
            duplicates.append((old_name, kw_names[old_name]))
            kw_names.pop(old_name)

    return kw_names, ignored_kw_names, duplicates


def rename_keywords(file_list, kw_names, args):
    """Rename the keywords in specified files.

    :param file_list: List of files to be processed.
    :param kw_names: Dictionary  where the key is the old name and the value is
    the new name
    :type file_list: list
    :type kw_names: dict
    """

    kw_not_found = list()

    for old_name, new_name in kw_names.items():
        kw_found = False
        if args.verbosity > 0:
            print("\nFrom: {}\n  To: {}\n".format(old_name, new_name))
        for file_name in file_list:
            tmp_file_name = file_name + ".new"
            with open(file_name) as file_read:
                file_write = open(tmp_file_name, 'w')
                occurrences = 0
                for line in file_read:
                    new_line = re.sub(old_name, new_name, line)
                    file_write.write(new_line)
                    if new_line != line:
                        occurrences += 1
                if occurrences:
                    kw_found = True
                    if args.verbosity > 1:
                        print(" {:3d}: {}".format(occurrences, file_name))
                file_write.close()
            rename(tmp_file_name, file_name)
        if not kw_found:
            kw_not_found.append(old_name)

    if args.verbosity > 0:
        print("\nKeywords not found:")
        for item in kw_not_found:
            print("  {}".format(item))


def parse_args():
    """Parse arguments from command line.

    :returns: Parsed arguments.
    :rtype: ArgumentParser
    """

    parser = argparse.ArgumentParser(description=__doc__,
                                     formatter_class=argparse.
                                     RawDescriptionHelpFormatter)
    parser.add_argument("-i", "--input",
                        required=True,
                        type=argparse.FileType('r'),
                        help="Text file with the old keyword name and the new "
                             "keyword name separated by separator per line.")
    parser.add_argument("-s", "--separator",
                        default=";",
                        type=str,
                        help="Separator which separates the old and the new "
                             "keyword name.")
    parser.add_argument("-d", "--dir",
                        required=True,
                        type=str,
                        help="Directory with robot files where the keywords "
                             "should be recursively searched.")
    parser.add_argument("-v", "--verbosity", action="count",
                        help="Set the output verbosity.")
    return parser.parse_args()


@time_interval
def main():
    """Main function."""

    args = parse_args()

    kw_names, ignored_kw_names, duplicates = read_keywords(args)

    file_list = get_files(args.dir, "robot")

    if args.verbosity > 2:
        print("\nList of files to be processed:")
        for item in file_list:
            print("  {}".format(item))
        print("\n{} files to be processed.\n".format(len(file_list)))

        print("\nList of keywords to be renamed:")
        for item in kw_names:
            print("  {}".format(item))
        print("\n{} keywords to be renamed.\n".format(len(kw_names)))

    rename_keywords(file_list, kw_names, args)

    if args.verbosity >= 0:
        print("\nIgnored keywords: ({})".format(len(ignored_kw_names)))
        for old, new in ignored_kw_names:
            print("  From: {}\n    To: {}\n".format(old, new))

        print("\nIgnored duplicates ({}):".format(len(duplicates)))
        for old, new in duplicates:
            print("  From: {}\n    To: {}\n".format(old, new))


if __name__ == "__main__":
    sys.exit(main())