Share
În prima parte a seriei tutorial, ați văzut cum să configurați proiectul și configurațiile necesare. Ați procesat jurnalele de proiect și le-ați imprimat în terminal. În această parte, vom trece la nivelul următor și vom trimite solicitările de examinare a codului.
Începeți prin clonarea codului sursă din prima parte a seriei tutorial.
git clone https://github.com/royagasthyan/CodeReviewer CodeReviewer
Odată ce ați clonat depozitul, navigați la directorul proiectului CodeReviewer și încercați să executați următoarea comandă în terminal.
python scheduler.py -n 20 -p "proiect_x"
Ar trebui să imprime codurile de comitet, data de comitere și autorul comitetului în terminal.
Veți primi detaliile de comitere în timp ce iterați jurnalele de comitere. Acum trebuie să colectați detaliile de comitere și să le memorați într-o listă, astfel încât să le puteți itera mai târziu pentru a trimite cererea de revizuire a codului. Pentru a colecta detaliile de comitere, începeți prin a crea un comite clasa cu membrii solicitați după cum se arată:
# ------------------------------------------- # # Comitează clasa pe care să o conțină comită informații legate # # ------------------------------------------- clasa Commit : def __init __ (auto, ID, autor, data): self.Id = Id; self.Author = Autor; auto date = data;
În timp ce iterăm jurnalele de comitere în process_commits metoda, creați un comite exemplu pentru a păstra detaliile comiterii.
În process_commits , definiți câteva variabile după cum se arată:
commitId = "autor =" data = "comitete = []
Veți colecta fiecare detaliu de comitere într-o listă Python numită comite. În timp ce citiți jurnalele de comitere, prima dată când se întâlnește codul de comitet, păstrați codul de comitere și spălați variabilele de dată și autor, deoarece este o nouă comitere. Modificați process_commits după codul de verificare al cuvântului cheie, după cum se arată:
Accentsconagua
dacă line.startswith ('commit'): author = "date =" commitId = line [7:]Când codul de comitet nu este nul, atunci când detaliile comiterii au fost colectate și este timpul să adăugăm comitetul la lista de angajamente. Adăugați următorul rând de cod la codul de mai sus:
dacă comanda (commit): commitId <> "": commits.append (Commit (commitId, author, date)) author = "date =" commitId = line [7:]
Modificați Autor verificarea cuvintelor cheie și Data verificați cuvintele cheie pentru a păstra detaliile de comitere respective în variabilele autorului și datei.
dacă line.startswith ('Autor:'): if (re.search ('<(.*?)\>', linie)): author = re.search ('<(.*?)\>', linie) .group (1) if line.startswith (' Date: '): date = line [5:]Acum, dacă există doar un singur comitet în codul sursă, detaliile vor fi salvate în lista de comitete. Deci, adăugați următorul cod la sfârșitul buclă pentru a gestiona acest scenariu.
dacă commitId <> "": commit.append (Commit (commitId, autor, date))
Aici este completă process_commits care colectează detaliile comiterii și returnează o listă de comitete.
# ---------------------------------- # # Procesați jurnalul git # # ------- --------------------------- def process_commits (): cmd = "cd" + proiect + "; git log - tot = "+ str" (no_days) + ".day - nume-statut" răspuns = execute_cmd (cmd) commitId = "author =" date = "commits = 'comitează'): dacă commitId <> "": commits.append (Commit (commitId, author, date)) author = "date =" commitId = line [7:] if line.startswith (cercetare('\<(.*?)\>', linie)): author = re.search ('<(.*?)\>', comanda (Commit (commitId, author, date)) comanda de întoarcere (Commit (commitId, author, date)Aveți detaliile de comitere colectate din jurnalul de proiect. Trebuie să selectați dezvoltatori aleatorii pentru a trimite cererea de revizuire a codului. În interiorul config.json fișier, să adăugăm dezvoltatorii asociați proiectului care pot examina codul. Aici este modificat config.json fişier:
"nume": "proiect_x", "git_url": "https://github.com/royagasthyan/project_x", "membri": ["royagasthyan", "hari", "sam", "shaun" , "nume": "project_y", "git_url": "https://github.com/royagasthyan/project_y", "membri": ["royagasthyan", "hari", "sam", "shaun" ]
Să citim informațiile despre dezvoltator legate de un anumit proiect. Definiți o variabilă publică numită project_members.
project_members = "
În timp ce citiți configurațiile proiectului, completați detaliile membrilor proiectului în project_members listă variabilă.
# # Citiți fișierul de configurare a planificatorului # cu fișierul deschis ('config.json') ca cfg_file: main_config = json.load (cfg_file) pentru p în main_config: if p ['name'] == project: project_url = p ['git_url '] project_members = p [' members '] pauzăAcum aveți lista de dezvoltatori referitoare la un anumit proiect din project_members variabil.
Definiți o metodă numită schedule_review_request pe care o veți apela pentru a programa cererea de examinare corespunzătoare fiecărui proiect de comitet. Cererea de recenzie va fi trimisă unui dezvoltator aleator din project_members listă, cu excepția autorului comitetului.
Creați o metodă numită select_reviewer pentru a selecta dezvoltatorul aleator din project_members listă. Pentru a selecta dezvoltatorii aleatorii din listă, veți utiliza întâmplător Modul Python. Importați întâmplător Modul Python.
importă aleatoriu
Iată cum ar arăta codul:
# ----------------------------------------- # # Metodă pentru a selecta recenzorul aleatoriu # # ----------------------------------------- def select_reviewer (autor, grup): dacă autorul în grup: group.remove (author) reviewer = random.choice (grup) revizuit
După cum se vede în codul de mai sus, autorul comitetului a fost eliminat din lista de dezvoltatori înainte de a selecta dezvoltatorii aleatorii pentru a examina codul. Pentru a selecta dezvoltatorii aleatorii din listă, ați folosit random.choice metoda de la întâmplător modul.
În interiorul schedule_review_request , iterați prin fiecare comitere din lista de angajamente. Pentru fiecare comitere, selectați un dezvoltator aleator altul decât autorul comitetului pentru a trimite solicitarea de examinare. Iată cum ar arăta codul:
def schedule_review_request (commits): pentru a comite în comitete: reviewer = select_reviewer (commit.Author, project_members)
Ați selectat dezvoltatori aleatorii pentru a trimite solicitarea de revizuire a codului. Înainte de a trimite solicitarea de examinare, trebuie să o formatați cu detalii despre solicitarea de revizuire. Definiți o metodă numită format_review_commit care va formata cererea de revizuire a codului. Iată cum ar arăta codul:
def format_review_commit (commit): review_req = "" review_req + = "URL:" + project_url + '/ commit /' + commit.Id + "\ n" review_req + = "Autor:" + commit.Author + "\ n" review_req + = "Data:" + commit.Date + "\ n" return_req
În schedule_review_request , creați conținutul de e-mail care solicită recenzia, care va fi trimis la recenzent. Conținutul de e-mail va conține informațiile necesare pentru ca recenzentul să revină la comiterea codului. Modificați schedule_review_request așa cum se arată:
def schedule_review_request (commits): date = time.strftime ("% Y-% m-% d") pentru comiterea comitetelor: reviewer = select_reviewer (commit.Author, project_members) subject = date + commit.Id + "]" body = "Bună ziua" "+ recenzent +" ', ați fost selectat să examinați codul de comitet \ n "body + =" done by "+ commit.Author + "body + =" \ n "body + = format_review_commit (commit) corpul de imprimareSalvați modificările de mai sus și executați programul de programare Python.
python scheduler.py -n 25 -p "proiect_x"
Ar trebui să puteți vedea o ieșire similară celei indicate mai jos:
Creați o metodă numită Trimite email care va trimite e-mailul solicitării de recenzie cu subiectul și conținutul solicitat. Veți fi de folos smtplib modul de trimitere a e-mailurilor. Import smptlib în scheduler.py fişier:
import smtplib
Definiți detaliile serverului de poștă electronică împreună cu variabilele publice:
FROM_EMAIL = "[email protected]" FROM_PWD = "parola" SERVER = "smtp.gmail.com" PORT = 587
Creați o metodă numită Trimite email care va trimite e-mailul la adresa specificată. Iată cum Trimite email cod ar arata:
def trimite_email (la, subiect, corp): header = "From:" + FROM_EMAIL + "\ n" header + = "header + =" \ n "antet + = imprimare corporală" ** Trimiterea e-mail la "+ to +" 'mail_server = smtplib.SMTP (SERVER, PORT) mail_server.starttls_mail_server.login FROM_EMAIL FROM_PWD mail_server.sendmail (FROM_EMAIL, la, header) mail_server.quit ()
După cum se vede în codul de mai sus, ați creat smtp server utilizând serverul Gmail și numărul portului. Utilizând numele de utilizator și parola definite, v-ați conectat la contul de e-mail și ați trimis e-mailul destinatarului.
Modificați schedule_review_request metoda de trimitere a e-mailului în loc de imprimare a conținutului de e-mail către terminal.
def schedule_review_request (commits): date = time.strftime ("% Y-% m-% d") pentru comiterea comitetelor: reviewer = select_reviewer (commit.Author, project_members) subject = date + commit.Id + "]" body = "Bună ziua" "+ recenzent +" ', ați fost selectat să examinați codul de comitet \ n "body + =" done by "+ commit.Author + "body + =" \ n "corp + = format_review_commit (comite) send_email (recenzent, subiect, organism)Salvați modificările de mai sus. Modificați config.json fișier pentru a include o adresă de e-mail validă pe care o puteți verifica. Rulați planificatorul utilizând următoarea comandă:
python scheduler.py -n 30 -p "proiect_x"
Ar trebui să puteți vedea următoarea ieșire pe terminal:
Verificați adresa de e-mail pentru a vedea solicitarea de revizuire a codului trimisă de la Planificatorul de revizuire a codului.
În această parte a seriei Schedulerului de revizuire a codului Python, ați colectat informațiile de comitet într-o listă. Lista de comitete a fost repetată pentru a formata solicitarea de revizuire. Dezvoltatorii aleatorii au fost selectați pentru a trimite solicitarea de revizuire a codului.
În următoarea parte a acestei serii, veți vedea cum să urmați solicitarea de revizuire a codului.
Codul sursă din acest tutorial este disponibil pe GitHub.
.
