[FEATURE] Added logging to the script. This fixes #90

Author: Seluj78

42PyChecker.py

@@ -7,6 +7,7 @@
 import platform
 from PyChecker.projects import libft, ft_commandements, other, fillit
 import sys
+import logging
 
 
 def check_args_rules(parser, args):
@@ -34,77 +35,103 @@ def check_args_rules(parser, args):
 
     :param args: the parsed arguments passed to the program
     """
-
+    logging.info("Starting argument checking.")
     # If no project is given the parser sends an error.
     if args.project is None:
+        logging.critical('You need to specify a project.')
         parser.error("You need to specify a project.")
     # If the path of the selected project is empty, the parser prints an error.
     if args.path == "":
+        logging.critical("`--path' needs to be specified in order for 42PyChecker"
+                     " to know where your project is.")
         parser.error("`--path' needs to be specified in order for 42PyChecker"
                      " to know where your project is.")
     if args.path[0] != '/':
+        logging.critical("`--path' needs to have an absolute path")
         parser.error("`--path' needs to have an absolute path")
     # If a test is disabled and the libft project is selected, the parser will
     # return an error.
 
     # Here, if the `--no-tests` option is set, all the testing suites will be
     # disabled, no matter the project.
     if args.project == "other" and args.no_tests:
+        logging.critical("`--no-tests' Can only be applied on projects, not when 'other' is selected.")
         parser.error("`--no-tests' Can only be applied on projects, not when 'other' is selected.")
 
     if args.no_author and args.project == "42commandements":
+        logging.critical("`--no-author' Can only be applied on project, but not on 42commandements.")
         parser.error("`--no-author' Can only be applied on project, but not on 42commandements.")
 
     forbidden_functions_projects = ['fdf', 'fillit', 'ft_ls', 'ft_p', 'ft_printf', 'gnl', 'get_next_line', 'libft', 'libftasm', 'libft_asm', 'minishell', 'pushswap', 'push_swap']
     if args.no_forbidden_functions and args.project not in forbidden_functions_projects:
+        logging.critical("`--no-forbidden-functions' Cannot be set if project isn't one of " + str(forbidden_functions_projects))
         parser.error("`--no-forbidden-functions' Cannot be set if project isn't one of " + str(forbidden_functions_projects))
 
     if args.no_makefile and args.project == "42commandements":
+        logging.critical("`--no-makefile' Can only be applied on project, but not on 42commandements.")
         parser.error("`--no-makefile' Can only be applied on project, but not on 42commandements.")
 
     if args.no_norm and args.project == "42commandements":
+        logging.critical("`--no-norm' Can only be applied on project, but not on 42commandements.")
         parser.error("`--no-norm' Can only be applied on project, but not on 42commandements.")
 
     if args.no_static and args.project != "libft":
+        logging.critical("`--no-static' Can only be applied project `libft'")
         parser.error("`--no-static' Can only be applied project `libft'")
 
     if args.no_extra and args.project != "libft":
+        logging.critical("`--no-extra' Can only be applied project `libft'")
         parser.error("`--no-extra' Can only be applied project `libft'")
 
     if args.no_required and args.project != "libft":
+        logging.critical("`--no-required' Can only be applied project `libft'")
         parser.error("`--no-required' Can only be applied project `libft'")
 
     if args.no_bonus and args.project != "libft":
+        logging.critical("`--no-bonus' Can only be applied project `libft'")
         parser.error("`--no-bonus' Can only be applied project `libft'")
 
     if args.do_benchmark and args.project != "libft":
+        logging.critical("`--do-benchmark' Can only be applied project `libft'")
         parser.error("`--do-benchmark' Can only be applied project `libft'")
 
     if args.no_libftest and args.project != "libft":
+        logging.critical("`--no-libftest' can only be applied if libft is selected "
+                     "with `--project'")
         parser.error("`--no-libftest' can only be applied if libft is selected "
                      "with `--project'")
 
     if args.no_maintest and args.project != "libft":
+        logging.critical("`--no-maintest' can only be applied if libft is selected "
+                     "with `--project'")
         parser.error("`--no-maintest' can only be applied if libft is selected "
                      "with `--project'")
 
     if args.no_moulitest and args.project != "libft":
+        logging.critical("`--no-moulitest' can only be applied if libft is selected"
+                     " with `--project'")
         parser.error("`--no-moulitest' can only be applied if libft is selected"
                      " with `--project'")
 
     if args.no_libft_unit_test and args.project != "libft":
+        logging.critical("`--no-libft-unit-test' can only be applied if libft is selected"
+                     " with `--project'")
         parser.error("`--no-libft-unit-test' can only be applied if libft is selected"
                      " with `--project'")
 
     if args.no_fillit_checker and args.project != "fillit":
+        logging.critical("`--no-fillit-checker' can only be applied if fillit is selected"
+                     " with `--project'")
         parser.error("`--no-fillit-checker' can only be applied if fillit is selected"
                      " with `--project'")
     if args.no_tests:
+        logging.debug("Option `--no-tests` selected. Setting all tests options to 'True' to disable them all")
         args.no_libftest = True
         args.no_maintest = True
         args.no_moulitest = True
         args.no_libft_unit_test = True
         args.no_fillit_checker = True
+    logging.info("Argument checking done.")
 
 
 def print_header():
@@ -130,8 +157,8 @@ def main():
 
     # @todo: Add verbose output
     # Adds all the arguments one by one.
-    parser.add_argument("-v", "--verbose", help="Increases output verbosity",
-                        action="store_true")
+    parser.add_argument("--log", help="Sets up the log output.",
+                        choices=['debug', 'DEBUG', 'info', 'INFO', 'warning', 'WARNING', 'error', 'ERROR', 'critical', 'CRITICAL'])
     parser.add_argument("--no-gui", help="disables the Graphical User Interface",
                         action="store_true")
     parser.add_argument("--project", help="Specifies the type of project you want to check", choices=['libft', '42commandements', 'other', 'fillit'], default=None)
@@ -176,22 +203,33 @@ def main():
         with open(root_path + '/.github/LICENSE.lesser', 'r') as file:
             print(file.read())
         sys.exit()
-
+    # @todo: Check for log file size and delete it if needed.
+    logging.basicConfig(filename='42PyChecker.log', level=args.log.upper(), format='%(asctime)s,%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', datefmt='%d-%m-%Y:%H:%M:%S')
+    logging.info("************************************************************")
+    logging.info("***********Starting new instance of 42PyChecker*************")
+    logging.info("************************************************************")
+    # @todo: Format the args to be printed in log
+    logging.debug("Arguments passed : {}".format(args))
     check_args_rules(parser, args)
 
     # Here we create the directory where the testing suites will be cloned
     if not os.path.exists(root_path + '/testing_suites'):
+        logging.debug("The directory `{}/testing_suites` doesn't exist. Creating it".format(root_path))
         os.makedirs(root_path + '/testing_suites')
 
     # Here we select the project and start the check based on the argument `--project`
     if args.project == "libft":
+        logging.info("Starting {} project check".format(args.project))
         libft.check(root_path, args)
     if args.project == "42commandements":
+        logging.info("Starting {} project check".format(args.project))
         ft_commandements.check(args)
-    if args.project == "other":
-        other.check(root_path, args)
     if args.project == "fillit":
+        logging.info("Starting {} project check".format(args.project))
         fillit.check(root_path, args)
+    if args.project == "other":
+        logging.info("Starting {} project check".format(args.project))
+        other.check(root_path, args)
 
 
 if __name__ == '__main__':

PyChecker/projects/fillit.py

@@ -5,10 +5,11 @@
 
 from PyChecker.utils import author, norme, makefile, forbidden_functions
 from PyChecker.testing_suite import fillit_checker
+import logging
 
 
 def check(root_path: str, args):
-
+    logging.info("Started checks for project `fillit`")
     authorized_functions = ['exit', 'open', 'close', 'write', 'read', 'malloc',
                             'free', 'main']
 
@@ -35,4 +36,5 @@ def check(root_path: str, args):
         print("Forbidden Functions: \n" + forbidden_functions_results)
     if not args.no_fillit_checker:
         print("Fillit Checker: \n" + fillit_checker_results)
+    logging.info("Finished checks for project `fillit`")
     return 0

PyChecker/projects/ft_commandements.py

@@ -4,6 +4,7 @@
 """
 
 import os
