src/git_stats/author.py

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