Pianificazione di un pianificatore di revisione del codice Python invio di richieste di revisione

Nella prima parte della serie di tutorial, hai visto come impostare il progetto e le sue configurazioni richieste. Hai elaborato i log git del progetto e li hai stampati nel terminale. In questa parte, lo porteremo al livello successivo e invieremo le richieste di revisione del codice.

Iniziare

Inizia clonando il codice sorgente dalla prima parte della serie di tutorial.

git clone https://github.com/royagasthyan/CodeReviewer CodeReviewer

Dopo aver clonato il repository, accedere alla directory del progetto CodeReviewer e prova ad eseguire il seguente comando nel terminale.

python scheduler.py -n 20 -p "project_x"

Dovrebbe stampare gli ID di commit, la data di commit e l'autore del commit nel terminale.

Raccolta di tutti i commit con i dettagli

Otterrai i dettagli del commit durante l'iterazione dei log di commit. Ora è necessario raccogliere i dettagli del commit e memorizzarli in un elenco, in modo da poterli iterare in seguito per inviare la richiesta di revisione del codice. Per raccogliere i dettagli del commit, iniziare creando un Commettere classe con i membri richiesti come mostrato:

# ------------------------------------------- # # Impegna la classe da contenere commit related info # # ------------------------------------------- class Commit : def __init __ (self, Id, Author, Date): self.Id = Id; self.Author = Autore; self.Date = Date;

Durante l'iterazione dei registri di commit in process_commits metodo, creare a Commettere istanza per mantenere i dettagli del commit.

Nel process_commits metodo, definire alcune variabili come mostrato:

commitId = "author =" date = "commit = []

Raccoglierai ogni dettaglio di commit in una lista Python chiamata impegna. Durante la lettura dei registri di commit, la prima volta che viene rilevato l'ID di commit, mantenere l'Id di commit e svuotare la data e le variabili di autore poiché si tratta di un nuovo commit. Modifica il process_commits codice del metodo dopo il controllo della parola chiave commit come mostrato: 

if line.startswith ('commit'): author = "date =" commitId = line [7:]

Quando l'Id di commit non è nullo, è in quel momento che i dettagli del commit sono stati raccolti ed è ora di aggiungere il commit alla lista dei commit. Aggiungere la seguente riga di codice al codice precedente:

if line.startswith ('commit'): if commitId <> "": commits.append (Commit (commitId, author, date)) author = "date =" commitId = line [7:]

Modifica il Autore controllo delle parole chiave e il Data verifica della parola chiave per mantenere i rispettivi dettagli di commit nell'autore e le variabili di data.

se line.startswith ('Autore:'): if (re.search ('\<(.*?)\>', linea)): author = re.search (' \<(.*?)\>', line) .group (1) se line.startswith (' Date: '): date = line [5:]

Ora, se c'è un solo commit nel codice sorgente, i dettagli verranno salvati all'interno dell'elenco di commit. Quindi aggiungi il seguente codice alla fine del ciclo per gestire lo scenario.

if commitId <> "": commits.append (Commit (commitId, author, date))

Ecco il completo process_commits metodo che raccoglie i dettagli del commit e restituisce un elenco di commit.

# ---------------------------------- # # Elabora il log git # # ------- --------------------------- def process_commits (): cmd = "cd" + project + "; git log --all --since = "+ str (no_days) +" .day --name-status "response = execute_cmd (cmd) commitId =" author = "date =" commit = [] per la riga in response.splitlines (): if line.startswith ( 'commit'): if commitId <> "": commits.append (Commit (commitId, author, date)) author = "date =" commitId = line [7:] se line.startswith ('Autore:'): if (ricerca('\<(.*?)\>', linea)): author = re.search (' \<(.*?)\>', line) .group (1) se line.startswith (' Date: '): date = line [5:] se commitId <> "": commits.append (commit (commitId, author, date)) return commit

Pianificazione di una richiesta di revisione del codice

I dettagli del commit sono raccolti dal registro del progetto. Devi selezionare sviluppatori casuali per inviare la richiesta di revisione del codice. Dentro il config.json file, aggiungiamo gli sviluppatori associati al progetto che possono rivedere il codice. Ecco la modifica config.json file:

["name": "project_x", "git_url": "https://github.com/royagasthyan/project_x", "membri": ["royagasthyan", "hari", "sam", "shaun"] , "nome": "project_y", "git_url": "https://github.com/royagasthyan/project_y", "membri": ["royagasthyan", "hari", "sam", "shaun"] ]

Leggiamo le informazioni dello sviluppatore relative a un particolare progetto. Definire una variabile pubblica chiamata project_members.

project_members = "

Durante la lettura delle configurazioni del progetto, inserire i dettagli del membro del progetto nel project_members lista variabile.

# # Leggi il file di configurazione dello schedulatore # con open ('config.json') come cfg_file: main_config = json.load (cfg_file) per p in main_config: if p ['name'] == progetto: project_url = p ['git_url '] project_members = p [' membri '] interruzione

Ora hai l'elenco degli sviluppatori relativo a un particolare progetto nel project_members variabile.

Definire un metodo chiamato schedule_review_request che chiamerai per pianificare la richiesta di revisione corrispondente a ciascun commit di progetto. La richiesta di revisione verrà inviata a uno sviluppatore casuale dal project_members elenco, escluso l'autore del commit. 

Crea un metodo chiamato select_reviewer selezionare lo sviluppatore casuale dal project_members elenco. Per selezionare gli sviluppatori casuali dalla lista, farai uso di casuale Modulo Python. Importa il casuale Modulo Python.

