Eric Lee / smarc-uboot | Embedian Git Server

Commit 102061bd8b0b174e1cf811dfd35641d8a9e4eba3

Authored by Simon Glass 2014-04-21 00:50:14 +0800

Exists in v2017.01-smarct4x and in 40 other branches

patman: Avoid duplicate sign-offs

Keep track of all Signed-off-by tags in a commit and silently suppress any
duplicates.

Signed-off-by: Simon Glass <sjg@chromium.org>

Showing 3 changed files with 23 additions and 2 deletions Inline Diff

tools/patman/README
tools/patman/commit.py
tools/patman/patchstream.py

tools/patman/README

Diff comments View file @ 102061b

 # Copyright (c) 2011 The Chromium OS Authors.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 What is this?
 =============
 This tool is a Python script which:
 - Creates patch directly from your branch
 - Cleans them up by removing unwanted tags
 - Inserts a cover letter with change lists
 - Runs the patches through checkpatch.pl and its own checks
 - Optionally emails them out to selected people
 It is intended to automate patch creation and make it a less
 error-prone process. It is useful for U-Boot and Linux work so far,
 since it uses the checkpatch.pl script.
 It is configured almost entirely by tags it finds in your commits.
 This means that you can work on a number of different branches at
 once, and keep the settings with each branch rather than having to
 git format-patch, git send-email, etc. with the correct parameters
 each time. So for example if you put:
 Series-to: fred.blogs@napier.co.nz
 in one of your commits, the series will be sent there.
 In Linux this will also call get_maintainer.pl on each of your
 patches automatically.
 How to use this tool
 ====================
 This tool requires a certain way of working:
 - Maintain a number of branches, one for each patch series you are
 working on
 - Add tags into the commits within each branch to indicate where the
 series should be sent, cover letter, version, etc. Most of these are
 normally in the top commit so it is easy to change them with 'git
 commit --amend'
 - Each branch tracks the upstream branch, so that this script can
 automatically determine the number of commits in it (optional)
 - Check out a branch, and run this script to create and send out your
 patches. Weeks later, change the patches and repeat, knowing that you
 will get a consistent result each time.
 How to configure it
 ===================
 For most cases of using patman for U-Boot development, patman will
 locate and use the file 'doc/git-mailrc' in your U-Boot directory.
 This contains most of the aliases you will need.
 For Linux the 'scripts/get_maintainer.pl' handles figuring out where
 to send patches pretty well.
 During the first run patman creates a config file for you by taking the default
 user name and email address from the global .gitconfig file.
 To add your own, create a file ~/.patman like this:
 >>>>
 # patman alias file
 [alias]
 me: Simon Glass <sjg@chromium.org>
 u-boot: U-Boot Mailing List <u-boot@lists.denx.de>
 wolfgang: Wolfgang Denk <wd@denx.de>
 others: Mike Frysinger <vapier@gentoo.org>, Fred Bloggs <f.bloggs@napier.net>
 <<<<
 Aliases are recursive.
 The checkpatch.pl in the U-Boot tools/ subdirectory will be located and
 used. Failing that you can put it into your path or ~/bin/checkpatch.pl
 If you want to change the defaults for patman's command-line arguments,
 you can add a [settings] section to your .patman file.  This can be used
 for any command line option by referring to the "dest" for the option in
 patman.py.  For reference, the useful ones (at the moment) shown below
 (all with the non-default setting):
 >>>
 [settings]
 ignore_errors: True
 process_tags: False
 verbose: True
 <<<
 If you want to adjust settings (or aliases) that affect just a single
 project you can add a section that looks like [project_settings] or
 [project_alias].  If you want to use tags for your linux work, you could
 do:
 >>>
 [linux_settings]
 process_tags: True
 <<<
 How to run it
 =============
 First do a dry run:
 $ ./tools/patman/patman -n
 If it can't detect the upstream branch, try telling it how many patches
 there are in your series:
 $ ./tools/patman/patman -n -c5
 This will create patch files in your current directory and tell you who
 it is thinking of sending them to. Take a look at the patch files.
 $ ./tools/patman/patman -n -c5 -s1
 Similar to the above, but skip the first commit and take the next 5. This
 is useful if your top commit is for setting up testing.
 How to add tags
 ===============
 To make this script useful you must add tags like the following into any
 commit. Most can only appear once in the whole series.
 Series-to: email / alias
 	Email address / alias to send patch series to (you can add this
 	multiple times)
 Series-cc: email / alias, ...
 	Email address / alias to Cc patch series to (you can add this
 	multiple times)
 Series-version: n
 	Sets the version number of this patch series
 Series-prefix: prefix
 	Sets the subject prefix. Normally empty but it can be RFC for
 	RFC patches, or RESEND if you are being ignored.
 Series-name: name
 	Sets the name of the series. You don't need to have a name, and
 	patman does not yet use it, but it is convenient to put the branch
 	name here to help you keep track of multiple upstreaming efforts.
 Cover-letter:
 This is the patch set title
 blah blah
 more blah blah
 END
 	Sets the cover letter contents for the series. The first line
 	will become the subject of the cover letter
 Cover-letter-cc: email / alias
 	Additional email addresses / aliases to send cover letter to (you
 	can add this multiple times)
 Series-notes:
 blah blah
 blah blah
 more blah blah
 END
 	Sets some notes for the patch series, which you don't want in
 	the commit messages, but do want to send, The notes are joined
 	together and put after the cover letter. Can appear multiple
 	times.
 Commit-notes:
 blah blah
 blah blah
 more blah blah
 END
 	Similar, but for a single commit (patch). These notes will appear
 	immediately below the --- cut in the patch file.
  Signed-off-by: Their Name <email>
 	A sign-off is added automatically to your patches (this is
 	probably a bug). If you put this tag in your patches, it will
 	override the default signoff that patman automatically adds.
