CSIT-687: Directory structure reorganization

Change-Id: I772c9e214be2461adf58124998d272e7d795220f
Signed-off-by: Tibor Frank <tifrank@cisco.com>
Signed-off-by: Maciek Konstantynowicz <mkonstan@cisco.com>

1 files changed, 243 insertions, 0 deletions

diff --git a/resources/tools/scripts/rename_robot_keywords.py b/resources/tools/scripts/rename_robot_keywords.py
new file mode 100755
index 0000000000..9f27b4aaec
--- /dev/null
+++ b/resources/tools/scripts/rename_robot_keywords.py
@@ -0,0 +1,243 @@
+#!/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())