1.Tout d'abord 2. module de sous-processus 3. Créez un objet Commit 4. Analyser le journal de validation
Avez-vous déjà voulu créer un module en utilisant git en Python?
J'ai. C'est un projet en cours.
Donc, cette fois, j'écrirai avec le thème de ** Parsing Git's commit log with Python **.
Pour utiliser un module qui utilise git, vous devez d'abord ** obtenir la sortie de la commande git **.
Créons donc une fonction git '' qui récupère la sortie de la commande git en utilisant le module subprocess`.
git.py
from subprocess import Popen, PIPE
class GitError(BaseException):
"""Se produit lorsqu'une erreur se produit dans le résultat de l'acquisition de la fonction git"""
pass
def git(cmd, *args):
"""Récupère et renvoie le résultat de l'exécution de git"""
proc = Popen(
("git", cmd) + args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
out, err = proc.communicate()
if len(err) == 0:
return out[:-1]
else:
raise GitError(err)
Pour expliquer brièvement le contenu de la fonction (numéros de ligne entre parenthèses), importez la classe Popen et les variables PIPE du module de sous-processus (1), et définissez le processus de git avec la fonction Popen. (8 ~ 9)
Exécute le processus défini par la méthode ** commun ** de la classe Popen. Lorsqu'ils sont exécutés **, le résultat de sortie de la sortie standard et le résultat de sortie de l'erreur standard sont renvoyés dans un taple **, de sorte que le résultat de sortie de la sortie standard et le résultat de sortie de l'erreur standard sont acquis avec la variable out et la variable err. .. (10) Après cela, vérifiez s'il y a une erreur standard, et si oui, GitError
Élevez la classe. Sinon, le résultat de sortie standard est renvoyé tel quel.
C'est à peu près comme ça. Ensuite, récupérons le journal de validation en utilisant cette fonction git.
Avant cela, j'ai quelque chose à faire. Créez une classe de validation ** qui stocke les journaux de validation analysés **.
commit.py
class Commit(object):
"""Valider la valeur de hachage, l'auteur, la date et l'heure, le commentaire de validation, la classe pour contenir les données fusionnées en cas de fusion"""
def __init__(self, commithash, author, date, comment, merge_data=None):
self.commithash = commithash
self.author = self._get_user_obj(author)
self.date = date
self.comment = comment
self.merge_data = merge_data
def _get_user_obj(self, author_string):
if " " in author_string:
lines = author_string.split(" ")
name = lines[0]
email = lines[1][1:-1]
return User(name, email)
else:
return User(author_string)
def __repr__(self):
return "CommitObject(%s)" % self.commithash
Créez une classe qui hérite de la classe intégrée ʻObject`.
Les données que l'objet Commit veut conserver sont
Ceux-ci sont. Ainsi, la méthode __init__ prend simplement chacun comme argument et valorise la classe Self.
La méthode _get_user_obj insère à l'origine les informations de validation dans l'objet Commit avec les données ʻAuthor <[email protected]> `. C'est donc votre travail de diviser cette chaîne en informations «Auteur» et «Email». La classe qui contient ces deux informations est la classe ** User **.
user.py
class User(object):
"""Conservez le nom et l'adresse e-mail du committer"""
def __init__(self, name, email=None):
self.name = name
self.email = email
def __repr__(self):
return "UserObject(name='%s', email='%s')" % (
self.name, self.email)
def __str__(self):
return self.__repr__()
Ce cours est facile. C'est juste une classe pour l'auteur de tenir un e-mail.
Commençons par le code en premier.
parser.py
from dateutil import parser as dateparser
def get_commits():
"""Récupérez le journal de validation du shell, faites-en un objet Commit et renvoyez-le sous forme de liste"""
commits = []
commits_string = git("log")
# analyzing
commitlines = commits_string.split("\n\n")
commits_string_list = []
while 0 < len(commitlines):
commits_string_list.append(
"\n".join(commitlines[0:2]))
commitlines = commitlines[2:]
# parse
for commitline in commits_string_list:
commitdata = parse_commit(commitline)
commits.append(
Commit(**commitdata))
return commits
def parse_commit():
"""Analyse le journal de validation obtenu à partir du shell et renvoie la valeur de hachage de validation, le validateur, la date / heure, le commentaire de validation et la source et la destination si fusionnées"""
commitlines = commitstring.split("\n")
# 1 row
commithash = commitlines[0].replace("commit ","")
# 2 row
merge_source = merge_dest = None
author = None
if "Merge" in commitlines[1]:
# parse merge data
merge_source = commitlines[1].split(" ")[1]
merge_dest = commitlines[1].split(" ")[2]
else:
# parse author
author = commitlines[1].replace("Author: ","")
# 3 row
if "Author" in commitlines[2]:
# parse author
author = commitlines[2].replace("Author: ","")
else:
# parse date
date = dateparser.parse(commitlines[2].replace("Date: ",""))
# 4 row
if "Date" in commitlines[3]:
# parse date
date = dateparser.parse(commitlines[3].replace("Date: ",""))
else:
# parse comment
comment = " ".join([i.strip() for i in commitlines[3:]])
# 5 row
if "Merge" in commitlines[1]:
# comment -> under 4 row
comment = " ".join([i.strip() for i in commitlines[4:]])
return {"commithash": commithash,
"merge_data": (merge_source, merge_dest) if merge_source != None else None,
"author" : author,
"date" : date,
"comment" : comment}
commit c92b57f9418eddf75cd96e268bac616aaecd95c4
Merge: 46a71a7 137a6ca
Author: alice <[email protected]>
Date: Sat Nov 17 01:00:14 2012 +0900
Merge branch 'rewrite'
Conflicts:
commithash.py
Un journal de validation normal ressemble à celui ci-dessus. (Version avec fusion) L'analyseur ci-dessus est un script qui évalue ce journal de validation ligne par ligne et obtient la valeur de hachage et les données de fusion de la validation, la date / heure dans le valideur et le commentaire de validation. C'est très ennuyeux d'expliquer ligne par ligne, alors laissez-moi l'omettre ... Eh bien, vous pouvez le comprendre en lisant le code. Je n'ai rien fait d'aussi avancé.
La façon dont vous gérez ces données de validation dépend de vous! !!
Recommended Posts