[CHORE] Added some doc. From now on, We close #54 and start fillit.

Author: Seluj78

PyChecker/projects/ft_commandements.py

@@ -23,4 +23,4 @@ def check(args):
         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":
             print("Error: The `rendu' file content is different from what is expected.")
             return 2
-    return 0
+    return 0

PyChecker/projects/libft.py

@@ -91,6 +91,7 @@ def check(root_path: str, args):
             libft_unit_test_results, benchmark_results = libft_unit_test.run(root_path, args)
         else:
             libft_unit_test_results = libft_unit_test.run(root_path, args)
+
     print("\n\n\nThe results are in:\n")
     if not args.no_author:
         print("Author File: \n" + author_results + '\n')

PyChecker/testing_suite/libft_unit_test.py

@@ -13,11 +13,13 @@ def run(root_path: str, args):
     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")
         return "Sorry, this testing suite can only be ran on Darwin computers (MacOS)"
+
     with open(root_path + '/.mylibftunittest', 'w+') as file:
         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)
@@ -26,6 +28,7 @@ def run(root_path: str, args):
         print(result)
         file.write(result)
         os.rename(root_path + '/testing_suites/libft-unit-test/result.log', root_path + '/.mylibftunittest-results')
+        # Starts benchmark if asked
         if args.do_benchmark:
             oldpwd = os.getcwd()
             os.chdir(root_path + '/testing_suites/libft-unit-test/')
@@ -37,6 +40,7 @@ def run(root_path: str, args):
                 for line in file2:
                     if "WINNER:" in line:
                         benchmark_results = line
+    # Open result file with correct encoding
     with io.open(root_path + '/.mylibftunittest-results', "r", encoding="ISO-8859-1") as file:
         data = file.read()
         results = 'OKs: ' + str(data.count('OK')) + '\n'
@@ -46,7 +50,8 @@ def run(root_path: str, args):
         results += 'protected: ' + str(data.count('protected')) + '\n'
         results += 'not protected:' + str(data.count('not protected'))
     print(results)
+    # Send results back
     if args.do_benchmark:
         return results, benchmark_results
     else:
-        return results
+        return results

PyChecker/testing_suite/libftest.py

@@ -10,6 +10,7 @@
 from shutil import move
 from os import fdopen, remove
 
+
 def replace_my_config(root_path: str, project_path: str):
     with open(root_path + "/testing_suites/libftest/my_config.sh", 'w+') as file:
         file.write('# !/bin/bash' + '\n')
@@ -24,6 +25,7 @@ def replace_my_config(root_path: str, project_path: str):
         file.write('COLOR_TOTAL="${BOLD}${YELLOW}"' + '\n')
         file.write('COLOR_DEEPTHOUGHT_PATH="${BOLD}${PURPLE}"' + '\n')
 
