Advertisement
  1. Code
  2. Python

Création d'un planificateur de révision du code Python: envoi de demandes de révision

Scroll to top
Read Time: 9 min
This post is part of a series called Building a Python Code Review Scheduler.
Building a Python Code Review Scheduler: Processing Log
Building a Python Code Review Scheduler: Keeping the Review Information

French (Français) translation by New Lune (you can also view the original English article)

Dans la première partie de la série de tutoriels, vous avez vu comment configurer le projet et ses configurations requises. Vous avez traité les journaux git du projet et les avez imprimés dans le terminal. Dans cette partie, nous allons passer au prochain niveau et envoyer les demandes de révision du code.

Commençons

Commencez par cloner le code source de la première partie de la série de tutoriels.

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

Une fois que vous avez cloné le référentiel, accédez au répertoire du projet CodeViewer et essayez d'exécuter la commande suivante dans le terminal.

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

Il devrait imprimer les identifiants de validation, la date de validation et l'auteur de validation dans le terminal.

Collecter tous les engagements avec les détails

Vous obtiendrez les détails de validation tout en itérant les journaux de validation. Maintenant, vous devez collecter les détails de validation et les stocker dans une liste, afin que vous puissiez les annuler plus tard pour envoyer la demande de révision du code. Pour collecter les détails de validation, commencez par créer une classe Commit avec les membres requis comme indiqué:

1
# -------------------------------------------

2
#

3
# Commit class to contain commit related info

4
#

5
# -------------------------------------------

6
class Commit:
7
    def __init__(self, Id, Author, Date):
8
        self.Id = Id;
9
        self.Author = Author;
10
        self.Date = Date;

Tout en itérant les journaux de commit dans la méthode process_commits, créez une instance Commit pour conserver les détails de validation.

Dans la méthode process_commits, définissez quelques variables comme indiqué:

1
commitId = ''
2
author = ''
3
date = ''
4
commits = []

Vous collecterez chaque détail de validation dans une liste Python appelée commits. Pendant la lecture des journaux de validation, la première fois que l'identifiant de validation est détecté, conservez l'Id de validation et laissez les dates et les variables d'auteur, car il s'agit d'une nouvelle validation. Modifiez le code de la méthode process_commits après la vérification des mots clés de validation, comme illustré:

1
if line.startswith('commit '):
2
    author = ''
3
    date = ''
4
    commitId = line[7:]

Lorsque l'Id de validation n'est pas nulle, c'est à ce moment-là que les détails de validation ont été collectés et il est temps d'ajouter le commit à la liste des commit. Ajoutez la ligne de code suivante au code ci-dessus:

1
if line.startswith('commit '):
2
    if commitId <> "":
3
        commits.append(Commit(commitId, author, date))
4
    author = ''
5
    date = ''
6
    commitId = line[7:]

Modifiez la vérification des mots clés de l'Author et la vérification du mot-clé Date pour conserver les détails de validation respectifs dans l'auteur et les variables de la date.

1
if line.startswith('Author:'):
2
    if(re.search('\<(.*?)\>',line)):
3
        author = re.search('\<(.*?)\>',line).group(1)
4
if line.startswith('Date:'):
5
    date = line[5:]

Maintenant, s'il n'y a qu'un seul commit dans le code source, les détails seront enregistrés dans la liste de validation. Ajoutez donc le code suivant à la fin de la boucle pour gérer ce scénario.

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

Voici la méthode complète de process_commits qui recueille les détails de validation et renvoie une liste d'engagements.

1
# ----------------------------------

2
#

3
# Process the git log 

4
#

5
# ----------------------------------

6
7
def process_commits():
8
    cmd = "cd " + project + "; git log --all --since=" + str(no_days) + ".day --name-status"
9
    response = execute_cmd(cmd)
10
    commitId = ''
11
    author = ''
12
    date = ''
13
    commits = []
14
15
    for line in response.splitlines():
16
        if line.startswith('commit '):
17
            if commitId <> "":
18
                commits.append(Commit(commitId, author, date))
19
            author = ''
20
            date = ''
21
            commitId = line[7:]
