src/git_stats/author.py

   1 #!/usr/bin/env python
   2
   3 import operator
   4 import os
   5 import sys
   6
   7 from optparse import OptionParser, OptionValueError
   8 from git import Repo
   9
  10 from git_stats import parse
  11
  12 class Activity:
  13   """Simple storage class containing stats on the activity in one file."""
  14
  15   def __init__(self):
  16     self.count = 0
  17     self.added = 0
  18     self.deleted = 0
  19     self.id = []
  20
  21   def __str__(self):
  22     return ("%4d: %5d+ %5d- %5d~" %
  23         (self.count, self.added, self.deleted, self.added-self.deleted))
  24
  25 def activityInArea(log):
  26   """Parses the specified file containing commit logs.
  27   The output is expected to be in the format described below:
  28   [
  29     [<id>\n]+
  30     [<lines added>\t<lines deleted>\t<path>]+
  31     \n
  32   ]+
  33
  34   Params:
  35     log: The log formatted as described above.
  36
  37   Returns:
  38     A dictionary containing activity per author is returned.
  39     Each author contains a dictionary with activity per path.
  40     Each path contains one Activity object with the aggregated results.
  41   """
  42
  43   # Create a dict to store the activity stats per path
  44   activityByAuthor = {}
  45
  46   # Create a place to store the result in
  47   activities = []
  48   ids = []
  49
  50   i = 0
  51
  52   # Parse all the lines in the file
  53   for line in log:
  54     i += 1
  55
  56     # Split the line at the tab and store the data
  57     splitline = line.split('\t')
  58     size = len(splitline)
  59     length = len(line.lstrip())
  60
  61     # There is something on this line, but it contains no separator
  62     if size == 1 and length > 0:
  63       # Get the id address minus the newline
  64       ids.append(line[:-1])
  65     elif size == 3:
  66       activity = Activity()
  67       activity.id = ids
  68
  69       try:
  70         addpart = splitline[0]
  71         deletepart = splitline[1]
  72
  73         if addpart == '-':
  74           addpart = 0
  75
  76         if deletepart == '-':
  77           deletepart = 0
  78
  79         activity.added = int(addpart)
  80         activity.deleted = int(deletepart)
  81       except ValueError, e:
  82         print("On line '%d', could not convert number: %s" % (i,str(e)))
  83
  84       activity.path = splitline[2][:-1]
  85       activities.append(activity)
  86     elif length == 0:
  87       for activity in activities:
  88         for author in activity.id:
  89           if not author in activityByAuthor:
  90             activityByAuthor[author] = {}
  91
  92           activityByPath = activityByAuthor[author]
  93
  94           # If we have not encountered this path, create an entry
  95           if not activity.path in activityByPath:
  96             addme = Activity()
  97             activityByPath[activity.path] = addme
  98
  99           known = activityByPath[activity.path]
 100
 101           result = Activity()
 102           result.added = known.added + activity.added
 103           result.deleted = known.deleted + activity.deleted
 104           result.count = known.count + 1
 105
 106           # Store it under it's path
 107           activityByPath[activity.path] = result
 108
 109           # Store it under it's author
 110           activityByAuthor[author] = activityByPath
 111
 112       # Create a fresh activity to store the next round in
 113       activities = []
 114       ids = []
 115     else:
 116       print("Cannot parse line %d." % i)
 117
 118   # Return the result
 119   return activityByAuthor
 120
 121 def activityInFile(path, id, start_from, relative):
 122   """Shows the activity for the file in the current repo.
 123
 124   Params:
 125     path: The path to filter on.
 126     id: The id of the developer to show in the result.
 127     startfrom: The commit to start logging from.
 128     relative: Treat path as relative to the current working directory.
 129  """
 130
 131   git = Repo(".").git
 132
 133   result = git.log(start_from, "--", path, pretty="format:%" + id, with_keep_cwd=relative)
 134   activity = result.split('\n')
 135
 136   result = {}
 137
 138   for line in activity:
 139     # Create an entry if there was none for this author yet
 140     if not line in result:
 141       result[line] = 0
 142
 143     result[line] += 1
 144
 145   return result
 146
 147 def activity(id, field, start_from):
 148   """Shows the activity for the specified developer in the current repo.
 149
 150   Params:
 151     id: The id of the developer, as specified by field.
 152     field: The field to filter on.
 153     startfrom: The commit to start logging from.
 154   """
 155
 156   git = Repo(".").git
 157   result = git.log("--numstat", start_from, "--", pretty="format:%" + field)
 158
 159   log = result.splitlines(True)
 160   allActivity = activityInArea(log)
 161
 162   result = []
 163
 164   if not id:
 165     for author in sorted(allActivity):
 166       activity = allActivity[author]
 167       result.append(author + ":")
 168
 169       for key in sorted(activity):
 170         value = activity[key]
 171         result.append("\t%s = %s" % (str(value), str(key)))
 172
 173       result.append("")
 174
 175     return result
 176
 177   if not id in allActivity:
 178     result.append("Unknown author " + id)
 179     result.append("Known authors:")
 180     result.extend(allActivity.keys())
 181
 182     return result
 183
 184   activity = allActivity[id]
 185
 186   for key in sorted(activity):
 187     value = activity[key]
 188     result.append("%s = %s" % (str(value), str(key)))
 189
 190   return result
 191
 192 def aggregateActivity(id_filter, field, start_from):
 193   """Aggregates the activity for all developers
 194
 195   Args:
 196     id_filter: The id to filter on, if None all developers will be shown.
 197     field: The field to filter on.
 198   """
 199
 200   git = Repo(".").git
 201   result = git.log("--numstat", start_from, "--", pretty="format:%" + field)
 202
 203   log = result.splitlines(True)
 204   allActivity = activityInArea(log)
 205
 206   aggregatedActivity = {}
 207
 208   for _, activityByPath in allActivity.iteritems():
 209     for path, activity in activityByPath.iteritems():
 210       if not path in aggregatedActivity:
 211         aggregatedActivity[path] = Activity()
 212
 213       known = aggregatedActivity[path]
 214
 215       result = Activity()
 216       result.added = known.added + activity.added
 217       result.deleted = known.deleted + activity.deleted
 218       result.count = known.count + activity.count
 219
 220       aggregatedActivity[path] = result
 221
 222   result = []
 223
 224   for key in sorted(aggregatedActivity):
 225     value = aggregatedActivity[key]
 226     result.append("%s = %s" % (str(value), str(key)))
 227
 228   return result
 229
 230 def _checkOptions(parser, options):
 231   """Checks the specified options and uses the parser to indicate errors
 232
 233   Args:
 234     parser: The parser to use to signal when the options are bad.
 235     options: The options to check.
 236   """
 237
 238   opts = [options.aggregate, options.developer, options.file, options.everyone]
 239
 240   if not parse.isUnique(opts, at_least_one=True):
 241     parser.error("Please choose exactly one mode")
 242
 243   if options.file:
 244     try:
 245       parse.checkFile(value=options.file, relative=options.relative)
 246     except OptionValueError, e:
 247       parser.error(e)
 248
 249
 250 def dispatch(*args):
 251   """Dispatches author related commands
 252   """
 253
 254   progname = os.path.basename(sys.argv[0]) + " author"
 255
 256   parser = OptionParser(option_class=parse.GitOption, prog=progname)
 257
 258   parser.add_option(
 259       "-a", "--aggregate",
 260       action="store_true",
 261       help="aggregate the results")
 262
 263   parser.add_option(
 264       "-e", "--everyone",
 265       action="store_true",
 266       help="show the activity of all developers")
 267
 268   parser.add_option(
 269       "-d", "--developer",
 270       help="the id to filter on")
 271
 272   parser.add_option(
 273       "-f", "--file",
 274       help="the file to filter on")
 275
 276   parser.add_option(
 277       "-i", "--id",
 278       help="the one/two letter identifier specifying which field to use as id")
 279
 280   parser.add_option(
 281       "-s", "--start-from",
 282       type="commit",
 283       metavar="COMMIT",
 284       help="the commit to start logging from")
 285
 286   parser.add_option(
 287       "-r", "--relative",
 288       action="store_true",
 289       help="paths are relative to the current directory")
 290
 291   parser.set_default("id", "ae")
 292   parser.set_default("start_from", "HEAD")
 293   parser.set_default("relative", False)
 294
 295   (options, args) = parser.parse_args(list(args))
 296
 297   _checkOptions(parser, options)
 298
 299   if options.aggregate:
 300     result = aggregateActivity(options.developer, options.id, options.start_from)
 301   elif options.developer or options.everyone:
 302     result = activity(options.developer, options.id, options.start_from)
 303   elif options.file:
 304     activity_for_file = activityInFile( options.file,
 305                                         options.id,
 306                                         options.start_from,
 307                                         options.relative)
 308
 309     result = []
 310
 311     for key, value in sorted(activity_for_file.iteritems(), reverse=True,
 312                              key=operator.itemgetter(1)):
 313       result.append("%s: %s" % (key, str(value)))
 314
 315   for line in result:
 316     print(line)
 317