+import logging
 
 
 def check(args):
@@ -15,12 +16,16 @@ def check(args):
      1 if the file doesn't exists,
      2 if the file content is different.
     """
+    logging.info("Started checks for project `42Commandements`")
     if not os.path.exists(args.path + '/rendu'):
+        logging.critical("File rendu not found")
         print("file `rendu' not found.")
         return 1
     with open(args.path + '/rendu', 'r') as file:
         content = file.read()
         if content != "En choisissant d'effectuer ma scolarite a 42, je declare adherer a ces regles ainsi qu'aux valeurs morales qu'elles vehiculent.\n":
+            logging.critical("Error: The `rendu' file content is different from what is expected.")
             print("Error: The `rendu' file content is different from what is expected.")
             return 2
+    logging.info("Finished checks for project `42Commandements`")
     return 0

PyChecker/projects/libft.py

@@ -7,29 +7,42 @@
 from PyChecker.utils import author, forbidden_functions, makefile, norme, static
 from PyChecker.testing_suite import maintest, moulitest, libftest
 from PyChecker.testing_suite import libft_unit_test
+import logging
+
 
 def check_required(project_path: str, required_functions):
+    logging.info("LIBFT: Started required function check.")
     while True:
         if all([os.path.isfile(project_path + '/' + function) for function in required_functions]):
             break
         else:
+            logging.debug("LIBFT: ERROR: not all required files are here")
             print("--> ERROR: not all required files are here")
+            logging.info("LIBFT: Finished required function check.")
             return "--> ERROR: not all required files are here"
+    logging.debug("LIBFT: All required functions are present.")
+    logging.info("LIBFT: Finished required function check.")
     return "-- All required functions are present."
 
 def check_bonuses(project_path: str, bonus_functions):
+    logging.info("LIBFT: Started bonus function check")
     has_libft_bonuses = True
     while True:
         if all([os.path.isfile(project_path + '/' + function) for function in bonus_functions]):
+            logging.debug("LIBFT: Found all bonuses files")
             break
         else:
             has_libft_bonuses = False
+            logging.warning("LIBFT: Warning: Warning: not all bonus files are here")
             print("--> Warning: not all bonus files are here")
+            logging.info("LIBFT: Finished bonus function check")
             return has_libft_bonuses, "--> Warning: not all bonus files are here"
+    logging.info("LIBFT: Finished bonus function check")
     return has_libft_bonuses, "-- All bonuses files were found."
 
 
 def count_extras(project_path: str, required_functions, bonus_functions):
+    logging.info("LIBFT: Started extra function count.")
     file_list = []
     for file in glob.glob(project_path + '/*.c'):
         file_list.append(file.replace(project_path + '/', ''))
@@ -38,12 +51,17 @@ def count_extras(project_path: str, required_functions, bonus_functions):
     print("*------------------------Extra functions:-----------------------*")
     print("*---------------------------------------------------------------*")
     print("You have {} extra functions.".format(len(extra_functions)))
+    if extra_functions:
+        logging.debug("Found extra functions:")
     for function in extra_functions:
+        logging.debug(function)
         print(function)
+    logging.info("LIBFT: Finished extra function count.")
     return extra_functions
 
 
 def check(root_path: str, args):
+    logging.info("Started check for project `libft`")
     required_functions = ['libft.h', 'ft_strcat.c', 'ft_strncat.c',
                           'ft_strlcat.c', 'ft_strchr.c', 'ft_strnstr.c',
                           'ft_strrchr.c', 'ft_strclr.c', 'ft_strcmp.c',
@@ -125,4 +143,5 @@ def check(root_path: str, args):
             print('libft-unit-test: \n' + libft_unit_test_results + '\n\n' + benchmark_results + '\n')
         else:
             print('libft-unit-test: \n' + libft_unit_test_results + '\n')
+    logging.info("Finished check for project `libft`")
     return 0

PyChecker/projects/other.py

@@ -3,9 +3,11 @@
     See full notice in `LICENSE'
 """
 from PyChecker.utils import author, norme, makefile