22
        if line.startswith('Author:'):
23
            if(re.search('\<(.*?)\>',line)):
24
                author = re.search('\<(.*?)\>',line).group(1)
25
        if line.startswith('Date:'):
26
            date = line[5:]
27
28
    if commitId <> "":
29
        commits.append(Commit(commitId, author, date))
30
31
    return commits

Planification d'une demande d'examen de code

Vous avez les détails de validation collectés à partir du journal du projet. Vous devez sélectionner les développeurs aléatoires pour envoyer la demande de révision du code. Dans le fichier config.json, ajoutons les développeurs associés au projet qui peuvent examiner le code. Voici le fichier config.json modifié:

1
[{
2
    "name": "project_x",
3
    "git_url": "https://github.com/royagasthyan/project_x",
4
    "members": [
5
        "royagasthyan",
6
        "hari",
7
        "sam",
8
        "shaun"
9
    ]
10
}, {
11
    "name": "project_y",
12
    "git_url": "https://github.com/royagasthyan/project_y",
13
    "members": [
14
        "royagasthyan",
15
        "hari",
16
        "sam",
17
        "shaun"
18
    ]
19
}]

Lisez les informations du développeur relatives à un projet particulier. Définissez une variable publique appelée project_members.

1
project_members = ''

Lors de la lecture des configurations du projet, remplissez les détails du membre du projet dans la variable de la liste des project_members.

1
#

2
# Read the scheduler config file

3
#

4
with open('config.json') as cfg_file:
5
    main_config = json.load(cfg_file)
6
7
for p in main_config:
8
    if p['name'] == project:
9
        project_url = p['git_url']
10
        project_members = p['members']
11
    break

Maintenant, vous avez la liste des développeurs liée à un projet particulier dans la variable project_members.

Définissez une méthode appelée schedule_review_request que vous appelez pour planifier la demande de révision correspondant à chaque engagement de projet. La demande de révision sera envoyée à un développeur aléatoire à partir de la liste project_members, à l'exclusion de l'auteur de la validation.

Créez une méthode appelée select_reviewer pour sélectionner le développeur aléatoire à partir de la liste project_members. Pour sélectionner des développeurs aléatoires dans la liste, vous utiliserez le module random Python. Importez le module random Python.

1
import random

Voici comment le code devrait être:

1
# -----------------------------------------

2
#

3
# Method to select random reviewer

4
#

5
# -----------------------------------------

6
7
def select_reviewer(author, group):
8
    if author in group:
9
        group.remove(author)
10
    reviewer = random.choice(group)
11
    return reviewer

Comme on l'a vu dans le code ci-dessus, l'auteur de la validation a été supprimé de la liste des développeurs avant de sélectionner les développeurs aléatoires pour examiner le code. Pour sélectionner des développeurs aléatoires dans la liste, vous avez utilisé la méthode random.choice du module random.

Dans la méthode schedule_review_request, répétez par chaque commit de la liste des commit. Pour chaque validation, sélectionnez un développeur aléatoire autre que l'auteur du commit pour envoyer la demande de révision. Voici comment le code devrait être:

1
def schedule_review_request(commits):
2
    for commit in commits:
3
        reviewer = select_reviewer(commit.Author, project_members)

Formatez la demande de révision du code

Vous avez sélectionné les développeurs aléatoires pour envoyer la demande de révision du code. Avant d'envoyer la demande de révision, vous devez la formater avec des détails sur la demande de révision. Définissez une méthode appelée format_review_commit qui formatera la demande de révision du code. Voici comment le code devrait être:

1
def format_review_commit(commit):
2
    review_req = ""
3
    review_req += "URL:     " + project_url + '/commit/' +  commit.Id + "\n"
4
    review_req += "Commit:  " + commit.Id + "\n"
5
    review_req += "Author:  " + commit.Author + "\n"
6
    review_req += "Date:    " + commit.Date + "\n"
7
    return review_req

Dans la méthode schedule_review_request, créez le contenu du courrier électronique de demande de révision qui sera envoyé au relecteur. Le contenu du courrier électronique contiendra les informations requises pour que l'évaluateur révise le code commit. Modifiez le message schedule_review_request comme indiqué:

1
def schedule_review_request(commits):
2
    date = time.strftime("%Y-%m-%d")
3
    
4
    for commit in commits:
5
        reviewer = select_reviewer(commit.Author, project_members)
6
        subject = date + " Code Review [commit:" + commit.Id + "]"
7
        body = "Hello '" + reviewer + "', you have been selected to review the code for commit\n"
8
        body += "done by '" + commit.Author + "'.\n"
9
        body += "\n"
10
        
11
        body += format_review_commit(commit)
12
13
        print body

Enregistrez les modifications ci-dessus et exécutez le programme Python scheduler.

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

Vous devriez pouvoir afficher une sortie similaire à celle ci-dessous:

Code Review Scheduler OutputCode Review Scheduler OutputCode Review Scheduler Output

Envoi électronique de la demande de révision du code

Créez une méthode appelée send_email qui vous enverra par courrier électronique la demande de révision avec le sujet et le contenu requis. Vous allez utiliser le module smtplib pour envoyer les emails. Importez smptlib dans le fichier scheduler.py:

1
import smtplib

Définissez les détails du serveur de messagerie ainsi que les variables publiques:

1
FROM_EMAIL      = "youemail@gmail.com"
2
FROM_PWD        = "your password"
3
SERVER     = "smtp.gmail.com"
4
PORT       = 587

Créez une méthode appelée send_email qui enverra l'adresse électronique à l'adresse spécifiée. Voici comment apparaitrait le code send_email:

1
def send_email(to, subject, body):
2
    header  = "From: " + FROM_EMAIL + "\n"
3
    header += "To: " + to + "\n"
4
    header += "Subject: " + subject + "\n"
5
    header += "\n"
6
    header += body
7
8
    print "** Sending email to '" + to + "'"
9
    
10
    
11
    mail_server = smtplib.SMTP(SERVER, PORT)
12
    mail_server.starttls()
13
    mail_server.login(FROM_EMAIL, FROM_PWD)
14
    mail_server.sendmail(FROM_EMAIL, to, header)
15
    mail_server.quit()

Comme on l'a vu dans le code ci-dessus, vous avez créé le serveur smtp à l'aide du serveur Gmail et du numéro de port. En utilisant le nom d'utilisateur et le mot de passe définis, vous vous êtes connecté au compte de messagerie et envoyé le courrier électronique au destinataire.

Modifiez la méthode schedule_review_request pour envoyer l'email au lieu d'imprimer le contenu du courrier électronique sur le terminal.

1
def schedule_review_request(commits):
2
    date = time.strftime("%Y-%m-%d")
3
    
4
    for commit in commits:
5
        reviewer = select_reviewer(commit.Author, project_members)
6
        subject = date + " Code Review [commit:" + commit.Id + "]"
7
        body = "Hello '" + reviewer + "', you have been selected to review the code for commit\n"
8
        body += "done by '" + commit.Author + "'.\n"
9
        body += "\n"
10
        
11
        body += format_review_commit(commit)
12
13
        send_email(reviewer,subject,body)

Enregistrez les modifications ci-dessus. Modifiez le fichier config.json pour inclure une adresse e-mail valide que vous pouvez vérifier. Exécutez le planificateur à l'aide de la commande suivante:

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

Vous devriez pouvoir voir la sortie suivante sur le terminal:

Code Review Request Sending OutputCode Review Request Sending OutputCode Review Request Sending Output

Vérifiez l'adresse e-mail pour voir la demande de révision du code envoyée par l'ordonnanceur de révision du code.

Finissons-en

Dans cette partie de la série Python Code Review Scheduler, vous avez collecté les informations de validation dans une liste. La liste de validation a également été émise pour formater la demande de révision. Les développeurs aléatoires ont été choisis pour envoyer la demande de révision du code.

Dans la prochaine partie de cette série, vous verrez comment suivre la demande de révision du code.

Le code source de ce tutoriel est disponible sur GitHub.

J'espère que vous avez apprécié cette partie. Faites-nous part de vos réflexions dans les commentaires ci-dessous.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.