src/git_stats/diff.py

   1 #!/usr/bin/env python
   2
   3 import collections
   4 import os
   5 import sys
   6
   7 from optparse import OptionParser
   8 from git import Repo
   9
  10 from git_stats import parse
  11
  12 class fileDiff:
  13   """A class to store the information of a file diff in.
  14
  15   Fields:
  16     afile: The file used as the left side of the diff.
  17     bfile: The file used as the right side of the diff.
  18     context: The context of this diff.
  19     apos: Where the left side of the diff starts.
  20     bpos: Where the right side of the diff starts.
  21     linesAdded: Which lines were added.
  22     linesDeleted: Which lines were deleted.
  23   """
  24
  25   def __init__(self, diffHeader):
  26     self.afile = ""
  27     self.bfile = ""
  28     self.context = ""
  29
  30     self.linesAdded = []
  31     self.linesDeleted = []
  32
  33     for line in diffHeader:
  34       if line.startswith("--- "):
  35         self.afile = line[4:]
  36
  37       if line.startswith("+++ "):
  38         self.bfile = line[4:]
  39
  40   def __str__(self):
  41     a = "Diff for '" + self.afile + "' (" + str(self.astart) + ") against '"
  42     b = self.bfile + "' (" + str(self.bstart) + ")" + self.context + "."
  43
  44     return a + b + '\n' + str(self.linesAdded) + '\n' + str(self.linesDeleted)
  45
  46 def getCommitDiff(commit, ignoreWhitespace=True, noContext=False):
  47   """Returns the commit diff for the specified commit
  48
  49   Params:
  50     commit: The commit to get the diff for.
  51
  52   Returns: The commit diff.
  53   """
  54
  55   git = Repo(".").git
  56   args = ["-p"]
  57
  58   if ignoreWhitespace:
  59     args.append("-w")
  60
  61   if noContext:
  62     args.append("-U0")
  63
  64   args.append(commit + "^")
  65   args.append(commit)
  66
  67   result = git.diff_tree(*args)
  68
  69   return result
  70
  71 def splitDiff(diff):
  72   """Splits off the diff in chunks, one for each file
  73
  74   Params:
  75     diff: The diff to split up.
  76
  77   Returns: A list containing a chunk per file.
  78   """
  79
  80   chunks = []
  81
  82   content = []
  83
  84   for line in diff:
  85     if line.startswith("diff"):
  86       if content:
  87         chunks.append(content)
  88
  89       content = []
  90
  91     content.append(line)
  92
  93   chunks.append(content)
  94
  95   return chunks
  96
  97 def _splitFileDiff(diff):
  98   """Splits a file diff into chunks, one per area.
  99
 100   Params:
 101     diff: The diff to split up.
 102
 103   Returns: The diff header and a list with all the chunks.
 104   """
 105
 106   chunks = []
 107
 108   header = []
 109   content = []
 110
 111   start = 0
 112
 113   for line in diff:
 114     if line.startswith("@@"):
 115       break
 116
 117     header.append(line)
 118     start += 1
 119
 120   for line in diff[start:]:
 121     if line.startswith("@@"):
 122       if content:
 123         chunks.append(content)
 124
 125       content = []
 126
 127     content.append(line)
 128
 129   chunks.append(content)
 130
 131   return header, chunks
 132
 133 def _parseFileDiff(header, chunk):
 134   """Takes a file diff and returns the parsed result
 135
 136   Params:
 137     header: The diff header.
 138     chunk: The chunk to parse.
 139
 140   Returns: A fileDiff containing the parsed diff.
 141   """
 142
 143   result = fileDiff(header)
 144
 145   if not chunk:
 146     return result
 147
 148   deleted = []
 149   added = []
 150
 151   # Find out where the context line ends, skipping the first '@@'
 152   to = chunk[0].find("@@", 2)
 153
 154   # Get the context, skipping the first and last '@@"
 155   context = chunk[0][3:to]
 156
 157   # Split it at the spaces and store the positions, ignoring '-' and '+'
 158   split = context.split(' ')
 159   a = split[0][1:]
 160   b = split[1][1:]
 161
 162   apos = int(a.split(',')[0])
 163   bpos = int(b.split(',')[0])
 164
 165   result.astart = apos
 166   result.bstart = bpos
 167
 168   # Start at the first line (skip the context line)
 169   for line in chunk[1:]:
 170     if line.startswith("-"):
 171       deleted.append((apos, line[1:]))
 172       apos += 1
 173
 174     if line.startswith("+"):
 175       added.append((bpos, line[1:]))
 176       bpos += 1
 177
 178   result.linesDeleted = deleted
 179   result.linesAdded = added
 180
 181   return result
 182
 183 def parseCommitDiff(diff):
 184   """Takes a commit diff and returns the parsed result
 185
 186   Params:
 187     diff: The diff to parse.
 188
 189   Returns: A parsedDiff instance containing the parsed diff.
 190   """
 191
 192   result = []
 193
 194   # Split the diff in file sized chunks
 195   chunks = splitDiff(diff)
 196
 197   # Loop over all the file diffs and parse them
 198   for chunk in chunks:
 199     header, filechunks = _splitFileDiff(chunk)
 200
 201     # Loop over all the chunks and parse them
 202     for filechunk in filechunks:
 203       # Get the result and store it
 204       fd = _parseFileDiff(header, filechunk)
 205       result.append(fd)
 206
 207   return result
 208
 209 def _compareFileDiffs(adiff, bdiff, invert=False):
 210   """Compares two fileDiffs and returns whether they are equal
 211
 212   Args:
 213     adiff: The first fileDiff.
 214     bdiff: The second fileDiff.
 215     invert: Whether to compare linesAdded with linesDeleted.
 216
 217   Returns: Whether the two diffs are equal.
 218   """
 219
 220   if invert:
 221     if not adiff.linesAdded == bdiff.linesDeleted:
 222       return False
 223     if not adiff.linesDeleted == bdiff.linesAdded:
 224         return False
 225   else:
 226     if not adiff.linesAdded == bdiff.linesAdded:
 227       return False
 228     if not adiff.linesDeleted == bdiff.linesDeleted:
 229       return False
 230
 231   # Checked everything, accept
 232   return True
 233
 234 def _compareDiffs(adiffs, bdiffs, compareChanges=False, invert=False):
 235   """Compares the two diffs and returns whether they are equal
 236
 237   Args:
 238     adiffs: The first set of diffs.
 239     bdiffs: The second set of diffs.
 240     compareChanges: Whether to compare not only which lines changed.
 241     invert: When compareChanges, invert the comparison of deleted/added.
 242
 243   Returns: Whether the diffs are equal.
 244   """
 245
 246   for fd in adiffs:
 247     # Look for a match in the bdiffs
 248     for theirs in bdiffs:
 249
 250       # Looks like we have a match
 251       if (theirs.astart <= fd.astart and theirs.bstart >= fd.bstart) or \
 252         (invert and theirs.astart <= fd.bstart and theirs.bstart >= fd.astart):
 253
 254        # If we want to compare changes, do they match
 255         if compareChanges:
 256           # Reject if they are inequal
 257           if not _compareFileDiffs(fd, theirs, invert):
 258             return False
 259
 260         # It was indeed a match, stop searching through bdiffs
 261         break
 262
 263     else:
 264       # Went through all items in bdiffs and couldn't find a matching pair
 265       return False
 266
 267   # All items in adiffs checked, all had a matching pair, accept.
 268   return True
 269
 270 def _difference(adiffs, bdiffs, compareChanges=False, invert=False):
 271   """Calculates the difference between two diffs and returns it
 272
 273   Params:
 274     adiffs: The first set of diffs.
 275     bdiffs: The second set of diffs.
 276     compareChanges: Whether to compare not only which lines changed.
 277     invert: When compareChanges, invert the comparison of deleted/added.
 278
 279   Returns: Which keys are missing and the difference between both diffs.
 280   """
 281
 282   afiles = collections.defaultdict(list)
 283   bfiles = collections.defaultdict(list)
 284
 285   missing = []
 286   difference = []
 287
 288   for fd in adiffs:
 289     afiles[(fd.afile, fd.bfile)].append(fd)
 290
 291   for fd in bdiffs:
 292     bfiles[(fd.afile, fd.bfile)].append(fd)
 293
 294   for key, fds in afiles.iteritems():
 295     if not bfiles.has_key(key):
 296       missing.append(key)
 297       continue
 298
 299     theirs = bfiles[key]
 300
 301     if not _compareDiffs(fds, theirs, compareChanges, invert):
 302       difference.append((fds, theirs))
 303
 304   return missing, difference
 305
 306 def commitdiffEqual(original, potentialMatch, threshold=0,
 307     compareChanges=True, invert=False, verbose=True):
 308   """Tests whether a commit matches another by a specified threshhold.
 309
 310   Params:
 311     original: The original commit that is to be checked.
 312     potentialMatch: The commit that might match original.
 313     threshhold: The threshold for how close they have to match.
 314     compareChanges: Whether to compare the changes made or just changes lines.
 315     invert: Whether to compare deletions with insertions instead.
 316
 317   Returns: Whether the commit diffs are equal.
 318   """
 319
 320   git = Repo(".").git
 321
 322   # Get the diff, but ignore whitespace
 323   result = getCommitDiff(original, noContext=True)
 324
 325   diffOriginal = result.split('\n')
 326
 327   # Get the diff but ignore whitespace
 328   result = getCommitDiff(potentialMatch, noContext=True)
 329
 330   diffPotentialMatch = result.split('\n')
 331
 332   parsedOriginal = parseCommitDiff(diffOriginal)
 333   parsedPotentialMatch = parseCommitDiff(diffPotentialMatch)
 334
 335   missing, diff = _difference(parsedOriginal, parsedPotentialMatch, compareChanges=compareChanges, invert=invert)
 336
 337   if verbose:
 338     if missing:
 339       print("Missing the following keys:")
 340       for key in missing:
 341         print(key)
 342
 343     if diff:
 344       print("Found the following differences:")
 345       for ours, theirs in diff:
 346         print("---")
 347         for fd in ours:
 348           print(fd)
 349         print("\nDoes not match:\n")
 350         for fd in theirs:
 351           print(fd)
 352         print("----")
 353
 354   # Unequal if something missing, or there is a difference
 355   return not (missing or diff)
 356
 357 def isReverted(commit, potentialRevert):
 358   """Returns whether the specified commit is reverted by another one
 359
 360   Args:
 361     commit: The commit that might be reverted.
 362     potentialRevert: The commit that might be a revert.
 363   """
 364
 365   return commitdiffEqual(commit, potentialRevert, invert=True, verbose=False)
 366
 367 def dispatch(*args):
 368   """Dispatches diff related commands
 369   """
 370
 371   progname = os.path.basename(sys.argv[0]) + " diff"
 372
 373   parser = OptionParser(option_class=parse.GitOption, prog=progname)
 374
 375   parser.add_option(
 376       "-e", "--equals",
 377       type="commit",
 378       nargs=2,
 379       help="show whether the two diffs for the specified commits match",
 380       metavar="COMMIT COMMIT")
 381
 382   parser.add_option(
 383       "-t", "--threshold",
 384       type="int",
 385       help="the threshold for comparison")
 386
 387   parser.add_option(
 388       "-n", "--no-compare",
 389       action="store_false",
 390       dest="compare",
 391       help="do not compare the diff content, just look at which lines were touched")
 392
 393   parser.add_option(
 394       "-i", "--invert",
 395       action="store_true",
 396       help="compare additions with deletions instead of with additions, and vise versa")
 397
 398   parser.set_default("threshold", 0)
 399   parser.set_default("compare", True)
 400   parser.set_default("invert", False)
 401
 402   (options, args) = parser.parse_args(list(args))
 403
 404   if options.equals:
 405     result = commitdiffEqual( threshold=options.threshold,
 406                               compareChanges=options.compare,
 407                               invert=options.invert,
 408                               *options.equals)
 409
 410     if result:
 411       print("Equal")
 412