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