+	Multiple duplicate signoffs will be removed.
  Tested-by: Their Name <email>
  Reviewed-by: Their Name <email>
  Acked-by: Their Name <email>
 	These indicate that someone has tested/reviewed/acked your patch.
 	When you get this reply on the mailing list, you can add this
 	tag to the relevant commit and the script will include it when
 	you send out the next version. If 'Tested-by:' is set to
 	yourself, it will be removed. No one will believe you.
 Series-changes: n
 - Guinea pig moved into its cage
 - Other changes ending with a blank line
 <blank line>
 	This can appear in any commit. It lists the changes for a
 	particular version n of that commit. The change list is
 	created based on this information. Each commit gets its own
 	change list and also the whole thing is repeated in the cover
 	letter (where duplicate change lines are merged).
 	By adding your change lists into your commits it is easier to
 	keep track of what happened. When you amend a commit, remember
 	to update the log there and then, knowing that the script will
 	do the rest.
 Patch-cc: Their Name <email>
 	This copies a single patch to another email address. Note that the
 	Cc: used by git send-email is ignored by patman, but will be
 	interpreted by git send-email if you use it.
 Series-process-log: sort, uniq
 	This tells patman to sort and/or uniq the change logs. It is
 	assumed that each change log entry is only a single line long.
 	Use 'sort' to sort the entries, and 'uniq' to include only
 	unique entries. If omitted, no change log processing is done.
 	Separate each tag with a comma.
 Various other tags are silently removed, like these Chrome OS and
 Gerrit tags:
 BUG=...
 TEST=...
 Change-Id:
 Review URL:
 Reviewed-on:
 Commit-xxxx: (except Commit-notes)
 Exercise for the reader: Try adding some tags to one of your current
 patch series and see how the patches turn out.
 Where Patches Are Sent
 ======================
 Once the patches are created, patman sends them using git send-email. The
 whole series is sent to the recipients in Series-to: and Series-cc.
 You can Cc individual patches to other people with the Patch-cc: tag. Tags
 in the subject are also picked up to Cc patches. For example, a commit like
 this:
 >>>>
 commit 10212537b85ff9b6e09c82045127522c0f0db981
 Author: Mike Frysinger <vapier@gentoo.org>
 Date:	Mon Nov 7 23:18:44 2011 -0500
     x86: arm: add a git mailrc file for maintainers
     This should make sending out e-mails to the right people easier.
     Patch-cc: sandbox, mikef, ag
     Patch-cc: afleming
 <<<<
 will create a patch which is copied to x86, arm, sandbox, mikef, ag and
 afleming.
 If you have a cover letter it will get sent to the union of the Patch-cc
 lists of all of the other patches. If you want to sent it to additional
 people you can add a tag:
 Cover-letter-cc: <list of addresses>
 These people will get the cover letter even if they are not on the To/Cc
 list for any of the patches.
 Example Work Flow
 =================
 The basic workflow is to create your commits, add some tags to the top
 commit, and type 'patman' to check and send them.
 Here is an example workflow for a series of 4 patches. Let's say you have
 these rather contrived patches in the following order in branch us-cmd in
 your tree where 'us' means your upstreaming activity (newest to oldest as
 output by git log --oneline):
     7c7909c wip
     89234f5 Don't include standard parser if hush is used
     8d640a7 mmc: sparc: Stop using builtin_run_command()
     0c859a9 Rename run_command2() to run_command()
     a74443f sandbox: Rename run_command() to builtin_run_command()
 The first patch is some test things that enable your code to be compiled,
 but that you don't want to submit because there is an existing patch for it
 on the list. So you can tell patman to create and check some patches
 (skipping the first patch) with:
     patman -s1 -n
 If you want to do all of them including the work-in-progress one, then
 (if you are tracking an upstream branch):
     patman -n
 Let's say that patman reports an error in the second patch. Then:
     git rebase -i HEAD~6
     <change 'pick' to 'edit' in 89234f5>
     <use editor to make code changes>
     git add -u
     git rebase --continue
 Now you have an updated patch series. To check it:
     patman -s1 -n
 Let's say it is now clean and you want to send it. Now you need to set up
 the destination. So amend the top commit with:
     git commit --amend
 Use your editor to add some tags, so that the whole commit message is:
     The current run_command() is really only one of the options, with
     hush providing the other. It really shouldn't be called directly
     in case the hush parser is bring used, so rename this function to
     better explain its purpose.
     Series-to: u-boot
     Series-cc: bfin, marex
     Series-prefix: RFC
     Cover-letter:
     Unified command execution in one place
     At present two parsers have similar code to execute commands. Also
     cmd_usage() is called all over the place. This series adds a single
     function which processes commands called cmd_process().
     END
     Change-Id: Ica71a14c1f0ecb5650f771a32fecb8d2eb9d8a17
 You want this to be an RFC and Cc the whole series to the bfin alias and
 to Marek. Two of the patches have tags (those are the bits at the front of
 the subject that say mmc: sparc: and sandbox:), so 8d640a7 will be Cc'd to
 mmc and sparc, and the last one to sandbox.
 Now to send the patches, take off the -n flag:
    patman -s1
 The patches will be created, shown in your editor, and then sent along with
 the cover letter. Note that patman's tags are automatically removed so that
 people on the list don't see your secret info.
 Of course patches often attract comments and you need to make some updates.
 Let's say one person sent comments and you get an Acked-by: on one patch.
 Also, the patch on the list that you were waiting for has been merged,
 so you can drop your wip commit. So you resync with upstream:
     git fetch origin		(or whatever upstream is called)
     git rebase origin/master
 and use git rebase -i to edit the commits, dropping the wip one. You add
 the ack tag to one commit:
     Acked-by: Heiko Schocher <hs@denx.de>
 update the Series-cc: in the top commit:
     Series-cc: bfin, marex, Heiko Schocher <hs@denx.de>
 and remove the Series-prefix: tag since it it isn't an RFC any more. The
 series is now version two, so the series info in the top commit looks like
 this:
     Series-to: u-boot
     Series-cc: bfin, marex, Heiko Schocher <hs@denx.de>
     Series-version: 2
     Cover-letter:
     ...
 Finally, you need to add a change log to the two commits you changed. You
 add change logs to each individual commit where the changes happened, like
 this:
     Series-changes: 2
     - Updated the command decoder to reduce code size
     - Wound the torque propounder up a little more
 (note the blank line at the end of the list)
 When you run patman it will collect all the change logs from the different
 commits and combine them into the cover letter, if you have one. So finally
 you have a new series of commits:
     faeb973 Don't include standard parser if hush is used
     1b2f2fe mmc: sparc: Stop using builtin_run_command()
     cfbe330 Rename run_command2() to run_command()
     0682677 sandbox: Rename run_command() to builtin_run_command()
 so to send them:
     patman
 and it will create and send the version 2 series.
 General points:
 1. When you change back to the us-cmd branch days or weeks later all your
 information is still there, safely stored in the commits. You don't need
 to remember what version you are up to, who you sent the last lot of patches
 to, or anything about the change logs.
 2. If you put tags in the subject, patman will Cc the maintainers
 automatically in many cases.
 3. If you want to keep the commits from each series you sent so that you can
 compare change and see what you did, you can either create a new branch for
 each version, or just tag the branch before you start changing it:
     git tag sent/us-cmd-rfc
     ...later...
     git tag sent/us-cmd-v2
 4. If you want to modify the patches a little before sending, you can do
 this in your editor, but be careful!
 5. If you want to run git send-email yourself, use the -n flag which will
 print out the command line patman would have used.
 6. It is a good idea to add the change log info as you change the commit,
 not later when you can't remember which patch you changed. You can always
 go back and change or remove logs from commits.
 Other thoughts
 ==============
 This script has been split into sensible files but still needs work.
 Most of these are indicated by a TODO in the code.
 It would be nice if this could handle the In-reply-to side of things.
 The tests are incomplete, as is customary. Use the --test flag to run them,
 and make sure you are in the tools/patman directory first:
     $ cd /path/to/u-boot
     $ cd tools/patman
     $ ./patman --test
 Error handling doesn't always produce friendly error messages - e.g.
 putting an incorrect tag in a commit may provide a confusing message.
 There might be a few other features not mentioned in this README. They
 might be bugs. In particular, tags are case sensitive which is probably
 a bad thing.
 Simon Glass <sjg@chromium.org>
 v1, v2, 19-Oct-11
 revised v3 24-Nov-11