+
 def run(project_path: str, root_path: str):
     """
     This function runs the libftest to the given project.
@@ -33,25 +35,27 @@ def run(project_path: str, root_path: str):
     print("*---------------------------------------------------------------*")
     print("*----------------------------Libftest---------------------------*")
     print("*---------------------------------------------------------------*")
+
     replace_my_config(root_path, project_path)
     result = subprocess.run(['bash', root_path + "/testing_suites/libftest/grademe.sh",
                              "-l -s -f -n -u"], stdout=subprocess.PIPE,
                             stderr=subprocess.STDOUT).stdout.decode('utf-8')
     os.rename(root_path + "/deepthought", root_path + "/.mylibftest-deepthought")
     print("Deepthought file too big. Not printed. See `.mylibftest-deepthought'.")
+
     with open(root_path + "/.mylibftest", 'w+') as file:
         file.write("*------------------------------------------------------*\n")
         file.write("LIBFTEST\n")
         file.write("Warning: This file contains escape sequences. Please use "
                    "`cat' to view it properly.\n")
         file.write("*------------------------------------------------------*\n")
         file.write(result)
+
     print(result)
     with open(root_path + "/.mylibftest", 'r') as file:
         res = ""
         for line in file:
             if "Total : " in line:
                 res += line
-    totals = []
     totals = res.split('\n')
     return totals

PyChecker/testing_suite/maintest.py

@@ -10,6 +10,13 @@
 
 
 def comment_define(source, destination, tokens):
+    """
+    This function will comment defines set in tokens.
+
+    :param source: The file you want to seek from
+    :param destination: The file you want to write in
+    :param tokens: The tokens you want commented
+    """
     with open(source, 'r') as src, open(destination, 'w+') as dst:
         for line in src:
             for token in tokens:
@@ -40,10 +47,12 @@ def run_libft(project_path: str, root_path: str):
                           'itoa', 'strtrim', 'lstnew', 'lstdelone', 'lstdel',
                           'lstadd', 'lstiter', 'lstmap']
     missing_functions = []
+
     for file in maintest_functions:
         # @todo: Add a check to handle libft where file aren't at libft/ but can be in libft/src
         if not os.path.exists(project_path + '/ft_' + file + '.c'):
             missing_functions.append(file)
+
     # @todo: special case for memalloc and memdel
     comment_define(root_path + '/testing_suites/Maintest/libft/main.c', root_path + '/libft_main.c', missing_functions)
     with open(root_path + "/.mymaintest", 'w+') as file:
@@ -52,6 +61,7 @@ def run_libft(project_path: str, root_path: str):
         file.write("Warning: This file contains escape sequences. Please use "
                    "`cat' to view it properly.\n")
         file.write("*------------------------------------------------------*\n")
+
         result = subprocess.run(['gcc', root_path + '/libft_main.c', '-L' + project_path,
                                  '-I' + project_path, "-I" + project_path +
                                  "/include", "-I" + project_path + "/includes",
@@ -62,11 +72,13 @@ def run_libft(project_path: str, root_path: str):
         print(result)
         result = subprocess.run([root_path + '/libft_main.out'], stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT).stdout.decode('utf-8')
+
         # @todo: Count number of OK and FAILs and yellow tests to get score for maintest
         file.write(result + '\n')
         print(result)
     if platform.system() == "Linux":
         print("-- Disclaimer: Some of these test may fail where they woudn't on Darwin. (Because Linux ?)")
+    # Cleanup and return
     os.remove(root_path + "/libft_main.c")
     os.remove(root_path + "/libft_main.out")
     # @todo: Check if FAIL is the right keyword.

PyChecker/testing_suite/moulitest.py

@@ -8,7 +8,7 @@
 
 def include_libft_bonuses(root_path: str):
     """
-    This method removes the `.exclude` extention to the libft bonuses files.
+    This function removes the `.exclude` extention to the libft bonuses files.
     """
     moulitest_libft_tests_path = root_path + "/testing_suites/moulitest/libft_tests/tests"
     files = os.listdir(moulitest_libft_tests_path)
@@ -21,7 +21,7 @@ def include_libft_bonuses(root_path: str):
 
 def exclude_libft_bonuses(root_path: str):
     """
