src/git_stats/commit.py

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