+import logging
 
 
 def check(root_path: str, args):
+    logging.info("Starting check for project `other`")
     if not args.no_author:
         author.check(args.path)
     if not args.no_norm:

PyChecker/testing_suite/fillit_checker.py

@@ -7,10 +7,14 @@
 from PyChecker.utils import git
 import re
 import os
+import logging
 
 
 def clean_log(root_path: str):
+    logging.info("FILLIT_CHECKER: Cleaning log file.")
+    logging.debug("FILLIT_CHECKER: Opening file {}.".format(root_path + '/.myfillitchecker-clean'))
     with open(root_path + '/.myfillitchecker-clean', 'w+') as file2:
+        logging.debug("FILLIT_CHECKER: Opening file {}.".format(root_path + '/.myfillitchecker'))
         with open(root_path + '/.myfillitchecker', 'r') as file:
             for line in file:
                 line = re.sub(r"\033\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]/", "", line)
@@ -26,17 +30,20 @@ def run(root_path: str, project_path: str):
 
     :param project_path: The path of the project you want to test.
     """
+    logging.info("Starting fillit checker tests.")
     print("*---------------------------------------------------------------*")
     print("*-------------------------fillit_checker------------------------*")
     print("*---------------------------------------------------------------*")
-
     if "fatal: Not a git repository" in git.status(root_path + '/testing_suites/fillit_checker'):
         git.clone("https://github.com/anisg/fillit_checker", root_path + '/testing_suites/fillit_checker')
     else:
         git.reset(root_path + '/testing_suites/fillit_checker')
 
     # @todo: Find a way to supress colors from output
+    logging.debug("FILLIT_CHECKER: Running `bash {}`".format(root_path + "/testing_suites/fillit_checker/test.sh"))
     result = subprocess.run(['bash', root_path + "/testing_suites/fillit_checker/test.sh", project_path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode('utf-8')
+    logging.debug("FILLIT_CHECKER: Opening file {}.".format(
+        root_path + '/.myfillitchecker'))
     with open(root_path + '/.myfillitchecker', 'w+') as file:
         file.write(result)
     #clean_log(root_path)
@@ -45,4 +52,5 @@ def run(root_path: str, project_path: str):
     #    for line in file:
     #        if "NOTE" in line:
     #            return line
+    logging.info("Finished fillit checker tests.")
     return "WIP"

PyChecker/testing_suite/libft_unit_test.py

@@ -8,47 +8,58 @@
 import os
 import io
 from PyChecker.utils import git
+import logging
 
 
 def run(root_path: str, args):
 
-
+    logging.info("Started runing `libft-unit-test` tests.")
     print("*---------------------------------------------------------------*")
     print("*------------------------libft-unit-test------------------------*")
     print("*---------------------------------------------------------------*")
-
     if platform.system() != 'Darwin':
         print("Sorry, this testing suite can only be ran on Darwin computers (MacOS)")
         with open(root_path + '/.mylibftunittest', 'w+') as file:
             file.write("Sorry, this testing suite can only be ran on Darwin computers (MacOS)\n")
+        logging.critical("Sorry, this testing suite can only be ran on Darwin computers (MacOS)")
         return "Sorry, this testing suite can only be ran on Darwin computers (MacOS)"
 
     if "fatal: Not a git repository" in git.status(root_path + '/testing_suites/libft-unit-test'):
         git.clone("https://github.com/alelievr/libft-unit-test.git", root_path + '/testing_suites/libft-unit-test')
     else:
         git.reset(root_path + '/testing_suites/libft-unit-test')
 
+    logging.debug("LUB: Opening file {}.".format(root_path + '/.mylibftunittest'))
     with open(root_path + '/.mylibftunittest', 'w+') as file:
+        logging.debug("LUB: Running `make re -C {} LIBFTDIR={}`".format(root_path + '/testing_suites/libft-unit-test', args.path))
         result = subprocess.run(['make', 're', '-C', root_path + '/testing_suites/libft-unit-test', 'LIBFTDIR=' + args.path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode('utf-8')
         file.write(result)
         print(result)
+        logging.debug("LUB: Running `make f {} LIBFTDIR={}`".format(root_path + '/testing_suites/libft-unit-test', args.path))
         result = subprocess.run(['make', 'f', '-C', root_path + '/testing_suites/libft-unit-test', 'LIBFTDIR=' + args.path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode('utf-8')
         print(result)
         file.write(result)
+        logging.debug("LUB: Renaming result.log and moving it into {}".format(root_path + '/.mylibftunittest-results'))
         os.rename(root_path + '/testing_suites/libft-unit-test/result.log', root_path + '/.mylibftunittest-results')
         # Starts benchmark if asked
         if args.do_benchmark:
+            logging.debug("LUB: Starting benchmark")
             oldpwd = os.getcwd()
+            logging.debug("Changing directory to {}".format(root_path + '/testing_suites/libft-unit-test/'))
             os.chdir(root_path + '/testing_suites/libft-unit-test/')
+            logging.debug("LUB: Running `./run_test -b`")
             result = subprocess.run(['./run_test', '-b'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode('utf-8')
+            logging.debug("LUB: Changing back directory to {}".format(oldpwd))
             os.chdir(oldpwd)
             print(result)
             file.write(result)
+            logging.debug("LUB: Opening file {}".format(root_path + '/.mylibftunittest'))
             with open(root_path + '/.mylibftunittest', 'r') as file2:
                 for line in file2:
                     if "WINNER:" in line:
                         benchmark_results = line
     # Open result file with correct encoding
+    logging.debug("LUB: Opening file {} with encoding ISO-8859-1".format(root_path + '/.mylibftunittest-results'))
     with io.open(root_path + '/.mylibftunittest-results', "r", encoding="ISO-8859-1") as file:
         data = file.read()
         results = 'OKs: ' + str(data.count('OK')) + '\n'
@@ -59,6 +70,7 @@ def run(root_path: str, args):
         results += 'not protected:' + str(data.count('not protected'))
     print(results)
     # Send results back
+    logging.info("Finished runing `libft-unit-test` tests.")
     if args.do_benchmark:
         return results, benchmark_results
     else: