mirror of
https://github.com/ejwa/gitinspector.git
synced 2024-09-20 23:11:29 +02:00
200 lines
6.5 KiB
Python
200 lines
6.5 KiB
Python
# coding: utf-8
|
|
#
|
|
# Copyright © 2012-2015 Ejwa Software. All rights reserved.
|
|
#
|
|
# This file is part of gitinspector.
|
|
#
|
|
# gitinspector is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# gitinspector is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with gitinspector. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
import datetime
|
|
import multiprocessing
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
from .localization import N_
|
|
from .changes import FileDiff
|
|
from . import comment, filtering, format, interval, terminal
|
|
|
|
NUM_THREADS = multiprocessing.cpu_count()
|
|
|
|
class BlameEntry(object):
|
|
rows = 0
|
|
skew = 0 # Used when calculating average code age.
|
|
comments = 0
|
|
|
|
__thread_lock__ = threading.BoundedSemaphore(NUM_THREADS)
|
|
__blame_lock__ = threading.Lock()
|
|
|
|
AVG_DAYS_PER_MONTH = 30.4167
|
|
|
|
class BlameThread(threading.Thread):
|
|
def __init__(self, useweeks, changes, blame_command, extension, blames, filename):
|
|
__thread_lock__.acquire() # Lock controlling the number of threads running
|
|
threading.Thread.__init__(self)
|
|
|
|
self.useweeks = useweeks
|
|
self.changes = changes
|
|
self.blame_command = blame_command
|
|
self.extension = extension
|
|
self.blames = blames
|
|
self.filename = filename
|
|
|
|
self.is_inside_comment = False
|
|
|
|
def __clear_blamechunk_info__(self):
|
|
self.blamechunk_email = None
|
|
self.blamechunk_is_last = False
|
|
self.blamechunk_is_prior = False
|
|
self.blamechunk_revision = None
|
|
self.blamechunk_time = None
|
|
|
|
def __handle_blamechunk_content__(self, content):
|
|
author = None
|
|
(comments, self.is_inside_comment) = comment.handle_comment_block(self.is_inside_comment, self.extension, content)
|
|
|
|
if self.blamechunk_is_prior and interval.get_since():
|
|
return
|
|
try:
|
|
author = self.changes.get_latest_author_by_email(self.blamechunk_email)
|
|
except KeyError:
|
|
return
|
|
|
|
if not filtering.set_filtered(author, "author") and not \
|
|
filtering.set_filtered(self.blamechunk_email, "email") and not \
|
|
filtering.set_filtered(self.blamechunk_revision, "revision"):
|
|
|
|
__blame_lock__.acquire() # Global lock used to protect calls from here...
|
|
|
|
if self.blames.get((author, self.filename), None) == None:
|
|
self.blames[(author, self.filename)] = BlameEntry()
|
|
|
|
self.blames[(author, self.filename)].comments += comments
|
|
self.blames[(author, self.filename)].rows += 1
|
|
|
|
if (self.blamechunk_time - self.changes.first_commit_date).days > 0:
|
|
self.blames[(author, self.filename)].skew += ((self.changes.last_commit_date - self.blamechunk_time).days /
|
|
(7.0 if self.useweeks else AVG_DAYS_PER_MONTH))
|
|
|
|
__blame_lock__.release() # ...to here.
|
|
|
|
def run(self):
|
|
git_blame_r = subprocess.Popen(self.blame_command, bufsize=1, stdout=subprocess.PIPE).stdout
|
|
rows = git_blame_r.readlines()
|
|
git_blame_r.close()
|
|
|
|
self.__clear_blamechunk_info__()
|
|
|
|
#pylint: disable=W0201
|
|
for j in range(0, len(rows)):
|
|
row = rows[j].decode("utf-8", "replace").strip()
|
|
keyval = row.split(" ", 2)
|
|
|
|
if self.blamechunk_is_last:
|
|
self.__handle_blamechunk_content__(row)
|
|
self.__clear_blamechunk_info__()
|
|
elif keyval[0] == "boundary":
|
|
self.blamechunk_is_prior = True
|
|
elif keyval[0] == "author-mail":
|
|
self.blamechunk_email = keyval[1].lstrip("<").rstrip(">")
|
|
elif keyval[0] == "author-time":
|
|
self.blamechunk_time = datetime.date.fromtimestamp(int(keyval[1]))
|
|
elif keyval[0] == "filename":
|
|
self.blamechunk_is_last = True
|
|
elif Blame.is_revision(keyval[0]):
|
|
self.blamechunk_revision = keyval[0]
|
|
|
|
__thread_lock__.release() # Lock controlling the number of threads running
|
|
|
|
PROGRESS_TEXT = N_("Checking how many rows belong to each author (Progress): {0:.0f}%")
|
|
|
|
class Blame(object):
|
|
def __init__(self, hard, useweeks, changes):
|
|
self.blames = {}
|
|
ls_tree_r = subprocess.Popen(["git", "ls-tree", "--name-only", "-r", interval.get_ref()], bufsize=1,
|
|
stdout=subprocess.PIPE).stdout
|
|
lines = ls_tree_r.readlines()
|
|
ls_tree_r.close()
|
|
|
|
for i, row in enumerate(lines):
|
|
row = row.strip().decode("unicode_escape", "ignore")
|
|
row = row.encode("latin-1", "replace")
|
|
row = row.decode("utf-8", "replace").strip("\"").strip("'").strip()
|
|
|
|
if FileDiff.is_valid_extension(row) and not filtering.set_filtered(FileDiff.get_filename(row)):
|
|
blame_command = filter(None, ["git", "blame", "--line-porcelain", "-w"] + \
|
|
(["-C", "-C", "-M"] if hard else []) +
|
|
[interval.get_since(), interval.get_ref(), "--", row])
|
|
thread = BlameThread(useweeks, changes, blame_command, FileDiff.get_extension(row), self.blames, row.strip())
|
|
thread.daemon = True
|
|
thread.start()
|
|
|
|
if hard:
|
|
Blame.output_progress(i, len(lines))
|
|
|
|
# Make sure all threads have completed.
|
|
for i in range(0, NUM_THREADS):
|
|
__thread_lock__.acquire()
|
|
|
|
@staticmethod
|
|
def output_progress(pos, length):
|
|
if sys.stdout.isatty() and format.is_interactive_format():
|
|
terminal.clear_row()
|
|
print(_(PROGRESS_TEXT).format(100 * pos / length), end="")
|
|
sys.stdout.flush()
|
|
|
|
@staticmethod
|
|
def is_revision(string):
|
|
revision = re.search("([0-9a-f]{40})", string)
|
|
|
|
if revision == None:
|
|
return False
|
|
|
|
return revision.group(1).strip()
|
|
|
|
@staticmethod
|
|
def get_stability(author, blamed_rows, changes):
|
|
if author in changes.get_authorinfo_list():
|
|
author_insertions = changes.get_authorinfo_list()[author].insertions
|
|
return 100 if author_insertions == 0 else 100.0 * blamed_rows / author_insertions
|
|
return 100
|
|
|
|
@staticmethod
|
|
def get_time(string):
|
|
time = re.search(r" \(.*?(\d\d\d\d-\d\d-\d\d)", string)
|
|
return time.group(1).strip()
|
|
|
|
def get_summed_blames(self):
|
|
summed_blames = {}
|
|
for i in self.blames.items():
|
|
if summed_blames.get(i[0][0], None) == None:
|
|
summed_blames[i[0][0]] = BlameEntry()
|
|
|
|
summed_blames[i[0][0]].rows += i[1].rows
|
|
summed_blames[i[0][0]].skew += i[1].skew
|
|
summed_blames[i[0][0]].comments += i[1].comments
|
|
|
|
return summed_blames
|
|
|
|
__blame__ = None
|
|
|
|
def get(hard, useweeks, changes):
|
|
global __blame__
|
|
if __blame__ == None:
|
|
__blame__ = Blame(hard, useweeks, changes)
|
|
|
|
return __blame__
|