tools/patman/commit.py

Diff comments View file @ 102061b

 # Copyright (c) 2011 The Chromium OS Authors.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 import re
 # Separates a tag: at the beginning of the subject from the rest of it
 re_subject_tag = re.compile('([^:\s]*):\s*(.*)')
 class Commit:
     """Holds information about a single commit/patch in the series.
     Args:
         hash: Commit hash (as a string)
     Variables:
         hash: Commit hash
         subject: Subject line
         tags: List of maintainer tag strings
         changes: Dict containing a list of changes (single line strings).
             The dict is indexed by change version (an integer)
         cc_list: List of people to aliases/emails to cc on this commit
         notes: List of lines in the commit (not series) notes
     """
     def __init__(self, hash):
         self.hash = hash
         self.subject = None
         self.tags = []
         self.changes = {}
         self.cc_list = []
+        self.signoff_set = set()
         self.notes = []
     def AddChange(self, version, info):
         """Add a new change line to the change list for a version.
         Args:
             version: Patch set version (integer: 1, 2, 3)
             info: Description of change in this version
         """
         if not self.changes.get(version):
             self.changes[version] = []
         self.changes[version].append(info)
     def CheckTags(self):
         """Create a list of subject tags in the commit
         Subject tags look like this:
             propounder: fort: Change the widget to propound correctly
         Here the tags are propounder and fort. Multiple tags are supported.
         The list is updated in self.tag.
         Returns:
             None if ok, else the name of a tag with no email alias
         """
         str = self.subject
         m = True
         while m:
             m = re_subject_tag.match(str)
             if m:
                 tag = m.group(1)
                 self.tags.append(tag)
                 str = m.group(2)
         return None
     def AddCc(self, cc_list):
         """Add a list of people to Cc when we send this patch.
         Args:
             cc_list:    List of aliases or email addresses
         """
         self.cc_list += cc_list
