src/git_stats/branch.py

   1 #!/usr/bin/env python
   2
   3 import os
   4 import sys
   5
   6 from optparse import OptionParser
   7 from git import Repo
   8
   9 from git_stats import parse
  10
  11 def prettyName(branch, pretty_names={}):
  12   """Looks up the name of a branch and returns it
  13
  14   Returns only the last part of the branchname.
  15
  16   Args:
  17     branch: The branch to print
  18     pretty_names: A dictionary with commits and their names
  19   """
  20
  21   if not pretty_names.has_key(branch):
  22     git = Repo(".").git
  23     name = git.describe("--all", branch)
  24     splitname = name.split('/')
  25     name = splitname[-1]
  26     pretty_names[branch] = name
  27   else:
  28     name = pretty_names[branch]
  29
  30   return name
  31
  32 class Metric:
  33   """This class represents a metric
  34
  35   It is meant to store arbitrary data related to a specific metric.
  36   """
  37
  38   def __init__(self):
  39     self.branch = ""
  40     self.commit = ""
  41     self.dilution = ""
  42
  43   def __str__(self):
  44     res = "Branch %s, dilution: %d." % \
  45         (prettyName(self.branch), self.dilution)
  46
  47     return res
  48
  49 def _bestMetric(metrics):
  50   """Finds the best metric from a set
  51
  52   Iterates the metrics and selects the ones with the lowest dilution.
  53   All the returned metrics are guaranteed to have the same dilution.
  54
  55   Args:
  56     metrics: The metrics to pick the best ones from.
  57
  58   Returns: A list with the best metrics.
  59   """
  60
  61   champs = []
  62
  63   # Find the best metric
  64   for metric in metrics:
  65     # Store the current value for easy access
  66     dilution = metric.dilution
  67
  68     # First element, set the minimum to the current
  69     if not champs:
  70       min = dilution
  71
  72     # Worse than our best, not interesting
  73     if dilution > min:
  74       continue
  75
  76     # Clear the old ones if we have a better minimum
  77     if dilution < min:
  78       champs = []
  79       min = dilution
  80
  81     champs.append(metric)
  82
  83   return min, champs
  84
  85 def _calculateDilution(target, start, parent_lists, global_memory, ignore=[]):
  86   """Calculates the dilution for the specified commit.
  87
  88   Args:
  89     target: The commit to calculate the dilution for.
  90     start: The initial metric information.
  91     parent_list: A dictionary with commits and their parents.
  92     global_memory: A dictionary with all commits and their parents.
  93     ignore: The parent commits of the target commit which should be ignored.
  94   """
  95
  96   metrics = []
  97
  98   memory = {}
  99   stack = []
 100   stack.append(start)
 101
 102   git = Repo(".").git
 103
 104   while stack:
 105     current = stack.pop()
 106
 107     # We found what we are looking for
 108     if target == current.commit:
 109       metrics.append(current)
 110       continue
 111
 112     # Ignore commits that are past the target
 113     if current.commit in ignore:
 114       continue
 115
 116     # If we already checked this commit, don't add it again
 117     if memory.has_key(current.commit):
 118       dilution = memory[current.commit]
 119       if dilution <= current.dilution:
 120         continue
 121
 122     if global_memory.has_key(current.commit):
 123       dilution = global_memory[current.commit]
 124       if dilution < current.dilution:
 125         continue
 126
 127     memory[current.commit] = current.dilution
 128     global_memory[current.commit] = current.dilution
 129
 130     parents = parent_lists[current.commit]
 131
 132     # Root commit, we can't go any further
 133     if not parents:
 134       continue
 135
 136     for parent in parents:
 137       if parent == parents[0]:
 138         newdilution = current.dilution
 139       else:
 140         newdilution = current.dilution + 1
 141
 142       next = Metric()
 143       next.commit = parent
 144       next.branch = current.branch
 145       next.dilution = newdilution
 146       stack.append(next)
 147
 148   if not metrics:
 149     return []
 150
 151   min, champs = _bestMetric(metrics)
 152   return champs
 153
 154 def debugPrint(debug, text):
 155   """Only print the specified text if debug is on
 156
 157   debug: Whether debug is on.
 158   text: The text to print
 159   """
 160
 161   if debug:
 162     print(text)
 163
 164 def getBranchMap(branches, cut_off_prefix=True):
 165   """
 166   """
 167
 168   git = Repo(".").git
 169
 170   branch_map = {}
 171
 172   for branch in branches:
 173     if cut_off_prefix:
 174       branch = branch[2:]
 175
 176     branch_hash = git.rev_parse(branch)
 177
 178     if branch_hash in branch_map.values():
 179       continue
 180
 181     branch_map[branch] = branch_hash
 182
 183   return branch_map
 184
 185 def getParentList(commits):
 186   """
 187   """
 188
 189   git = Repo(".").git
 190
 191   # First mine some data
 192   result = git.rev_list("--parents", *commits)
 193   data = result.split('\n')
 194
 195   parent_list = {}
 196
 197   for item in data:
 198     splitline = item.split(' ')
 199     first = splitline[0]
 200
 201     if len(splitline) == 1:
 202       parent_list[first] = []
 203     elif splitline[1] == '':
 204       parent_list[first] = []
 205     else:
 206       parent_list[first] = splitline[1:]
 207
 208   return parent_list
 209
 210 def belongsTo(commit,
 211               branch_map,
 212               parent_list,
 213               pretty_names={},
 214               debug=False,
 215               ignore_parents=False):
 216   """Returns which branches the specified commit belongs to
 217
 218   Args:
 219     commit: The commit to examine.
 220     branch_map: A dictionary of all refs and their hashes.
 221     parent_list: A dictionary with tuples of refs and their rev-lists.
 222     pretty_names: A dictionary with commits and their names
 223     debug: Whether to return debug information as well.
 224
 225   Returns: A list of branches that the commit belongs to.
 226   """
 227
 228   git = Repo(".").git
 229
 230   if commit in branch_map:
 231     debugPrint(debug, "Easy as pie, that's a branch head!")
 232     name = branch_map[commit]
 233     return [name]
 234
 235   metrics = []
 236
 237   if ignore_parents:
 238     result = git.rev_list(commit)
 239     ignore = set(result.split('\n'))
 240   else:
 241     ignore = []
 242
 243   debugPrint(debug, "Checking branches now:")
 244
 245   memory = {}
 246
 247   for branch_name, branch_hash in branch_map.iteritems():
 248     debugPrint(debug, branch_name)
 249
 250     metric = Metric()
 251     metric.branch = branch_hash
 252     metric.commit = branch_hash
 253     metric.dilution = 0
 254
 255     # Find the dilution for this branch
 256     metric = _calculateDilution(commit, metric, parent_list, memory, ignore)
 257     metrics = metrics + metric
 258
 259   debugPrint(debug, "Done.\n")
 260
 261   if debug:
 262     print("Listing found metrics:")
 263     for metric in metrics:
 264       print(metric)
 265
 266   min, champs = _bestMetric(metrics)
 267
 268   debugPrint(debug, "Done.\n")
 269
 270   results = []
 271
 272   if debug:
 273     results.append("The minimal dilution is: " + str(min))
 274
 275   # Loop over all the champs and get their name
 276   for metric in champs:
 277     results.append(prettyName(metric.branch, pretty_names))
 278
 279   return results
 280
 281 def branchcontains(branch, commit):
 282   """returns whether the specified branch contains the specified commit.
 283
 284   params:
 285     branch: the branch.
 286     commit: the commit.
 287
 288   returns:
 289     whether the branch contains the commit.
 290   """
 291
 292   git = git(".")
 293   arg = branch + ".." + commit
 294   result = git.rev_list(arg)
 295
 296   if result:
 297     # if there is a difference between these sets, the commit is not in the branch
 298     return false
 299   else:
 300     # there is no difference between the two, thus the branch contains the commit
 301     return true
 302
 303 def branchList(commitFilter, includeRemotes=False):
 304   """Returns all branches that contain the specified commit
 305
 306   Args:
 307     commitFilter: The commit to filter by.
 308     includeRemotes: Whether to search remote branches as well.
 309   """
 310
 311   git = Repo(".").git
 312
 313   args = []
 314
 315   if includeRemotes:
 316     args.append("-a")
 317
 318   if commitFilter:
 319     args.append("--contains")
 320     args.append(commitFilter)
 321
 322   result = git.branch(*args)
 323
 324   branches = result.split('\n')
 325
 326   result = []
 327
 328   for branch in branches:
 329     result.append(branch[2:])
 330
 331   return result
 332
 333 def dispatch(*args):
 334   """Dispatches branch related commands
 335   """
 336
 337   progname = os.path.basename(sys.argv[0]) + " branch"
 338
 339   parser = OptionParser(option_class=parse.GitOption, prog=progname)
 340
 341
 342   parser.add_option(
 343       "-b", "--belongs-to",
 344       type="commit",
 345       metavar="COMMIT",
 346       help="find out which branch the specified commit belongs to")
 347
 348   parser.add_option(
 349       "-d", "--debug",
 350       action="store_true",
 351       help="print debug information on the found metrics")
 352
 353   parser.add_option(
 354       "-c", "--contains",
 355       type="commit",
 356       help="show only branches that contain the specified commit")
 357
 358   parser.add_option(
 359       "-r", "--remotes",
 360       action="store_true",
 361       help="include remotes in the listing")
 362
 363   parser.set_default("debug", False)
 364   parser.set_default("remotes", False)
 365
 366   (options, args) = parser.parse_args(list(args))
 367
 368   if options.belongs_to:
 369     git = Repo(".").git
 370
 371     result = git.branch("-a", "--contains", options.belongs_to)
 372     branches = result.split('\n')
 373
 374     branch_map = getBranchMap(branches)
 375     parent_list = getParentList(branch_map.values())
 376
 377     result = belongsTo( options.belongs_to,
 378                         branch_map,
 379                         parent_list,
 380                         debug=options.debug)
 381   else:
 382     result = branchList(commitFilter=options.contains,
 383                         includeRemotes=options.remotes)
 384
 385   print("Matching branches:")
 386
 387   for branch in result:
 388     print(branch)
 389