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     for author, activity in allActivity.iteritems():
 164       result.append(author + ":")
 165       keys = activity.keys()
 166       keys.sort()
 167
 168       for key in keys:
 169         value = activity[key]
 170         result.append("\t" + str(value) + " = " + str(key))
 171
 172       result.append("")
 173
 174     return result
 175
 176   if not allActivity.has_key(id):
 177     result.append("Unknown author " + id)
 178     result.append("Known authors:")
 179     result.extend(allActivity.keys())
 180
 181     return result
 182
 183   activity = allActivity[id]
 184
 185   keys = activity.keys()
 186   keys.sort()
 187
 188   for key in keys:
 189     value = activity[key]
 190     result.append(str(value) + " = " + str(key))
 191
 192   return result
 193
 194 def aggregateActivity(idFilter, field, startFrom):
 195   """Aggregates the activity for all developers
 196
 197   Args:
 198     idFilter: The id to filter on, if None all developers will be shown.
 199     field: The field to filter on.
 200   """
 201
 202   git = Repo(".").git
 203   result = git.log("--numstat", startFrom, "--", pretty="format:%" + field)
 204
 205   log = result.splitlines(True)
 206   allActivity = activityInArea(log)
 207
 208   aggregatedActivity = {}
 209
 210   for _, activityByPath in allActivity.iteritems():
 211     for path, activity in activityByPath.iteritems():
 212       if not aggregatedActivity.has_key(path):
 213         aggregatedActivity[path] = Activity()
 214
 215       known = aggregatedActivity[path]
 216
 217       result = Activity()
 218       result.added = known.added + activity.added
 219       result.deleted = known.deleted + activity.deleted
 220       result.count = known.count + activity.count
 221
 222       aggregatedActivity[path] = result
 223
 224   result = []
 225
 226   keys = aggregatedActivity.keys()
 227   keys.sort()
 228
 229   for key in keys:
 230     value = aggregatedActivity[key]
 231     result.append(str(value) + " = " + str(key))
 232
 233   return result
 234
 235 def _checkOptions(parser, options):
 236   """Checks the specified options and uses the parser to indicate errors
 237
 238   Args:
 239     parser: The parser to use to signal when the options are bad.
 240     options: The options to check.
 241   """
 242
 243   opts = [options.aggregate, options.developer, options.file, options.everyone]
 244
 245   if not parse.isUnique(opts):
 246     parser.error("Please choose exactly one mode")
 247
 248   if options.file:
 249     try:
 250       parse.check_file(value=options.file, relative=options.relative)
 251     except OptionValueError, e:
 252       parser.error(e)
 253
 254
 255 def dispatch(*args):
 256   """Dispatches author related commands
 257   """
 258
 259   progname = os.path.basename(sys.argv[0]) + " author"
 260
 261   parser = OptionParser(option_class=parse.GitOption, prog=progname)
 262
 263   parser.add_option(
 264       "-a", "--aggregate",
 265       action="store_true",
 266       help="aggregate the results")
 267
 268   parser.add_option(
 269       "-e", "--everyone",
 270       action="store_true",
 271       help="show the activity of all developers")
 272
 273   parser.add_option(
 274       "-d", "--developer",
 275       help="the id to filter on")
 276
 277   parser.add_option(
 278       "-f", "--file",
 279       help="the file to filter on")
 280
 281   parser.add_option(
 282       "-i", "--id",
 283       help="the one/two letter identifier specifying which field to use as id")
 284
 285   parser.add_option(
 286       "-s", "--start-from",
 287       type="commit",
 288       metavar="COMMIT",
 289       help="the commit to start logging from")
 290
 291   parser.add_option(
 292       "-r", "--relative",
 293       action="store_true",
 294       help="paths are relative to the current directory")
 295
 296   parser.set_default("id", "ae")
 297   parser.set_default("start_from", "HEAD")
 298   parser.set_default("relative", False)
 299
 300   (options, args) = parser.parse_args(list(args))
 301
 302   _checkOptions(parser, options)
 303
 304   if options.aggregate:
 305     result = aggregateActivity(options.developer, options.id, options.start_from)
 306   elif options.developer or options.everyone:
 307     result = activity(options.developer, options.id, options.start_from)
 308   elif options.file:
 309     activity_for_file = activityInFile( options.file,
 310                                         options.id,
 311                                         options.start_from,
 312                                         options.relative)
 313
 314     result = []
 315
 316     for key, value in activity_for_file.iteritems():
 317       result.append(key + ": " + str(value))
 318
 319   for line in result:
 320     print(line)
 321