+    def CheckDuplicateSignoff(self, signoff):
+        """Check a list of signoffs we have send for this patch
+        Args:
+            signoff:    Signoff line
+        Returns:
+            True if this signoff is new, False if we have already seen it.
+        """
+        if signoff in self.signoff_set:
+          return False
+        self.signoff_set.add(signoff)
+        return True

tools/patman/patchstream.py

Diff comments View file @ 102061b

 # Copyright (c) 2011 The Chromium OS Authors.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 import os
 import re
 import shutil
 import tempfile
 import command
 import commit
 import gitutil
 from series import Series
 # Tags that we detect and remove
 re_remove = re.compile('^BUG=|^TEST=|^BRANCH=|^Change-Id:|^Review URL:'
     '|Reviewed-on:|Commit-\w*:')
 # Lines which are allowed after a TEST= line
 re_allowed_after_test = re.compile('^Signed-off-by:')
 # Signoffs
-re_signoff = re.compile('^Signed-off-by:')
+re_signoff = re.compile('^Signed-off-by: *(.*)')
 # The start of the cover letter
 re_cover = re.compile('^Cover-letter:')
 # A cover letter Cc
 re_cover_cc = re.compile('^Cover-letter-cc: *(.*)')
 # Patch series tag
 re_series_tag = re.compile('^Series-([a-z-]*): *(.*)')
 # Commit series tag
 re_commit_tag = re.compile('^Commit-([a-z-]*): *(.*)')
 # Commit tags that we want to collect and keep
 re_tag = re.compile('^(Tested-by|Acked-by|Reviewed-by|Patch-cc): (.*)')
 # The start of a new commit in the git log
 re_commit = re.compile('^commit ([0-9a-f]*)$')
 # We detect these since checkpatch doesn't always do it
 re_space_before_tab = re.compile('^[+].* \t')
 # States we can be in - can we use range() and still have comments?
 STATE_MSG_HEADER = 0        # Still in the message header
 STATE_PATCH_SUBJECT = 1     # In patch subject (first line of log for a commit)
 STATE_PATCH_HEADER = 2      # In patch header (after the subject)
 STATE_DIFFS = 3             # In the diff part (past --- line)
 class PatchStream:
     """Class for detecting/injecting tags in a patch or series of patches
     We support processing the output of 'git log' to read out the tags we
     are interested in. We can also process a patch file in order to remove
     unwanted tags or inject additional ones. These correspond to the two
     phases of processing.
     """
     def __init__(self, series, name=None, is_log=False):
         self.skip_blank = False          # True to skip a single blank line
         self.found_test = False          # Found a TEST= line
         self.lines_after_test = 0        # MNumber of lines found after TEST=
         self.warn = []                   # List of warnings we have collected
         self.linenum = 1                 # Output line number we are up to
         self.in_section = None           # Name of start...END section we are in
         self.notes = []                  # Series notes
         self.section = []                # The current section...END section
         self.series = series             # Info about the patch series
         self.is_log = is_log             # True if indent like git log
         self.in_change = 0               # Non-zero if we are in a change list
         self.blank_count = 0             # Number of blank lines stored up
         self.state = STATE_MSG_HEADER    # What state are we in?
         self.tags = []                   # Tags collected, like Tested-by...
         self.signoff = []                # Contents of signoff line
         self.commit = None               # Current commit
     def AddToSeries(self, line, name, value):
         """Add a new Series-xxx tag.
         When a Series-xxx tag is detected, we come here to record it, if we
         are scanning a 'git log'.
         Args:
             line: Source line containing tag (useful for debug/error messages)
             name: Tag name (part after 'Series-')
             value: Tag value (part after 'Series-xxx: ')
         """
         if name == 'notes':
             self.in_section = name
             self.skip_blank = False
         if self.is_log:
             self.series.AddTag(self.commit, line, name, value)
     def AddToCommit(self, line, name, value):
         """Add a new Commit-xxx tag.
         When a Commit-xxx tag is detected, we come here to record it.
         Args:
             line: Source line containing tag (useful for debug/error messages)
             name: Tag name (part after 'Commit-')
             value: Tag value (part after 'Commit-xxx: ')
         """
         if name == 'notes':
             self.in_section = 'commit-' + name
             self.skip_blank = False
     def CloseCommit(self):
         """Save the current commit into our commit list, and reset our state"""
         if self.commit and self.is_log:
             self.series.AddCommit(self.commit)
             self.commit = None
     def FormatTags(self, tags):
         out_list = []
         for tag in sorted(tags):
             if tag.startswith('Cc:'):
                 tag_list = tag[4:].split(',')
                 out_list += gitutil.BuildEmailList(tag_list, 'Cc:')
             else:
                 out_list.append(tag)
         return out_list
     def ProcessLine(self, line):
         """Process a single line of a patch file or commit log
         This process a line and returns a list of lines to output. The list
         may be empty or may contain multiple output lines.
         This is where all the complicated logic is located. The class's
         state is used to move between different states and detect things
         properly.
         We can be in one of two modes:
             self.is_log == True: This is 'git log' mode, where most output is
                 indented by 4 characters and we are scanning for tags
             self.is_log == False: This is 'patch' mode, where we already have
                 all the tags, and are processing patches to remove junk we
                 don't want, and add things we think are required.
         Args:
             line: text line to process
         Returns:
             list of output lines, or [] if nothing should be output
         """
         # Initially we have no output. Prepare the input line string
         out = []
         line = line.rstrip('\n')
         if self.is_log:
             if line[:4] == '    ':
                 line = line[4:]
         # Handle state transition and skipping blank lines
         series_tag_match = re_series_tag.match(line)
         commit_tag_match = re_commit_tag.match(line)
         commit_match = re_commit.match(line) if self.is_log else None
         cover_cc_match = re_cover_cc.match(line)