importazione casuale

Ecco come apparirà il codice:

# ----------------------------------------- # # Metodo per selezionare un recensore casuale # # ----------------------------------------- def select_reviewer (autore, gruppo): se autore in gruppo: group.remove (autore) revisore = random.choice (gruppo) revisore di ritorno

Come visto nel codice precedente, l'autore del commit è stato rimosso dall'elenco degli sviluppatori prima di selezionare sviluppatori casuali per rivedere il codice. Per selezionare gli sviluppatori casuali dall'elenco, hai fatto uso di random.choice metodo dal casuale modulo.

Dentro il schedule_review_request metodo, scorrere ogni commit dall'elenco dei commit. Per ogni commit, selezionare uno sviluppatore casuale diverso dall'autore del commit per inviare la richiesta di revisione. Ecco come apparirà il codice:

def schedule_review_request (commit): for commit in commit: reviewer = select_reviewer (commit.Author, project_members)

Formattare la richiesta di revisione del codice

Hai selezionato sviluppatori casuali per inviare la richiesta di revisione del codice. Prima di inviare la richiesta di revisione, è necessario formattarla con i dettagli sulla richiesta di revisione. Definire un metodo chiamato format_review_commit che formatterà la richiesta di revisione del codice. Ecco come apparirà il codice:

def format_review_commit (commit): review_req = "" review_req + = "URL:" + project_url + '/ commit /' + commit.Id + "\ n" review_req + = "Conferma:" + commit.Id + "\ n" review_req + = "Autore:" + commit.Author + "\ n" review_req + = "Data:" + commit.Date + "\ n" return review_req

Nel schedule_review_request metodo, creare il contenuto dell'email di richiesta di revisione che verrà inviato al revisore. Il contenuto dell'email conterrà le informazioni richieste affinché il revisore riveda il commit del codice. Modifica il schedule_review_request come mostrato:

def schedule_review_request (commit): date = time.strftime ("% Y-% m-% d") per il commit in commit: reviewer = select_reviewer (commit.Author, project_members) subject = date + "Code Review [commit:" + commit.Id + "]" body = "Hello" "+ reviewer +" ", sei stato selezionato per rivedere il codice per commit \ n" body + = "fatto da" "+ commit.Author +" '. \ n "body + =" \ n "body + = format_review_commit (commit) corpo di stampa

Salvare le modifiche precedenti ed eseguire il programma di pianificazione Python.

python scheduler.py -n 25 -p "project_x"

Dovresti essere in grado di vedere un risultato simile a quello mostrato di seguito:

Invio tramite posta elettronica della richiesta di revisione del codice

Crea un metodo chiamato invia una email che invierà per e-mail la richiesta di revisione con l'oggetto e il contenuto richiesti. Farai uso di smtplib modulo per inviare le e-mail. Importare smptlib nel scheduler.py file:

importa smtplib

Definire i dettagli del server di posta elettronica insieme alle variabili pubbliche:

FROM_EMAIL = "[email protected]" FROM_PWD = "la tua password" SERVER = "smtp.gmail.com" PORT = 587

Crea un metodo chiamato invia una email che invierà l'e-mail all'indirizzo specificato. Ecco come invia una email il codice sarebbe:

def send_email (to, subject, body): header = "From:" + FROM_EMAIL + "\ n" header + = "A:" + a + "\ n" header + = "Oggetto:" + subject + "\ n "header + =" \ n "header + = body print" ** Invio di email a "" + a + "'" mail_server = smtplib.SMTP (SERVER, PORT) mail_server.starttls () mail_server.login (FROM_EMAIL, FROM_PWD) mail_server.sendmail (FROM_EMAIL, to, header) mail_server.quit ()

Come visto nel codice sopra, hai creato il smtp server che utilizza il server Gmail e il numero di porta. Usando il nome utente e la password definiti, hai effettuato l'accesso all'account e-mail e hai inviato l'e-mail al destinatario.

Modifica il schedule_review_request metodo per inviare l'e-mail invece di stampare il contenuto dell'email sul terminale.

def schedule_review_request (commit): date = time.strftime ("% Y-% m-% d") per il commit in commit: reviewer = select_reviewer (commit.Author, project_members) subject = date + "Code Review [commit:" + commit.Id + "]" body = "Hello" "+ reviewer +" ", sei stato selezionato per rivedere il codice per commit \ n" body + = "fatto da" "+ commit.Author +" '. \ n "body + =" \ n "body + = format_review_commit (commit) send_email (revisore, oggetto, corpo)

Salva le modifiche precedenti. Modifica il config.json file per includere un indirizzo email valido che puoi controllare. Esegui lo scheduler usando il seguente comando:

python scheduler.py -n 30 -p "project_x"

Dovresti essere in grado di vedere il seguente output sul terminale:

Verificare l'indirizzo e-mail per vedere la richiesta di revisione del codice inviata dallo scheduler di revisione del codice.

Avvolgendolo

In questa parte della serie di utilità di revisione del codice Python, hai raccolto le informazioni di commit in un elenco. L'elenco di commit è stato ulteriormente iterato per formattare la richiesta di revisione. Gli sviluppatori casuali sono stati selezionati per inviare la richiesta di revisione del codice.

Nella parte successiva di questa serie, vedrai come seguire la richiesta di revisione del codice.

Il codice sorgente di questo tutorial è disponibile su GitHub.

.