tools/patman/patchstream.py

   1 # Copyright (c) 2011 The Chromium OS Authors.
   2 #
   3 # See file CREDITS for list of people who contributed to this
   4 # project.
   5 #
   6 # This program is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU General Public License as
   8 # published by the Free Software Foundation; either version 2 of
   9 # the License, or (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  19 # MA 02111-1307 USA
  20 #
  21
  22 import os
  23 import re
  24 import shutil
  25 import tempfile
  26
  27 import command
  28 import commit
  29 import gitutil
  30 from series import Series
  31
  32 # Tags that we detect and remove
  33 re_remove = re.compile('^BUG=|^TEST=|^BRANCH=|^Change-Id:|^Review URL:'
  34     '|Reviewed-on:|Reviewed-by:|Commit-Ready:')
  35
  36 # Lines which are allowed after a TEST= line
  37 re_allowed_after_test = re.compile('^Signed-off-by:')
  38
  39 # Signoffs
  40 re_signoff = re.compile('^Signed-off-by:')
  41
  42 # The start of the cover letter
  43 re_cover = re.compile('^Cover-letter:')
  44
  45 # Patch series tag
  46 re_series = re.compile('^Series-(\w*): *(.*)')
  47
  48 # Commit tags that we want to collect and keep
  49 re_tag = re.compile('^(Tested-by|Acked-by|Cc): (.*)')
  50
  51 # The start of a new commit in the git log
  52 re_commit = re.compile('^commit (.*)')
  53
  54 # We detect these since checkpatch doesn't always do it
  55 re_space_before_tab = re.compile('^[+].* \t')
  56
  57 # States we can be in - can we use range() and still have comments?
  58 STATE_MSG_HEADER = 0        # Still in the message header
  59 STATE_PATCH_SUBJECT = 1     # In patch subject (first line of log for a commit)
  60 STATE_PATCH_HEADER = 2      # In patch header (after the subject)
  61 STATE_DIFFS = 3             # In the diff part (past --- line)
  62
  63 class PatchStream:
  64     """Class for detecting/injecting tags in a patch or series of patches
  65
  66     We support processing the output of 'git log' to read out the tags we
  67     are interested in. We can also process a patch file in order to remove
  68     unwanted tags or inject additional ones. These correspond to the two
  69     phases of processing.
  70     """
  71     def __init__(self, series, name=None, is_log=False):
  72         self.skip_blank = False          # True to skip a single blank line
  73         self.found_test = False          # Found a TEST= line
  74         self.lines_after_test = 0        # MNumber of lines found after TEST=
  75         self.warn = []                   # List of warnings we have collected
  76         self.linenum = 1                 # Output line number we are up to
  77         self.in_section = None           # Name of start...END section we are in
  78         self.notes = []                  # Series notes
  79         self.section = []                # The current section...END section
  80         self.series = series             # Info about the patch series
  81         self.is_log = is_log             # True if indent like git log
  82         self.in_change = 0               # Non-zero if we are in a change list
  83         self.blank_count = 0             # Number of blank lines stored up
  84         self.state = STATE_MSG_HEADER    # What state are we in?
  85         self.tags = []                   # Tags collected, like Tested-by...
  86         self.signoff = []                # Contents of signoff line
  87         self.commit = None               # Current commit
  88
  89     def AddToSeries(self, line, name, value):
  90         """Add a new Series-xxx tag.
  91
  92         When a Series-xxx tag is detected, we come here to record it, if we
  93         are scanning a 'git log'.
  94
  95         Args:
  96             line: Source line containing tag (useful for debug/error messages)
  97             name: Tag name (part after 'Series-')
  98             value: Tag value (part after 'Series-xxx: ')
  99         """
 100         if name == 'notes':
 101             self.in_section = name
 102             self.skip_blank = False
 103         if self.is_log:
 104             self.series.AddTag(self.commit, line, name, value)
 105
 106     def CloseCommit(self):
 107         """Save the current commit into our commit list, and reset our state"""
 108         if self.commit and self.is_log:
 109             self.series.AddCommit(self.commit)
 110             self.commit = None
 111
 112     def FormatTags(self, tags):
 113         out_list = []
 114         for tag in sorted(tags):
 115             if tag.startswith('Cc:'):
 116                 tag_list = tag[4:].split(',')
 117                 out_list += gitutil.BuildEmailList(tag_list, 'Cc:')
 118             else:
 119                 out_list.append(tag)
 120         return out_list
 121
 122     def ProcessLine(self, line):
 123         """Process a single line of a patch file or commit log
 124
 125         This process a line and returns a list of lines to output. The list
 126         may be empty or may contain multiple output lines.
 127
 128         This is where all the complicated logic is located. The class's
 129         state is used to move between different states and detect things
 130         properly.
 131
 132         We can be in one of two modes:
 133             self.is_log == True: This is 'git log' mode, where most output is
 134                 indented by 4 characters and we are scanning for tags
 135
 136             self.is_log == False: This is 'patch' mode, where we already have
 137                 all the tags, and are processing patches to remove junk we
 138                 don't want, and add things we think are required.
 139
 140         Args:
 141             line: text line to process
 142
 143         Returns:
 144             list of output lines, or [] if nothing should be output
 145         """
 146         # Initially we have no output. Prepare the input line string
 147         out = []
 148         line = line.rstrip('\n')
 149         if self.is_log:
 150             if line[:4] == '    ':
 151                 line = line[4:]
 152
 153         # Handle state transition and skipping blank lines
 154         series_match = re_series.match(line)
 155         commit_match = re_commit.match(line) if self.is_log else None
 156         tag_match = None
 157         if self.state == STATE_PATCH_HEADER:
 158             tag_match = re_tag.match(line)
 159         is_blank = not line.strip()
 160         if is_blank:
 161             if (self.state == STATE_MSG_HEADER
 162                     or self.state == STATE_PATCH_SUBJECT):
 163                 self.state += 1
 164
 165             # We don't have a subject in the text stream of patch files
 166             # It has its own line with a Subject: tag
 167             if not self.is_log and self.state == STATE_PATCH_SUBJECT:
 168                 self.state += 1
 169         elif commit_match:
 170             self.state = STATE_MSG_HEADER
 171
 172         # If we are in a section, keep collecting lines until we see END
 173         if self.in_section:
 174             if line == 'END':
 175                 if self.in_section == 'cover':
 176                     self.series.cover = self.section
 177                 elif self.in_section == 'notes':
 178                     if self.is_log:
 179                         self.series.notes += self.section
 180                 else:
 181                     self.warn.append("Unknown section '%s'" % self.in_section)
 182                 self.in_section = None
 183                 self.skip_blank = True
 184                 self.section = []
 185             else:
 186                 self.section.append(line)
 187
 188         # Detect the commit subject
 189         elif not is_blank and self.state == STATE_PATCH_SUBJECT:
 190             self.commit.subject = line
 191
 192         # Detect the tags we want to remove, and skip blank lines
 193         elif re_remove.match(line):
 194             self.skip_blank = True
 195
 196             # TEST= should be the last thing in the commit, so remove
 197             # everything after it
 198             if line.startswith('TEST='):
 199                 self.found_test = True
 200         elif self.skip_blank and is_blank:
 201             self.skip_blank = False
 202
 203         # Detect the start of a cover letter section
 204         elif re_cover.match(line):
 205             self.in_section = 'cover'
 206             self.skip_blank = False
 207
 208         # If we are in a change list, key collected lines until a blank one
 209         elif self.in_change:
 210             if is_blank:
 211                 # Blank line ends this change list
 212                 self.in_change = 0
 213             elif line == '---' or re_signoff.match(line):
 214                 self.in_change = 0
 215                 out = self.ProcessLine(line)
 216             else:
 217                 if self.is_log:
 218                     self.series.AddChange(self.in_change, self.commit, line)
 219             self.skip_blank = False
 220
 221         # Detect Series-xxx tags
 222         elif series_match:
 223             name = series_match.group(1)
 224             value = series_match.group(2)
 225             if name == 'changes':
 226                 # value is the version number: e.g. 1, or 2
 227                 try:
 228                     value = int(value)
 229                 except ValueError as str:
 230                     raise ValueError("%s: Cannot decode version info '%s'" %
 231                         (self.commit.hash, line))
 232                 self.in_change = int(value)
 233             else:
 234                 self.AddToSeries(line, name, value)
 235                 self.skip_blank = True
 236
 237         # Detect the start of a new commit
 238         elif commit_match:
 239             self.CloseCommit()
 240             self.commit = commit.Commit(commit_match.group(1)[:7])
 241
 242         # Detect tags in the commit message
 243         elif tag_match:
 244             # Remove Tested-by self, since few will take much notice
 245             if (tag_match.group(1) == 'Tested-by' and
 246                     tag_match.group(2).find(os.getenv('USER') + '@') != -1):
 247                 self.warn.append("Ignoring %s" % line)
 248             elif tag_match.group(1) == 'Cc':
 249                 self.commit.AddCc(tag_match.group(2).split(','))
 250             else:
 251                 self.tags.append(line);
 252
 253         # Well that means this is an ordinary line
 254         else:
 255             pos = 1
 256             # Look for ugly ASCII characters
 257             for ch in line:
 258                 # TODO: Would be nicer to report source filename and line
 259                 if ord(ch) > 0x80:
 260                     self.warn.append("Line %d/%d ('%s') has funny ascii char" %
 261                         (self.linenum, pos, line))
 262                 pos += 1
 263
 264             # Look for space before tab
 265             m = re_space_before_tab.match(line)
 266             if m:
 267                 self.warn.append('Line %d/%d has space before tab' %
 268                     (self.linenum, m.start()))
 269
 270             # OK, we have a valid non-blank line
 271             out = [line]
 272             self.linenum += 1
 273             self.skip_blank = False
 274             if self.state == STATE_DIFFS:
 275                 pass
 276
 277             # If this is the start of the diffs section, emit our tags and
 278             # change log
 279             elif line == '---':
 280                 self.state = STATE_DIFFS
 281
 282                 # Output the tags (signeoff first), then change list
 283                 out = []
 284                 log = self.series.MakeChangeLog(self.commit)
 285                 out += self.FormatTags(self.tags)
 286                 out += [line] + log
 287             elif self.found_test:
 288                 if not re_allowed_after_test.match(line):
 289                     self.lines_after_test += 1
 290
 291         return out
 292
 293     def Finalize(self):
 294         """Close out processing of this patch stream"""
 295         self.CloseCommit()
 296         if self.lines_after_test:
 297             self.warn.append('Found %d lines after TEST=' %
 298                     self.lines_after_test)
 299
 300     def ProcessStream(self, infd, outfd):
 301         """Copy a stream from infd to outfd, filtering out unwanting things.
 302
 303         This is used to process patch files one at a time.
 304
 305         Args:
 306             infd: Input stream file object
 307             outfd: Output stream file object
 308         """
 309         # Extract the filename from each diff, for nice warnings
 310         fname = None
 311         last_fname = None
 312         re_fname = re.compile('diff --git a/(.*) b/.*')
 313         while True:
 314             line = infd.readline()
 315             if not line:
 316                 break
 317             out = self.ProcessLine(line)
 318
 319             # Try to detect blank lines at EOF
 320             for line in out:
 321                 match = re_fname.match(line)
 322                 if match:
 323                     last_fname = fname
 324                     fname = match.group(1)
 325                 if line == '+':
 326                     self.blank_count += 1
 327                 else:
 328                     if self.blank_count and (line == '-- ' or match):
 329                         self.warn.append("Found possible blank line(s) at "
 330                                 "end of file '%s'" % last_fname)
 331                     outfd.write('+\n' * self.blank_count)
 332                     outfd.write(line + '\n')
 333                     self.blank_count = 0
 334         self.Finalize()
 335
 336
 337 def GetMetaData(start, count):
 338     """Reads out patch series metadata from the commits
 339
 340     This does a 'git log' on the relevant commits and pulls out the tags we
 341     are interested in.
 342
 343     Args:
 344         start: Commit to start from: 0=HEAD, 1=next one, etc.
 345         count: Number of commits to list
 346     """
 347     pipe = [['git', 'log', '--no-color', '--reverse', 'HEAD~%d' % start,
 348         '-n%d' % count]]
 349     stdout = command.RunPipe(pipe, capture=True)
 350     series = Series()
 351     ps = PatchStream(series, is_log=True)
 352     for line in stdout.splitlines():
 353         ps.ProcessLine(line)
 354     ps.Finalize()
 355     return series
 356
 357 def FixPatch(backup_dir, fname, series, commit):
 358     """Fix up a patch file, by adding/removing as required.
 359
 360     We remove our tags from the patch file, insert changes lists, etc.
 361     The patch file is processed in place, and overwritten.
 362
 363     A backup file is put into backup_dir (if not None).
 364
 365     Args:
 366         fname: Filename to patch file to process
 367         series: Series information about this patch set
 368         commit: Commit object for this patch file
 369     Return:
 370         A list of errors, or [] if all ok.
 371     """
 372     handle, tmpname = tempfile.mkstemp()
 373     outfd = os.fdopen(handle, 'w')
 374     infd = open(fname, 'r')
 375     ps = PatchStream(series)
 376     ps.commit = commit
 377     ps.ProcessStream(infd, outfd)
 378     infd.close()
 379     outfd.close()
 380
 381     # Create a backup file if required
 382     if backup_dir:
 383         shutil.copy(fname, os.path.join(backup_dir, os.path.basename(fname)))
 384     shutil.move(tmpname, fname)
 385     return ps.warn
 386
 387 def FixPatches(series, fnames):
 388     """Fix up a list of patches identified by filenames
 389
 390     The patch files are processed in place, and overwritten.
 391
 392     Args:
 393         series: The series object
 394         fnames: List of patch files to process
 395     """
 396     # Current workflow creates patches, so we shouldn't need a backup
 397     backup_dir = None  #tempfile.mkdtemp('clean-patch')
 398     count = 0
 399     for fname in fnames:
 400         commit = series.commits[count]
 401         commit.patch = fname
 402         result = FixPatch(backup_dir, fname, series, commit)
 403         if result:
 404             print '%d warnings for %s:' % (len(result), fname)
 405             for warn in result:
 406                 print '\t', warn
 407             print
 408         count += 1
 409     print 'Cleaned %d patches' % count
 410     return series
 411
 412 def InsertCoverLetter(fname, series, count):
 413     """Inserts a cover letter with the required info into patch 0
 414
 415     Args:
 416         fname: Input / output filename of the cover letter file
 417         series: Series object
 418         count: Number of patches in the series
 419     """
 420     fd = open(fname, 'r')
 421     lines = fd.readlines()
 422     fd.close()
 423
 424     fd = open(fname, 'w')
 425     text = series.cover
 426     prefix = series.GetPatchPrefix()
 427     for line in lines:
 428         if line.startswith('Subject:'):
 429             # TODO: if more than 10 patches this should save 00/xx, not 0/xx
 430             line = 'Subject: [%s 0/%d] %s\n' % (prefix, count, text[0])
 431
 432         # Insert our cover letter
 433         elif line.startswith('*** BLURB HERE ***'):
 434             # First the blurb test
 435             line = '\n'.join(text[1:]) + '\n'
 436             if series.get('notes'):
 437                 line += '\n'.join(series.notes) + '\n'
 438
 439             # Now the change list
 440             out = series.MakeChangeLog(None)
 441             line += '\n' + '\n'.join(out)
 442         fd.write(line)
 443     fd.close()