+        signoff_match = re_signoff.match(line)
         tag_match = None
         if self.state == STATE_PATCH_HEADER:
             tag_match = re_tag.match(line)
         is_blank = not line.strip()
         if is_blank:
             if (self.state == STATE_MSG_HEADER
                     or self.state == STATE_PATCH_SUBJECT):
                 self.state += 1
             # We don't have a subject in the text stream of patch files
             # It has its own line with a Subject: tag
             if not self.is_log and self.state == STATE_PATCH_SUBJECT:
                 self.state += 1
         elif commit_match:
             self.state = STATE_MSG_HEADER
         # If we are in a section, keep collecting lines until we see END
         if self.in_section:
             if line == 'END':
                 if self.in_section == 'cover':
                     self.series.cover = self.section
                 elif self.in_section == 'notes':
                     if self.is_log:
                         self.series.notes += self.section
                 elif self.in_section == 'commit-notes':
                     if self.is_log:
                         self.commit.notes += self.section
                 else:
                     self.warn.append("Unknown section '%s'" % self.in_section)
                 self.in_section = None
                 self.skip_blank = True
                 self.section = []
             else:
                 self.section.append(line)
         # Detect the commit subject
         elif not is_blank and self.state == STATE_PATCH_SUBJECT:
             self.commit.subject = line
         # Detect the tags we want to remove, and skip blank lines
         elif re_remove.match(line) and not commit_tag_match:
             self.skip_blank = True
             # TEST= should be the last thing in the commit, so remove
             # everything after it
             if line.startswith('TEST='):
                 self.found_test = True
         elif self.skip_blank and is_blank:
             self.skip_blank = False
         # Detect the start of a cover letter section
         elif re_cover.match(line):
             self.in_section = 'cover'
             self.skip_blank = False
         elif cover_cc_match:
             value = cover_cc_match.group(1)
             self.AddToSeries(line, 'cover-cc', value)
         # If we are in a change list, key collected lines until a blank one
         elif self.in_change:
             if is_blank:
                 # Blank line ends this change list
                 self.in_change = 0
