[FIX/DOC] Documented some code and added a regex to get the binary name directly from the makefile. Fixes #68

Author: Seluj78

42PyChecker.py

@@ -6,10 +6,13 @@
 import argparse
 import platform
 from PyChecker.projects import libft, ft_commandements, other
-# @todo: Add verbose output
 
 
 def print_header():
+    """
+    This function simply prints the warranty and condition statement.
+    Might be removed in the future
+    """
     print("\t42PyChecker  Copyright (C) 2018-present Jules Lasne "
           "<jules.lasne@gmail.com>\n\tThis program comes with"
           " ABSOLUTELY NO WARRANTY; for details run with `--show-w'.\n\tThis is free"
@@ -18,8 +21,16 @@ def print_header():
 
 
 def main():
+    """
+    Main function where arguments are parse and where the GUI is created.
+    """
+
+    # Initialize the parser and get the path of the script to use as a reference.
     root_path = os.path.dirname(os.path.realpath(__file__))
     parser = argparse.ArgumentParser()
+
+    # @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("--no-gui", help="disables the Graphical User Interface",
@@ -44,9 +55,12 @@ def main():
     # @todo: Fix --do-benchmark option for libft-unit-test
     parser.add_argument("--do-benchmark", help="Disables libft-unit-test benchmarking", action="store_false")
 
+    # Calls the parser for the arguments we asked to implement.
     args = parser.parse_args()
+
+    # If the argument `--show-w` is passed, the program will display the warranty
+    # statement and exit.
     if args.show_w:
-        print_header()
         print("THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY"
               " APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING\n"
               " THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM"
@@ -57,20 +71,32 @@ def main():
               " WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME\n"
               " THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.")
         return
+
+    # If the `--show-c` argument is passed, the program will display the License
+    # and exit.
     if args.show_c:
-        print_header()
         with open(root_path + '/.github/LICENSE.lesser', 'r') as file:
             print(file.read())
         return
+
+    # Here, if the `--no-tests` option is set, all the testing suites will be
+    # disabled, no matter the project.
     if args.no_tests:
         args.no_libftest = True
         args.no_maintest = True
         args.no_moulitest = True
+        args.no_libft_unit_test = True
+
+    # If no project is given the parser sends an error.
     if args.project is None:
         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 == "":
         parser.error("`--path' needs to be specified in order for 42PyChecker"
                      " to know where your project is.")
+
+    # If a test is disabled and the libft project is selected, the parser will
+    # return an error.
     if args.no_libftest and args.project != "libft":
         parser.error("`--no-libftest' can only be applied if libft is selected "
                      "with `--project'")
@@ -80,7 +106,8 @@ def main():
     if args.no_moulitest and args.project != "libft":
         parser.error("`--no-moulitest' can only be applied if libft is selected"
                      " with `--project'")
-    print_header()
+
+    # Here we select the project and start the check based on the argument `--project`
     if args.project == "libft":
         libft.check(root_path, args)
     # @todo: Handle options for 42commandements: No option can be passed (like --no-norm)
@@ -93,6 +120,7 @@ def main():
 
 if __name__ == '__main__':
     if not platform.system() == "Windows":
+        print_header()
         main()
     else:
         raise OSError("Sorry, this script can't be run on windows !")

PyChecker/projects/libft.py

@@ -78,9 +78,9 @@ def check(root_path: str, args):
     if not args.no_static:
         static_results = static.check(root_path, args)
     if not args.no_makefile:
-        makefile_results = makefile.check(args.path, "libft.a", root_path)
+        makefile_results = makefile.check(args.path, root_path)
     if not args.no_forbidden_functions:
-        forbidden_functions_results = forbidden_functions.check(args.path, "libft.a", authorized_functions, root_path)
+        forbidden_functions_results = forbidden_functions.check(args.path, authorized_functions, root_path)
     if not args.no_moulitest:
         moulitest_results = moulitest.run(args.path, has_libft_bonuses, "libft", root_path)
     if not args.no_libftest:

PyChecker/projects/other.py

@@ -2,14 +2,15 @@
     Copyright (C) 2018 Jules Lasne <jules.lasne@gmail.com>
     See full notice in `LICENSE'
 """
-from PyChecker.utils import author, norme
+from PyChecker.utils import author, norme, makefile
 
 
 def check(root_path: str, args):
     if not args.no_author:
         author.check(args.path)
     if not args.no_norm:
         norme.check(args.path, root_path)
-    # @todo: Add the makefile check and find the binary name itself
+    if not args.no_makefile:
+        makefile.check(args.path, root_path)
     # @todo: Add forbidden function check based on assumption of what the project is.
     return 0

PyChecker/utils/forbidden_functions.py

@@ -8,14 +8,17 @@
 import re
 
 
-def check(project_path: str, binary: str, authorized_func, root_path: str):
+def check(project_path: str, authorized_func, root_path: str):
     """
     This function will check the functions used by the given binary in the given project.
 
     :param project_path: The path of the project you want to test.
     :param binary_name: The binary that you want to analyze
     :param authorized_func: The functions authorized by the project.
     """
+    with open(project_path + '/Makefile', 'r') as file:
+        data = file.read()
+        binary = re.findall("NAME[\s]*=[\s]*(.*)", data)[0]
     print("*---------------------------------------------------------------*")
     print("*----------------------Forbidden functions:---------------------*")
     print("*---------------------------------------------------------------*")

PyChecker/utils/makefile.py

@@ -10,17 +10,30 @@
 
 
 def check_makefile_clean_dir(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will clean the project's directory and test if the binary
+    and the .o were removed.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     with open(root_path + "/.mymakefile", 'w+') as file:
         file.write("Cleaning Directory\n")
         print("Cleaning Directory")
         file.write("*------------------------------------------------------*\n")
         file.write("")
+        # Run make fclean in the project's directory
         result = subprocess.run('make ' + '-C ' + project_path + ' fclean',
                                 shell=True, stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT).stdout.decode('utf-8')
         file.write(result + '\n')
         print(result)
+        # If the binary or the object file still exists after the fclean,
+        # print an error and increment the error counter.
         if os.path.exists(project_path + '/' + binary_name):
             file.write("-> Error when processing rule `fclean':"
                        " It should have removed {}\n".format(binary_name))
