def ressamblance_fonction(f1, f2):
f1 = trouve_variables.snailVariables(f1,
trouve_variables.countVariables(f1))
f2 = trouve_variables.snailVariables(f2,
trouve_variables.countVariables(f2))
l1, l2 = len(f1), len(f2)
if l1 > l2: #on ajuste la longueur des fonction
for k in range(l1 - l2):
f2 = f2 + []
l = l1
else:
for k in range(l2 - l1):
f1 = f1 + []
l = l2
same = 0
for k in range(len(f1)): #on calcule les similitude
same += duplicationFonction.pourcentage_similitude_ligne(f1[k], f2[k])
return (same / l)
def controle_duplication(Code, precision, code_controle):
Code = checkIndentation.retirerIndentation(
commentaires.retirerCom(Code)) #on enlève indentation et commentaires
code_controle = checkIndentation.retirerIndentation(
commentaires.retirerCom(code_controle))
Code = trouve_variables.snailVariables(
Code, trouve_variables.countVariables(Code)) #on enlève les variables
code_controle = trouve_variables.snailVariables(
code_controle, trouve_variables.countVariables(code_controle))
similitude_fonctions = []
fonctions = trouve_fonction.count_fonction(
Code) #trouve les fonctions de code
for num_fonction in range(len(fonctions)):
similitude_fonctions.append(
controle_duplicat_fonction(
Code[fonctions[num_fonction]["start"] +
1:fonctions[num_fonction]["end"]], precision,
code_controle))
return (similitude_fonctions)
def graphiquenote(lignes):
compteur = appelvar(lignes)
nbvariables = len(countVariables(lignes))
pourcentage = round(100*compteur/nbvariables)
#print(str(compteur))
note=int(10-(0.5*compteur))
if note >=0:
note=note
else:
note = 0
return("Variables appelées-Evaluation de l'appel des variables-variables utilisées+variables non utilisées-"+str(100-pourcentage)+"-Note : "+str(note)+"/10-|",note)
def appelvar (lignes): #lignes=fichier texte contenant toutes les lignes du code
#regarde si une variable a été utilisée
compteur=0 #compteur correspond au nombre de fois où une variable n'a pas été appelée
L=textefonctions(lignes)
for i in range(len(L)) :
vars= countVariables(L[i][1]) #vars = les variables dans la ième fonction
vars= vars + varglobefore(L[i][0], lignes) #on rajoute les variables globales créées avant la fonction
for var in vars:
if vars.count(var) ==1:
compteur+=1
return compteur
def varglobal(lignes):
#renvoie les variables globales et les indices des lignes où elles apparaissent
L=numlignevarglo(lignes)
vars=[]
for i in L:
#print("lol" +str(lignes[i-1]))
var= countVariables([lignes[i-1]]) #appel fonction pour récupérer la variable dans la ligne i de lignes
#print(var)
if var:
vars.append([var[0],i])
#print (vars) #var= un tableau avec comme seul élément une variable
return vars
def fonction_double(Code, precision):
Code = checkIndentation.retirerIndentation(
commentaires.retirerCom(Code)) #on enlève indentation et commentaires
Code = trouve_variables.snailVariables(
Code, trouve_variables.countVariables(Code)) #on enlève les variables
liste_fonction = trouve_fonction.count_fonction(Code)
for f in range(len(liste_fonction)):
liste_fonction[f]["copie"] = len(
duplicationFonction.controle_duplicat_fonction(
Code[liste_fonction[f]["start"] + 1:liste_fonction[f]["end"]],
precision, Code[:liste_fonction[f]["start"] + 1] +
Code[liste_fonction[f]["end"] + 1:]))
return (liste_fonction)
def double_fonction_meme_nom(Code):
Code = checkIndentation.retirerIndentation(
commentaires.retirerCom(Code)) #on enlève indentation et commentaires
Code = trouve_variables.snailVariables(
Code, trouve_variables.countVariables(Code)) #on enlève les variables
liste_fonction = trouve_fonction.count_fonction(Code)
for i in range(len(liste_fonction) - 1):
for j in range(i + 1, len(liste_fonction)):
if liste_fonction[i]["nom"] == liste_fonction[j]["nom"]:
liste_fonction[i]["copie_status"].append(
(j,
ressamblance_fonction(
Code[liste_fonction[i]["start"] +
1:liste_fonction[i]["end"]],
Code[liste_fonction[j]["start"] +
1:liste_fonction[j]["end"]])))
liste_fonction[j]["copie_status"].append(
(i,
ressamblance_fonction(
Code[liste_fonction[i]["start"] +
1:liste_fonction[i]["end"]],
Code[liste_fonction[j]["start"] +
1:liste_fonction[j]["end"]])))
return (liste_fonction)
def test_countVariables():
lines = readLines(path)
result = toTest.countVariables(lines)
assert type(result) == list
assert "KIND" in result
#Parsing des fonctions présentes dans le code et affichage de leur nombre de lignes.
print("----- FONCTIONS -----")
txt, points_f1 = printFonction(lines)
results_txt = results_txt + txt
txt, points_f2 = creation_string(lines)
results_txt = results_txt + txt
#Parsing des tests présents dans le code et affichage de données à leur sujet.
print("----- VERIFICATION DES TESTS -----")
txt, points_t = printStatsTests(lines, False)
results_txt = results_txt + txt
#Parsing des variables présentes dans le code et affichage d'informations à leur sujet.
print("----- VARIABLES -----")
variables_list = countVariables(lines)
txt, points_v = returnmain(variables_list)
results_txt = results_txt + txt
txt, points_v2 = graphiquenote(lines)
results_txt = results_txt + txt
points_i = round(points_i * points_f2)
points_c = round(points_c * points_f2)
points_t = round(points_t * points_f2)
points_v = round(points_v * points_f2)
points_v2 = round(points_v2 * points_f2)
note = round((points_i + points_c + points_t + points_v + points_v2) / 5)
results_txt = results_txt + "Synthèse--Indentation+Commentaires+Tests+Nommage+Variables utilisées+Points perdus-" + str(
points_i * 100 // 50) + "+" + str(points_c * 100 // 50) + "+" + str(
points_t * 100 // 50) + "+" + str(points_v * 100 // 50) + "+" + str(
points_v2 * 100 // 50) + "-Note : " + str(note) + "/10-|"