-            elif line == '---' or re_signoff.match(line):
+            elif line == '---':
                 self.in_change = 0
                 out = self.ProcessLine(line)
             else:
                 if self.is_log:
                     self.series.AddChange(self.in_change, self.commit, line)
             self.skip_blank = False
         # Detect Series-xxx tags
         elif series_tag_match:
             name = series_tag_match.group(1)
             value = series_tag_match.group(2)
             if name == 'changes':
                 # value is the version number: e.g. 1, or 2
                 try:
                     value = int(value)
                 except ValueError as str:
                     raise ValueError("%s: Cannot decode version info '%s'" %
                         (self.commit.hash, line))
                 self.in_change = int(value)
             else:
                 self.AddToSeries(line, name, value)
                 self.skip_blank = True
         # Detect Commit-xxx tags
         elif commit_tag_match:
             name = commit_tag_match.group(1)
             value = commit_tag_match.group(2)
             if name == 'notes':
                 self.AddToCommit(line, name, value)
                 self.skip_blank = True
         # Detect the start of a new commit
         elif commit_match:
             self.CloseCommit()
             # TODO: We should store the whole hash, and just display a subset
             self.commit = commit.Commit(commit_match.group(1)[:8])
         # Detect tags in the commit message
         elif tag_match:
             # Remove Tested-by self, since few will take much notice
             if (tag_match.group(1) == 'Tested-by' and
                     tag_match.group(2).find(os.getenv('USER') + '@') != -1):
                 self.warn.append("Ignoring %s" % line)
             elif tag_match.group(1) == 'Patch-cc':
                 self.commit.AddCc(tag_match.group(2).split(','))
             else:
                 self.tags.append(line);
