--- /dev/null
+#!/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())
Code Review / csit.git / blobdiff