src/git_stats/commit.py

   1 #!/usr/bin/env python
   2
   3 import os
   4 import copy
   5 import sys
   6 import re
   7
   8 from optparse import OptionParser, Option, OptionValueError
   9 from git import Git
  10
  11 def _logContains(log, regexp):
  12   """Traverses the specified log and searches for the specified regexp.
  13
  14   Params:
  15     log: The log to search through.
  16     regexp: The regexp to match for.
  17   """
  18
  19   matcher = re.compile(regexp)
  20
  21   isDiff = log[0].startswith("diff")
  22
  23   for line in log:
  24     # Skip anything that is not an addition or a removal
  25     if isDiff and not line.startswith("+") and not line.startswith("-"):
  26         continue
  27
  28     # If this line matches the regexp, accept
  29     if matcher.search(line):
  30       return True
  31
  32   # None of the lines matched, reject
  33   return False
  34
  35 def check_commit(option, opt, value):
  36   """Checks whether value is a valid rev and returns its hash
  37   """
  38
  39   git = Git(".")
  40   rev = git.rev_parse("--verify", value)
  41
  42   if not rev:
  43     raise OptionValueError("Unknown commit '" + value + "'")
  44
  45   return rev
  46
  47 class CommitOption(Option):
  48   """This parser understands a new type, "commit"
  49   """
  50
  51   TYPES = Option.TYPES + ("commit",)
  52   TYPE_CHECKER = copy.copy(Option.TYPE_CHECKER)
  53   TYPE_CHECKER["commit"] = check_commit
  54
  55 def prettyPrint(commits):
  56   """Pretty prints the specified commits with git log.
  57   """
  58   git = Git(".")
  59
  60   for commit in commits:
  61     # Enable raw output for the trailing newline, which is desired in this case
  62     result = git.log("-1", "--name-only", commit, with_raw_output=True)
  63     print(result)
  64
  65 def _makePathsRelative(paths):
  66   """Helper function that takes a list of paths and makes it relative
  67
  68   Args:
  69     paths: The paths to make relative.
  70
  71   Returns: A new lists in which the paths are relative to the working dir.
  72   """
  73
  74   result = []
  75
  76   git = Git(".")
  77
  78   # Get our 'distance' to the top
  79   prefix = git.rev_parse("--show-cdup")
  80
  81   prefix = prefix
  82
  83   # Make it relative
  84   for path in paths:
  85     result.append(os.path.join(prefix, path))
  86
  87   return result
  88
  89 def pathsTouchedBy(commit, ignoreAddedFiles):
  90   """Returns a list of paths touched by a specific commit.
  91
  92   Params:
  93     commit: A commit identifier as accepted by git-log.
  94     ignoreAddedFiles: When True newly added files are ignored.
  95
  96   Returns:
  97     A list of paths touched by the specified commit.
  98   """
  99
 100   git = Git(".")
 101
 102   # Enable raw output, we use the last empty line as delimiter
 103   result = git.diff_tree("--name-status", "--no-commit-id", "-r", commit, with_raw_output=True)
 104
 105   log = result.split('\n')
 106
 107   paths = []
 108
 109   for line in log:
 110     if len(line.lstrip()) == 0:
 111       continue
 112
 113     splitline = line.split('\t')
 114     if splitline[0] == 'A' and ignoreAddedFiles:
 115       continue
 116
 117     paths.append(splitline[1])
 118
 119   return paths
 120
 121 def commitsThatTouched(paths, relative=False):
 122   """Returns a list of commits that touch the specified paths.
 123
 124   Params:
 125     paths: A list of changed path relative to the current working dir.
 126     relative: Whether the paths are relative to the current directory.
 127
 128   Returns:
 129     A list of 40-character SHA's of the touched commits.
 130   """
 131
 132   if not paths:
 133     raise ValueError("No changed paths specified")
 134
 135   if not relative:
 136     relativePaths = _makePathsRelative(paths)
 137   else:
 138     relativePaths = paths
 139
 140   git = Git(".")
 141
 142   result = git.rev_list("HEAD", *relativePaths)
 143
 144   touched = result.split('\n')
 145
 146   return touched
 147
 148 def commitTouched(commit):
 149   """Shows what commit touched the same files as the specified commit.
 150   """
 151
 152   touched = pathsTouchedBy(commit, True)
 153
 154   touched = commitsThatTouched(touched)
 155
 156   prettyPrint(touched)
 157
 158 def commitmsgMatches(commit, regexp):
 159   """Returns whether the specified commit matches the specified regexp.
 160
 161   The commit message for the specified commit is searched, if a
 162   matching line is found, True is returned. Otherwise False is returned.
 163
 164   Params:
 165     commit: The commit whose commit msg is to be searched.
 166     regexp: The regexp to match against.
 167
 168   Returns: Whether the commit msg matches the specified regexp.
 169   """
 170
 171   git = Git(".")
 172
 173   result = git.cat_file("-p", commit)
 174
 175   log = result.split('\n')
 176
 177   # Skip the first lines, the commit msg doesn't begin till after these
 178   return _logContains(log[4:], regexp)
 179
 180 def hasParent(commit):
 181   """Checks if the specified commit has a parent
 182
 183   Args:
 184     commit: The commitish to check
 185
 186   Returns: False if the commitish doesn't have a parent,
 187     or if the committish is not a commit at all.
 188   """
 189
 190   git = Git(".")
 191
 192   hash = git.rev_parse("--verify", commit)
 193
 194   if not hash:
 195     return False
 196
 197   hash = hash + "^"
 198
 199   parent = git.rev_parse("--verify", hash)
 200
 201   if not parent:
 202     return False
 203
 204   return True
 205
 206 def commitdiffMatches(commit, regexp):
 207   """Returns whether the commit diff matches the specified regexp.
 208
 209   Params:
 210     commit: The commit whose commit diff is to be searched.
 211     regexp: The regexp to match against.
 212
 213   Returns: Whether the commit diff matches the specified regexp.
 214   """
 215
 216   git = Git(".")
 217
 218   if hasParent(commit):
 219     lhs = commit + "^"
 220   else:
 221     lhs = "--root"
 222
 223   result = git.diff_tree("-p", "-U0", lhs, commit)
 224
 225   log = result.split('\n')
 226
 227   return _logContains(log, regexp)
 228
 229 def commitList(logFilter=None, diffFilter=None):
 230   """
 231   """
 232
 233   git = Git(".")
 234
 235   result = git.rev_list("HEAD")
 236   commits = result.split('\n')
 237
 238   if not logFilter and not diffFilter:
 239     return commits
 240
 241   result = []
 242
 243   for commit in commits:
 244     addIt = True
 245
 246     if logFilter:
 247       if not commitmsgMatches(commit, logFilter):
 248         addIt = False
 249
 250     if diffFilter:
 251       if not commitdiffMatches(commit, diffFilter):
 252         addIt = False
 253
 254     if addIt:
 255       result.append(commit)
 256
 257
 258   return result
 259
 260
 261 def _isUnique(options, atLeastOne=False):
 262   """Checks if a list of options is unique
 263
 264   Args:
 265     options: The list of options to check
 266     atLeastOne: If set, when no optiosn are set, return False
 267   """
 268
 269   unique = False
 270
 271   for option in options:
 272     if option:
 273       # If we already found one, it's not unique for sure
 274       if unique:
 275         return False
 276       else:
 277         unique = True
 278
 279   # If there is only one, it's unique
 280   if unique:
 281     return True
 282
 283   # None found, so unique only if we don't require at least one
 284   return not atLeastOne
 285
 286 def _checkOptions(parser, options):
 287   """Checks the specified options and uses the parser to indicate errors
 288
 289   Args:
 290     parser: The parser to use to signal when the options are bad.
 291     options: The options to check.
 292   """
 293
 294   opts = [options.touched, options.log_contains, options.diff_contains, options.all]
 295
 296   if not _isUnique(opts, True):
 297     parser.error("Please choose exactly one mode")
 298
 299   if options.relative and not options.touched:
 300     parser.error("-r makes no sense without -t")
 301
 302 def dispatch(*args):
 303   """Dispatches commit related commands
 304   """
 305
 306   progname = os.path.basename(sys.argv[0]) + " commit"
 307
 308   parser = OptionParser(prog=progname)
 309
 310   parser.add_option(
 311       "-t", "--touches",
 312       dest="touched",
 313       action="store_true",
 314       help="show only commits that modify the specified files")
 315
 316   # Toy option, since we have git log for that
 317   parser.add_option(
 318       "-a", "--all",
 319       action="store_true",
 320       help="lists all commits on HEAD")
 321
 322   parser.add_option(
 323       "-l", "--log-contains",
 324       help="show only commits of which the log contains the specified regexp")
 325
 326   parser.add_option(
 327       "-d", "--diff-contains",
 328       help="show only commits of which the diff contains the specified regexp")
 329
 330   parser.add_option(
 331       "-r", "--relative",
 332       action="store_true",
 333       help="paths are relative to the current directory")
 334
 335   parser.set_default("touched", False)
 336   parser.set_default("relative", False)
 337
 338   (options, args) = parser.parse_args(list(args))
 339
 340   _checkOptions(parser, options)
 341
 342   if options.touched:
 343     result = commitsThatTouched(args, options.relative)
 344     prettyPrint(result)
 345
 346   if options.diff_contains or options.log_contains or options.all:
 347     result = commitList(diffFilter=options.diff_contains,
 348                         logFilter=options.log_contains)
 349     prettyPrint(result)
 350