+        # Suppress duplicate signoffs
+        elif signoff_match:
+            if self.commit.CheckDuplicateSignoff(signoff_match.group(1)):
+                out = [line]
         # Well that means this is an ordinary line
         else:
             pos = 1
             # Look for ugly ASCII characters
             for ch in line:
                 # TODO: Would be nicer to report source filename and line
                 if ord(ch) > 0x80:
                     self.warn.append("Line %d/%d ('%s') has funny ascii char" %
                         (self.linenum, pos, line))
                 pos += 1
             # Look for space before tab
             m = re_space_before_tab.match(line)
             if m:
                 self.warn.append('Line %d/%d has space before tab' %
                     (self.linenum, m.start()))
             # OK, we have a valid non-blank line
             out = [line]
             self.linenum += 1
             self.skip_blank = False
             if self.state == STATE_DIFFS:
                 pass
             # If this is the start of the diffs section, emit our tags and
             # change log
             elif line == '---':
                 self.state = STATE_DIFFS
                 # Output the tags (signeoff first), then change list
                 out = []
                 log = self.series.MakeChangeLog(self.commit)
                 out += self.FormatTags(self.tags)
                 out += [line] + self.commit.notes + [''] + log
             elif self.found_test:
                 if not re_allowed_after_test.match(line):
                     self.lines_after_test += 1
         return out
     def Finalize(self):
         """Close out processing of this patch stream"""
         self.CloseCommit()
         if self.lines_after_test:
             self.warn.append('Found %d lines after TEST=' %
                     self.lines_after_test)
     def ProcessStream(self, infd, outfd):
         """Copy a stream from infd to outfd, filtering out unwanting things.
         This is used to process patch files one at a time.
         Args:
             infd: Input stream file object
             outfd: Output stream file object
         """
         # Extract the filename from each diff, for nice warnings
         fname = None
         last_fname = None
         re_fname = re.compile('diff --git a/(.*) b/.*')
         while True:
             line = infd.readline()
             if not line:
                 break
             out = self.ProcessLine(line)
             # Try to detect blank lines at EOF
             for line in out:
                 match = re_fname.match(line)
                 if match:
                     last_fname = fname
                     fname = match.group(1)
                 if line == '+':
                     self.blank_count += 1
                 else:
                     if self.blank_count and (line == '-- ' or match):
                         self.warn.append("Found possible blank line(s) at "
                                 "end of file '%s'" % last_fname)
                     outfd.write('+\n' * self.blank_count)
                     outfd.write(line + '\n')
                     self.blank_count = 0
         self.Finalize()
 def GetMetaDataForList(commit_range, git_dir=None, count=None,
                        series = Series()):
     """Reads out patch series metadata from the commits
     This does a 'git log' on the relevant commits and pulls out the tags we
     are interested in.
     Args:
         commit_range: Range of commits to count (e.g. 'HEAD..base')
         git_dir: Path to git repositiory (None to use default)
         count: Number of commits to list, or None for no limit
         series: Series object to add information into. By default a new series
             is started.
     Returns:
         A Series object containing information about the commits.
     """
     params = ['git', 'log', '--no-color', '--reverse', '--no-decorate',
                     commit_range]
     if count is not None:
         params[2:2] = ['-n%d' % count]
     if git_dir:
         params[1:1] = ['--git-dir', git_dir]
     pipe = [params]
     stdout = command.RunPipe(pipe, capture=True).stdout
     ps = PatchStream(series, is_log=True)
     for line in stdout.splitlines():
         ps.ProcessLine(line)
     ps.Finalize()
     return series
 def GetMetaData(start, count):
     """Reads out patch series metadata from the commits
     This does a 'git log' on the relevant commits and pulls out the tags we
     are interested in.
     Args:
         start: Commit to start from: 0=HEAD, 1=next one, etc.
         count: Number of commits to list
     """
     return GetMetaDataForList('HEAD~%d' % start, None, count)
 def FixPatch(backup_dir, fname, series, commit):
     """Fix up a patch file, by adding/removing as required.
     We remove our tags from the patch file, insert changes lists, etc.
     The patch file is processed in place, and overwritten.
     A backup file is put into backup_dir (if not None).
     Args:
         fname: Filename to patch file to process
         series: Series information about this patch set
         commit: Commit object for this patch file
     Return:
         A list of errors, or [] if all ok.
     """
     handle, tmpname = tempfile.mkstemp()
     outfd = os.fdopen(handle, 'w')
     infd = open(fname, 'r')
     ps = PatchStream(series)
     ps.commit = commit
     ps.ProcessStream(infd, outfd)
     infd.close()
     outfd.close()
     # Create a backup file if required
     if backup_dir:
         shutil.copy(fname, os.path.join(backup_dir, os.path.basename(fname)))
     shutil.move(tmpname, fname)
     return ps.warn
 def FixPatches(series, fnames):
     """Fix up a list of patches identified by filenames
     The patch files are processed in place, and overwritten.
     Args:
         series: The series object
         fnames: List of patch files to process
     """
     # Current workflow creates patches, so we shouldn't need a backup
     backup_dir = None  #tempfile.mkdtemp('clean-patch')
     count = 0
     for fname in fnames:
         commit = series.commits[count]
         commit.patch = fname
         result = FixPatch(backup_dir, fname, series, commit)
         if result:
             print '%d warnings for %s:' % (len(result), fname)
             for warn in result:
                 print '\t', warn
             print
         count += 1
     print 'Cleaned %d patches' % count
     return series
 def InsertCoverLetter(fname, series, count):
     """Inserts a cover letter with the required info into patch 0
     Args:
         fname: Input / output filename of the cover letter file
         series: Series object
         count: Number of patches in the series
     """
     fd = open(fname, 'r')
     lines = fd.readlines()
     fd.close()
     fd = open(fname, 'w')
     text = series.cover
     prefix = series.GetPatchPrefix()
     for line in lines:
         if line.startswith('Subject:'):
             # TODO: if more than 10 patches this should save 00/xx, not 0/xx
             line = 'Subject: [%s 0/%d] %s\n' % (prefix, count, text[0])
         # Insert our cover letter
         elif line.startswith('*** BLURB HERE ***'):
             # First the blurb test
             line = '\n'.join(text[1:]) + '\n'
             if series.get('notes'):
                 line += '\n'.join(series.notes) + '\n'
             # Now the change list
             out = series.MakeChangeLog(None)
             line += '\n' + '\n'.join(out)
         fd.write(line)
     fd.close()