@@ -37,6 +50,15 @@ def check_makefile_clean_dir(project_path: str, binary_name: str, root_path: str
 
 
 def check_makefile_all(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `all` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -45,6 +67,8 @@ def check_makefile_all(project_path: str, binary_name: str, root_path: str):
             file.write("*------------------------------------------------------*\n")
             file.write("Checking rule: `all'\n")
             print("Checking rule: `all'")
+            # Searches every line of the makefile for the string `all`
+            # followed by spaces and/or tabs and then a `:`
             for line in makefile:
                 if re.match('^all[\t ]*:', line):
                     match = True
@@ -53,6 +77,9 @@ def check_makefile_all(project_path: str, binary_name: str, root_path: str):
                 print("-> Error: rule `all' not found in the Makefile.")
                 error_count += 1
                 return error_count
+            # Searches every line of the makefile for the string `all` followed
+            # by tabs and/or spaces and then `:` then tabs and spaces again and
+            # then for the string `$(NAME)`
             for line in makefile:
                 if re.match('^all[\t ]*:[\t ]*\$\(NAME\)', line):
                     match = True
@@ -61,11 +88,13 @@ def check_makefile_all(project_path: str, binary_name: str, root_path: str):
                 print("-> Error: rule `all' should call the rule `$(NAME)'")
                 error_count += 1
                 return error_count
+            # Runs make all in the project's directory
             result = subprocess.run('make ' + '-C ' + project_path + ' all',
                                     shell=True, stdout=subprocess.PIPE,
                                     stderr=subprocess.STDOUT).stdout.decode('utf-8')
             file.write(result + '\n')
             print(result)
+            # Checks if binary and object file were created.
             if not os.path.exists(project_path + '/' + binary_name):
                 file.write("-> Error when processing rule `all':"
                            " It should have created {}\n".format(binary_name))
@@ -83,6 +112,15 @@ def check_makefile_all(project_path: str, binary_name: str, root_path: str):
 
 
 def check_makefile_clean(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `clean` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -91,6 +129,8 @@ def check_makefile_clean(project_path: str, binary_name: str, root_path: str):
             file.write("*------------------------------------------------------*\n")
             file.write("Checking rule: `clean'\n")
             print("Checking rule: `clean'")
+            # Searches every line of the makefile for the string `clean`
+            # followed by `:`
             for line in makefile:
                 if re.match('^clean[\t ]*:', line):
                     match = True
@@ -99,18 +139,23 @@ def check_makefile_clean(project_path: str, binary_name: str, root_path: str):
                 print("-> Error: rule `clean' not found in the Makefile.")
                 error_count += 1
                 return error_count
+            # If previous rule failed, print an error message, increment error
+            # counter and return number of errors.
             if not os.path.exists(project_path + '/' + binary_name):
                 file.write("-> Error: Cannot test rule `clean' because rule"
                            " `all' failed\n")
                 print("-> Error: Cannot test rule `clean' because rule"
                            " `all' failed")
                 error_count += 1
                 return error_count
+            # Run `make clean` in the project's directory
             result = subprocess.run('make ' + '-C ' + project_path + ' clean',
                                     shell=True, stdout=subprocess.PIPE,
                                     stderr=subprocess.STDOUT).stdout.decode('utf-8')
             file.write(result + '\n')
             print(result)
+            # If the binary name is not here and/or the object files are here,
+            # the rule failed.
             if not os.path.exists(project_path + '/' + binary_name):
                 file.write("-> Error: Failing Rule: It should not have "
                            "cleaned the binary named {}.\n".format(binary_name))
@@ -125,6 +170,15 @@ def check_makefile_clean(project_path: str, binary_name: str, root_path: str):
 
 
 def check_makefile_re(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `re` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -181,6 +235,15 @@ def check_makefile_re(project_path: str, binary_name: str, root_path: str):
 
 
 def check_makefile_fclean(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `fclean` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -220,6 +283,15 @@ def check_makefile_fclean(project_path: str, binary_name: str, root_path: str):
 
 
 def check_makefile_name(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `$(NAME)` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -258,6 +330,15 @@ def check_makefile_name(project_path: str, binary_name: str, root_path: str):
 
 
 def check_makefile_phony(project_path: str, binary_name: str, root_path: str):
+    """
+    This function will check the rule `.PHONY` for the makefile of the given project.
+
+    :param project_path: The project path where what needs to be tested is.
+    :param binary_name: The name of the binary the makefile will compile
+    :param root_path: The absolute path leading to the script's main file.
+
+    :return: Returns the number of errors encountered during that function.
+    """
     error_count = 0
     makefile_path = project_path + '/Makefile'
     match = False
@@ -299,14 +380,15 @@ def check_makefile_phony(project_path: str, binary_name: str, root_path: str):
     return error_count
 
 
-def check(project_path: str, binary_name: str, root_path: str):
+def check(project_path: str, root_path: str):
     """
-    This function is the one you call to test the makefile given with the project.
+    This function will run all the makefile checks.
 
     :param project_path: The path of the project you want to test.
     :param binary_name: The binary that the makefile compiles
+    :param root_path: The absolute path leading to the script's main file.
 
-    :return This functions returns 1 If an error occured, 0 otherwise.
+    :return This functions returns the number of errors found on the makefile
     """
     print("*---------------------------------------------------------------*")
     print("*----------------------------Makefile---------------------------*")
@@ -315,6 +397,9 @@ def check(project_path: str, binary_name: str, root_path: str):
     if not os.path.exists(makefile_path):
         print("--> Error: Makefile not found.")
         return "--> Error: Makefile not found."
+    with open(makefile_path, 'r') as file:
+        data = file.read()
+        binary_name = re.findall("NAME[\s]*=[\s]*(.*)", data)[0]
     error_count = 0
     error_count += check_makefile_clean_dir(project_path, binary_name, root_path)
     error_count += check_makefile_all(project_path, binary_name, root_path)