-    This method Adds the `.exclude` extention to the libft bonuses files.
+    This function Adds the `.exclude` extention to the libft bonuses files.
     """
     moulitest_libft_tests_path = root_path + "/testing_suites/moulitest/libft_tests/tests"
     files = os.listdir(moulitest_libft_tests_path)
@@ -32,22 +32,25 @@ def exclude_libft_bonuses(root_path: str):
 
 
 def execute_test(test_name: str, root_path: str):
-    available_tests = ['libft_part1', 'libft_part2', 'libft_bonus', 'get_next_line', 'gnl', 'ft_ls', 'ft_printf']
+    available_tests = ['libft_part1', 'libft_part2', 'libft_bonus',
+                       'get_next_line', 'gnl', 'ft_ls', 'ft_printf']
     if test_name not in available_tests:
         raise ValueError("Given test not in moulitest available tests.")
+
     with open(root_path + "/.mymoulitest", 'w+') as file:
         file.write("*------------------------------------------------------*\n")
         file.write("MOULITEST\n")
         file.write("Warning: This file contains escape sequences. Please use"
                    " `cat' to view it properly.\n")
         file.write("*------------------------------------------------------*\n")
-        # @todo: Get the result line of moulitest and parse it.
+        # Run moulitest
         result = subprocess.run('make ' + test_name + ' -C ' + root_path +
                                 '/testing_suites/moulitest', shell=True,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT).stdout.decode('utf-8')
         file.write(result + '\n')
         print(result)
+    # Parse the result
     with open(root_path + "/.mymoulitest", 'r') as file:
         for line in file:
             if "(dots)." in line:
@@ -60,9 +63,11 @@ def run(project_path: str, has_libft_bonuses: bool, project: str, root_path: str
     print("*--------------------------Moulitest----------------------------*")
     print("*---------------------------------------------------------------*")
     available_projects = ['ft_ls', 'ft_printf', 'gnl', 'libft', 'libftasm']
+
     #  Available projects checks if the given project corresponds to one the moulitest tests.
     if project not in available_projects:
         raise ValueError("given project not in moulitest available projects.")
+
     if project == "libft":
         with open(root_path + "/testing_suites/moulitest/config.ini", 'w+') as file:
             file.write("LIBFT_PATH = " + project_path)

PyChecker/utils/forbidden_functions.py

@@ -16,29 +16,33 @@ def check(project_path: str, authorized_func, root_path: str):
     :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("*---------------------------------------------------------------*")
     ret = ""
     functions_called = []
-    # @todo: Check difference between Darwin and Linux `nm'
-    subprocess.run(['make', '-C', project_path, 'all'], stdout=subprocess.PIPE,
-                            stderr=subprocess.STDOUT)
+
+    # Get binary name
+    with open(project_path + '/Makefile', 'r') as file:
+        data = file.read()
+        binary = re.findall("NAME[\s]*=[\s]*(.*)", data)[0]
+
+    subprocess.run(['make', '-C', project_path, 'all'])
     result = subprocess.run(['nm', project_path + '/' + binary],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.STDOUT).stdout.decode('utf-8')
     for line in result.splitlines():
         if "U " in line:
             functions_called.append(re.sub(' +', ' ', line))
+
+    # Os check for nm differences
     if platform.system() == "Darwin":
         sys_calls = {func.replace(' U _', '') for func in functions_called}
     elif platform.system() == "Linux":
         sys_calls = {func.replace(' U ', '') for func in functions_called}
     else:
         sys_calls = ['Error']
+
     sys_calls = [item for item in sys_calls if not item.startswith("ft_")]
     extra_function_call = [item for item in sys_calls if item not in authorized_func]
     with open(root_path + "/.myforbiddenfunctions", 'w+') as file:

PyChecker/utils/makefile.py

@@ -393,13 +393,15 @@ def check(project_path: str, root_path: str):
     print("*---------------------------------------------------------------*")
     print("*----------------------------Makefile---------------------------*")
     print("*---------------------------------------------------------------*")
+
     makefile_path = project_path + '/Makefile'
     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)
@@ -408,6 +410,7 @@ def check(project_path: str, root_path: str):
     error_count += check_makefile_fclean(project_path, binary_name, root_path)
     error_count += check_makefile_name(project_path, binary_name, root_path)
     error_count += check_makefile_phony(project_path, binary_name, root_path)
+
     print("\n\n\t\tFound {} errors on your makefile".format(error_count))
     with open(root_path + "/.mymakefile", 'a') as file:
         file.write("\n\n\t\tFound {} errors on your makefile\n".format(error_count))

PyChecker/utils/norme.py

@@ -29,6 +29,7 @@ def check(project_path: str, root_path: str):
     if files == "":
         print("-- No source file (.c) or header (.h) to check")
         return "-- No source file (.c) or header (.h) to check"
+
     with open(root_path + "/.mynorme", 'w+') as file:
         try:
             # Run the norminette on those files
@@ -43,7 +44,6 @@ def check(project_path: str, root_path: str):
             file.write(result)
             error_count = 0
             warning_count = 0
-            # Count the results
             error_count = result.count('Error')
             warning_count = result.count('Warning')
             if error_count != 0 or warning_count != 0: