Update upload.py from ed59464f8468.

third_party/upload.py

 #!/usr/bin/env python
 #
 # Copyright 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 76 matching lines @@
 MAX_UPLOAD_SIZE = 900 * 1024
 
 # Constants for version control names.  Used by GuessVCSName.
 VCS_GIT = "Git"
 VCS_MERCURIAL = "Mercurial"
 VCS_SUBVERSION = "Subversion"
 VCS_PERFORCE = "Perforce"
 VCS_CVS = "CVS"
 VCS_UNKNOWN = "Unknown"
 
-# whitelist for non-binary filetypes which do not start with "text/"
-# .mm (Objective-C) shows up as application/x-freemind on my Linux box.
-TEXT_MIMETYPES = ['application/javascript', 'application/json',
-                  'application/x-javascript', 'application/xml',
-                  'application/x-freemind', 'application/x-sh']
-
 VCS_ABBREVIATIONS = {
   VCS_MERCURIAL.lower(): VCS_MERCURIAL,
   "hg": VCS_MERCURIAL,
   VCS_SUBVERSION.lower(): VCS_SUBVERSION,
   "svn": VCS_SUBVERSION,
   VCS_PERFORCE.lower(): VCS_PERFORCE,
   "p4": VCS_PERFORCE,
   VCS_GIT.lower(): VCS_GIT,
   VCS_CVS.lower(): VCS_CVS,
 }
@@ skipping 428 matching lines @@
                  dest="download_base", default=False,
                  help="Base files will be downloaded by the server "
                  "(side-by-side diffs may not work on files with CRs).")
 group.add_option("--rev", action="store", dest="revision",
                  metavar="REV", default=None,
                  help="Base revision/branch/tree to diff against. Use "
                       "rev1:rev2 range to review already committed changeset.")
 group.add_option("--send_mail", action="store_true",
                  dest="send_mail", default=False,
                  help="Send notification email to reviewers.")
+group.add_option("-p", "--send_patch", action="store_true",
+                 dest="send_patch", default=False,
+                 help="Send notification email to reviewers, with a diff of "
+                      "the changes included as an attachment instead of "
+                      "inline. Also prepends 'PATCH:' to the email subject. "
+                      "(implies --send_mail)")
 group.add_option("--vcs", action="store", dest="vcs",
                  metavar="VCS", default=None,
                  help=("Version control system (optional, usually upload.py "
                        "already guesses the right VCS)."))
 group.add_option("--emulate_svn_auto_props", action="store_true",
                  dest="emulate_svn_auto_props", default=False,
                  help=("Emulate Subversion's auto properties feature."))
 # Perforce-specific
 group = parser.add_option_group("Perforce-specific options "
                                 "(overrides P4 environment variables)")
@@ skipping 308 matching lines @@
       if new_content != None:
         UploadFile(filename, file_id, new_content, is_binary, status, False)
 
   def IsImage(self, filename):
     """Returns true if the filename has an image extension."""
     mimetype =  mimetypes.guess_type(filename)[0]
     if not mimetype:
       return False
     return mimetype.startswith("image/")
 
-  def IsBinary(self, filename):
-    """Returns true if the guessed mimetyped isnt't in text group."""
-    mimetype = mimetypes.guess_type(filename)[0]
-    if not mimetype:
-      return False  # e.g. README, "real" binaries usually have an extension
-    # special case for text files which don't start with text/
-    if mimetype in TEXT_MIMETYPES:
-      return False
-    return not mimetype.startswith("text/")
+  def IsBinaryData(self, data):
+    """Returns true if data contains a null byte."""
+    # Derived from how Mercurial's heuristic, see
+    # http://selenic.com/hg/file/848a6658069e/mercurial/util.py#l229
+    return bool(data and "\0" in data)
 
 
 class SubversionVCS(VersionControlSystem):
   """Implementation of the VersionControlSystem interface for Subversion."""
 
   def __init__(self, options):
     super(SubversionVCS, self).__init__(options)
     if self.options.revision:
       match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
       if not match:
@@ skipping 36 matching lines @@
           guess = "Google Code "
         path = path + "/"
         base = urlparse.urlunparse((scheme, netloc, path, params,
                                     query, fragment))
         logging.info("Guessed %sbase = %s", guess, base)
         return base
     if required:
       ErrorExit("Can't find URL in output from svn info")
     return None
 
+  def _EscapeFilename(self, filename):
+    """Escapes filename for SVN commands."""
+    if "@" in filename and not filename.endswith("@"):
+      filename = "%s@" % filename
+    return filename
+
   def GenerateDiff(self, args):
     cmd = ["svn", "diff"]
     if self.options.revision:
       cmd += ["-r", self.options.revision]
     cmd.extend(args)
     data = RunShell(cmd)
     count = 0
     for line in data.splitlines():
       if line.startswith("Index:") or line.startswith("Property changes on:"):
         count += 1
@@ skipping 47 matching lines @@
     result = ""
     try:
       result = file.read()
     finally:
       file.close()
     return result
 
   def GetStatus(self, filename):
     """Returns the status of a file."""
     if not self.options.revision:
-      status = RunShell(["svn", "status", "--ignore-externals", filename])
+      status = RunShell(["svn", "status", "--ignore-externals",
+                         self._EscapeFilename(filename)])
       if not status:
         ErrorExit("svn status returned no output for %s" % filename)
       status_lines = status.splitlines()
       # If file is in a cl, the output will begin with
       # "\n--- Changelist 'cl_name':\n".  See
       # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
       if (len(status_lines) == 3 and
           not status_lines[0] and
           status_lines[1].startswith("--- Changelist")):
         status = status_lines[2]
       else:
         status = status_lines[0]
     # If we have a revision to diff against we need to run "svn list"
     # for the old and the new revision and compare the results to get
     # the correct status for a file.
     else:
       dirname, relfilename = os.path.split(filename)
       if dirname not in self.svnls_cache:
-        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
+        cmd = ["svn", "list", "-r", self.rev_start,
+               self._EscapeFilename(dirname) or "."]
         out, err, returncode = RunShellWithReturnCodeAndStderr(cmd)
         if returncode:
           # Directory might not yet exist at start revison
           # svn: Unable to find repository location for 'abc' in revision nnn
           if re.match('^svn: Unable to find repository location for .+ in revision \d+', err):
             old_files = ()
           else:
             ErrorExit("Failed to get status for %s:\n%s" % (filename, err))
         else:
           old_files = out.splitlines()
         args = ["svn", "list"]
         if self.rev_end:
           args += ["-r", self.rev_end]
-        cmd = args + [dirname or "."]
+        cmd = args + [self._EscapeFilename(dirname) or "."]
         out, returncode = RunShellWithReturnCode(cmd)
         if returncode:
           ErrorExit("Failed to run command %s" % cmd)
         self.svnls_cache[dirname] = (old_files, out.splitlines())
       old_files, new_files = self.svnls_cache[dirname]
       if relfilename in old_files and relfilename not in new_files:
         status = "D   "
       elif relfilename in old_files and relfilename in new_files:
         status = "M   "
       else:
         status = "A   "
     return status
 
   def GetBaseFile(self, filename):
     status = self.GetStatus(filename)
     base_content = None
     new_content = None
 
     # If a file is copied its status will be "A  +", which signifies
     # "addition-with-history".  See "svn st" for more information.  We need to
     # upload the original file or else diff parsing will fail if the file was
     # edited.
     if status[0] == "A" and status[3] != "+":
       # We'll need to upload the new content if we're adding a binary file
       # since diff's output won't contain it.
-      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
-                          silent_ok=True)
+      mimetype = RunShell(["svn", "propget", "svn:mime-type",
+                           self._EscapeFilename(filename)], silent_ok=True)
       base_content = ""
       is_binary = bool(mimetype) and not mimetype.startswith("text/")
       if is_binary and self.IsImage(filename):
         new_content = self.ReadFile(filename)
     elif (status[0] in ("M", "D", "R") or
           (status[0] == "A" and status[3] == "+") or  # Copied file.
           (status[0] == " " and status[1] == "M")):  # Property change.
       args = []
       if self.options.revision:
+        # filename must not be escaped. We already add an ampersand here.
         url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
       else:
         # Don't change filename, it's needed later.
         url = filename
         args += ["-r", "BASE"]
       cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
       mimetype, returncode = RunShellWithReturnCode(cmd)
       if returncode:
         # File does not exist in the requested revision.
         # Reset mimetype, it contains an error message.
         mimetype = ""
       else:
         mimetype = mimetype.strip()
       get_base = False
+      # this test for binary is exactly the test prescribed by the
+      # official SVN docs at
+      # http://subversion.apache.org/faq.html#binary-files
       is_binary = (bool(mimetype) and
         not mimetype.startswith("text/") and
-        not mimetype in TEXT_MIMETYPES)
+        mimetype not in ("image/x-xbitmap", "image/x-xpixmap"))
       if status[0] == " ":
         # Empty base content just to force an upload.
         base_content = ""
       elif is_binary:
         if self.IsImage(filename):
           get_base = True
           if status[0] == "M":
             if not self.rev_end:
               new_content = self.ReadFile(filename)
             else:
@@ skipping 12 matching lines @@
           universal_newlines = True
         if self.rev_start:
           # "svn cat -r REV delete_file.txt" doesn't work. cat requires
           # the full URL with "@REV" appended instead of using "-r" option.
           url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
           base_content = RunShell(["svn", "cat", url],
                                   universal_newlines=universal_newlines,
                                   silent_ok=True)
         else:
           base_content, ret_code = RunShellWithReturnCode(
-            ["svn", "cat", filename], universal_newlines=universal_newlines)
+            ["svn", "cat", self._EscapeFilename(filename)],
+            universal_newlines=universal_newlines)
           if ret_code and status[0] == "R":
             # It's a replaced file without local history (see issue208).
             # The base file needs to be fetched from the server.
             url = "%s/%s" % (self.svn_base, filename)
             base_content = RunShell(["svn", "cat", url],
                                     universal_newlines=universal_newlines,
                                     silent_ok=True)
           elif ret_code:
             ErrorExit("Got error status from 'svn cat %s'" % filename)
         if not is_binary:
@@ skipping 93 matching lines @@
     # --no-ext-diff is broken in some versions of Git, so try to work around
     # this by overriding the environment (but there is still a problem if the
     # git config key "diff.external" is used).
     env = os.environ.copy()
     if 'GIT_EXTERNAL_DIFF' in env: del env['GIT_EXTERNAL_DIFF']
     # -M/-C will not print the diff for the deleted file when a file is renamed.
     # This is confusing because the original file will not be shown on the
     # review when a file is renamed. So first get the diff of all deleted files,
     # then the diff of everything except deleted files with rename and copy
     # support enabled.
-    cmd = ["git", "diff", "--no-ext-diff", "--full-index"]
+    cmd = [
+        "git", "diff", "--no-ext-diff", "--full-index", "--ignore-submodules"
+    ]
     diff = RunShell(cmd + ["--diff-filter=D"] + extra_args, env=env,
         silent_ok=True)
     diff += RunShell(cmd + ["-C", "--diff-filter=ACMRT"] + extra_args, env=env,
         silent_ok=True)
     if not diff:
       ErrorExit("No output from %s" % (cmd + extra_args))
     return diff
 
   def GetUnknownFiles(self):
     status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
                       silent_ok=True)
     return status.splitlines()
 
   def GetFileContent(self, file_hash, is_binary):
     """Returns the content of a file identified by its git hash."""
     data, retcode = RunShellWithReturnCode(["git", "show", file_hash],
                                             universal_newlines=not is_binary)
     if retcode:
       ErrorExit("Got error status from 'git show %s'" % file_hash)
     return data
 
   def GetBaseFile(self, filename):
     hash_before, hash_after = self.hashes.get(filename, (None,None))
     base_content = None
     new_content = None
-    is_binary = self.IsBinary(filename)
     status = None
 
     if filename in self.renames:
       status = "A +"  # Match svn attribute name for renames.
       if filename not in self.hashes:
         # If a rename doesn't change the content, we never get a hash.
         base_content = RunShell(["git", "show", "HEAD:" + filename])
     elif not hash_before:
       status = "A"
       base_content = ""
     elif not hash_after:
       status = "D"
     else:
       status = "M"
 
+    is_binary = self.IsBinaryData(base_content)
     is_image = self.IsImage(filename)
 
     # Grab the before/after content if we need it.
     # We should include file contents if it's text or it's an image.
     if not is_binary or is_image:
       # Grab the base content if we don't have it already.
       if base_content is None and hash_before:
         base_content = self.GetFileContent(hash_before, is_binary)
       # Only include the "after" file if it's an image; otherwise it
       # it is reconstructed from the diff.
@@ skipping 11 matching lines @@
 
   def GetOriginalContent_(self, filename):
     RunShell(["cvs", "up", filename], silent_ok=True)
     # TODO need detect file content encoding
     content = open(filename).read()
     return content.replace("\r\n", "\n")
 
   def GetBaseFile(self, filename):
     base_content = None
     new_content = None
-    is_binary = False
     status = "A"
 
     output, retcode = RunShellWithReturnCode(["cvs", "status", filename])
     if retcode:
       ErrorExit("Got error status from 'cvs status %s'" % filename)
 
     if output.find("Status: Locally Modified") != -1:
       status = "M"
       temp_filename = "%s.tmp123" % filename
       os.rename(filename, temp_filename)
       base_content = self.GetOriginalContent_(filename)
       os.rename(temp_filename, filename)
     elif output.find("Status: Locally Added"):
       status = "A"
       base_content = ""
     elif output.find("Status: Needs Checkout"):
       status = "D"
       base_content = self.GetOriginalContent_(filename)
 
-    return (base_content, new_content, is_binary, status)
+    return (base_content, new_content, self.IsBinaryData(base_content), status)
 
   def GenerateDiff(self, extra_args):
     cmd = ["cvs", "diff", "-u", "-N"]
     if self.options.revision:
       cmd += ["-r", self.options.revision]
 
     cmd.extend(extra_args)
     data, retcode = RunShellWithReturnCode(cmd)
     count = 0
     if retcode in [0, 1]:
@@ skipping 96 matching lines @@
       # retrieve base contents
       oldrelpath = out[1].strip()
       status = "M"
     if ":" in self.base_rev:
       base_rev = self.base_rev.split(":", 1)[0]
     else:
       base_rev = self.base_rev
     if status != "A":
       base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath],
         silent_ok=True)
-      is_binary = "\0" in base_content  # Mercurial's heuristic
+      is_binary = self.IsBinaryData(base_content)
     if status != "R":
       new_content = open(relpath, "rb").read()
-      is_binary = is_binary or "\0" in new_content
+      is_binary = is_binary or self.IsBinaryData(new_content)
     if is_binary and base_content:
       # Fetch again without converting newlines
       base_content = RunShell(["hg", "cat", "-r", base_rev, oldrelpath],
         silent_ok=True, universal_newlines=False)
     if not is_binary or not self.IsImage(relpath):
       new_content = None
     return base_content, new_content, is_binary, status
 
 
 class PerforceVCS(VersionControlSystem):
   """Implementation of the VersionControlSystem interface for Perforce."""
 
   def __init__(self, options):
-    
+
     def ConfirmLogin():
       # Make sure we have a valid perforce session
       while True:
         data, retcode = self.RunPerforceCommandWithReturnCode(
             ["login", "-s"], marshal_output=True)
         if not data:
           ErrorExit("Error checking perforce login")
         if not retcode and (not "code" in data or data["code"] != "error"):
           break
         print "Enter perforce password: "
         self.RunPerforceCommandWithReturnCode(["login"])
-      
+
     super(PerforceVCS, self).__init__(options)
-    
+
     self.p4_changelist = options.p4_changelist
     if not self.p4_changelist:
       ErrorExit("A changelist id is required")
     if (options.revision):
       ErrorExit("--rev is not supported for perforce")
-    
+
     self.p4_port = options.p4_port
     self.p4_client = options.p4_client
     self.p4_user = options.p4_user
-    
+
     ConfirmLogin()
-    
+
     if not options.message:
       description = self.RunPerforceCommand(["describe", self.p4_changelist],
                                             marshal_output=True)
       if description and "desc" in description:
         # Rietveld doesn't support multi-line descriptions
         raw_message = description["desc"].strip()
         lines = raw_message.splitlines()
         if len(lines):
           options.message = lines[0]
-  
+
   def RunPerforceCommandWithReturnCode(self, extra_args, marshal_output=False,
                                        universal_newlines=True):
     args = ["p4"]
     if marshal_output:
       # -G makes perforce format its output as marshalled python objects
       args.extend(["-G"])
     if self.p4_port:
       args.extend(["-p", self.p4_port])
     if self.p4_client:
       args.extend(["-c", self.p4_client])
     if self.p4_user:
       args.extend(["-u", self.p4_user])
     args.extend(extra_args)
-    
+
     data, retcode = RunShellWithReturnCode(
         args, print_output=False, universal_newlines=universal_newlines)
     if marshal_output and data:
       data = marshal.loads(data)
     return data, retcode
-    
+
   def RunPerforceCommand(self, extra_args, marshal_output=False,
                          universal_newlines=True):
     # This might be a good place to cache call results, since things like
     # describe or fstat might get called repeatedly.
     data, retcode = self.RunPerforceCommandWithReturnCode(
         extra_args, marshal_output, universal_newlines)
     if retcode:
       ErrorExit("Got error status from %s:\n%s" % (extra_args, data))
     return data
 
   def GetFileProperties(self, property_key_prefix = "", command = "describe"):
     description = self.RunPerforceCommand(["describe", self.p4_changelist],
                                           marshal_output=True)
-    
+
     changed_files = {}
     file_index = 0
     # Try depotFile0, depotFile1, ... until we don't find a match
     while True:
       file_key = "depotFile%d" % file_index
       if file_key in description:
         filename = description[file_key]
         change_type = description[property_key_prefix + str(file_index)]
         changed_files[filename] = change_type
         file_index += 1
       else:
         break
     return changed_files
 
   def GetChangedFiles(self):
     return self.GetFileProperties("action")
 
   def GetUnknownFiles(self):
     # Perforce doesn't detect new files, they have to be explicitly added
     return []
 
   def IsBaseBinary(self, filename):
     base_filename = self.GetBaseFilename(filename)
     return self.IsBinaryHelper(base_filename, "files")
 
   def IsPendingBinary(self, filename):
     return self.IsBinaryHelper(filename, "describe")
 
-  def IsBinary(self, filename):
-    ErrorExit("IsBinary is not safe: call IsBaseBinary or IsPendingBinary")
-
   def IsBinaryHelper(self, filename, command):
     file_types = self.GetFileProperties("type", command)
     if not filename in file_types:
       ErrorExit("Trying to check binary status of unknown file %s." % filename)
     # This treats symlinks, macintosh resource files, temporary objects, and
     # unicode as binary. See the Perforce docs for more details:
     # http://www.perforce.com/perforce/doc.current/manuals/cmdref/o.ftypes.html
     return not file_types[filename].endswith("text")
 
   def GetFileContent(self, filename, revision, is_binary):
     file_arg = filename
     if revision:
       file_arg += "#" + revision
     # -q suppresses the initial line that displays the filename and revision
     return self.RunPerforceCommand(["print", "-q", file_arg],
                                    universal_newlines=not is_binary)
 
   def GetBaseFilename(self, filename):
     actionsWithDifferentBases = [
         "move/add", # p4 move
         "branch", # p4 integrate (to a new file), similar to hg "add"
         "add", # p4 integrate (to a new file), after modifying the new file
     ]
-    
+
     # We only see a different base for "add" if this is a downgraded branch
-    # after a file was branched (integrated), then edited. 
+    # after a file was branched (integrated), then edited.
     if self.GetAction(filename) in actionsWithDifferentBases:
       # -Or shows information about pending integrations/moves
       fstat_result = self.RunPerforceCommand(["fstat", "-Or", filename],
                                              marshal_output=True)
-      
+
       baseFileKey = "resolveFromFile0" # I think it's safe to use only file0
       if baseFileKey in fstat_result:
         return fstat_result[baseFileKey]
-    
+
     return filename
 
   def GetBaseRevision(self, filename):
     base_filename = self.GetBaseFilename(filename)
-    
+
     have_result = self.RunPerforceCommand(["have", base_filename],
                                           marshal_output=True)
     if "haveRev" in have_result:
       return have_result["haveRev"]
-    
+
   def GetLocalFilename(self, filename):
     where = self.RunPerforceCommand(["where", filename], marshal_output=True)
     if "path" in where:
       return where["path"]
 
-  def GenerateDiff(self, args): 
+  def GenerateDiff(self, args):
     class DiffData:
       def __init__(self, perforceVCS, filename, action):
         self.perforceVCS = perforceVCS
         self.filename = filename
         self.action = action
         self.base_filename = perforceVCS.GetBaseFilename(filename)
-        
+
         self.file_body = None
         self.base_rev = None
         self.prefix = None
         self.working_copy = True
         self.change_summary = None
-         
+
     def GenerateDiffHeader(diffData):
       header = []
       header.append("Index: %s" % diffData.filename)
       header.append("=" * 67)
-      
+
       if diffData.base_filename != diffData.filename:
         if diffData.action.startswith("move"):
           verb = "rename"
         else:
           verb = "copy"
         header.append("%s from %s" % (verb, diffData.base_filename))
         header.append("%s to %s" % (verb, diffData.filename))
-        
+
       suffix = "\t(revision %s)" % diffData.base_rev
       header.append("--- " + diffData.base_filename + suffix)
       if diffData.working_copy:
         suffix = "\t(working copy)"
       header.append("+++ " + diffData.filename + suffix)
       if diffData.change_summary:
         header.append(diffData.change_summary)
       return header
-  
+
     def GenerateMergeDiff(diffData, args):
       # -du generates a unified diff, which is nearly svn format
       diffData.file_body = self.RunPerforceCommand(
           ["diff", "-du", diffData.filename] + args)
       diffData.base_rev = self.GetBaseRevision(diffData.filename)
       diffData.prefix = ""
-      
+
       # We have to replace p4's file status output (the lines starting
       # with +++ or ---) to match svn's diff format
       lines = diffData.file_body.splitlines()
       first_good_line = 0
       while (first_good_line < len(lines) and
             not lines[first_good_line].startswith("@@")):
         first_good_line += 1
       diffData.file_body = "\n".join(lines[first_good_line:])
       return diffData
 
     def GenerateAddDiff(diffData):
       fstat = self.RunPerforceCommand(["fstat", diffData.filename],
                                       marshal_output=True)
       if "headRev" in fstat:
         diffData.base_rev = fstat["headRev"] # Re-adding a deleted file
       else:
         diffData.base_rev = "0" # Brand new file
       diffData.working_copy = False
       rel_path = self.GetLocalFilename(diffData.filename)
       diffData.file_body = open(rel_path, 'r').read()
       # Replicate svn's list of changed lines
       line_count = len(diffData.file_body.splitlines())
       diffData.change_summary = "@@ -0,0 +1"
       if line_count > 1:
           diffData.change_summary += ",%d" % line_count
       diffData.change_summary += " @@"
       diffData.prefix = "+"
       return diffData
-    
+
     def GenerateDeleteDiff(diffData):
       diffData.base_rev = self.GetBaseRevision(diffData.filename)
       is_base_binary = self.IsBaseBinary(diffData.filename)
       # For deletes, base_filename == filename
-      diffData.file_body = self.GetFileContent(diffData.base_filename, 
-          None, 
+      diffData.file_body = self.GetFileContent(diffData.base_filename,
+          None,
           is_base_binary)
       # Replicate svn's list of changed lines
       line_count = len(diffData.file_body.splitlines())
       diffData.change_summary = "@@ -1"
       if line_count > 1:
         diffData.change_summary += ",%d" % line_count
       diffData.change_summary += " +0,0 @@"
       diffData.prefix = "-"
       return diffData
-  
+
     changed_files = self.GetChangedFiles()
-    
+
     svndiff = []
     filecount = 0
     for (filename, action) in changed_files.items():
       svn_status = self.PerforceActionToSvnStatus(action)
       if svn_status == "SKIP":
         continue
-    
+
       diffData = DiffData(self, filename, action)
       # Is it possible to diff a branched file? Stackoverflow says no:
       # http://stackoverflow.com/questions/1771314/in-perforce-command-line-how-to-diff-a-file-reopened-for-add
       if svn_status == "M":
         diffData = GenerateMergeDiff(diffData, args)
       elif svn_status == "A":
         diffData = GenerateAddDiff(diffData)
       elif svn_status == "D":
         diffData = GenerateDeleteDiff(diffData)
       else:
         ErrorExit("Unknown file action %s (svn action %s)." % \
                   (action, svn_status))
-      
+
       svndiff += GenerateDiffHeader(diffData)
-      
+
       for line in diffData.file_body.splitlines():
         svndiff.append(diffData.prefix + line)
       filecount += 1
     if not filecount:
       ErrorExit("No valid patches found in output from p4 diff")
     return "\n".join(svndiff) + "\n"
 
   def PerforceActionToSvnStatus(self, status):
     # Mirroring the list at http://permalink.gmane.org/gmane.comp.version-control.mercurial.devel/28717
     # Is there something more official?
     return {
             "add" : "A",
             "branch" : "A",
             "delete" : "D",
             "edit" : "M", # Also includes changing file types.
             "integrate" : "M",
             "move/add" : "M",
             "move/delete": "SKIP",
             "purge" : "D", # How does a file's status become "purge"?
             }[status]
 
   def GetAction(self, filename):
     changed_files = self.GetChangedFiles()
     if not filename in changed_files:
       ErrorExit("Trying to get base version of unknown file %s." % filename)
-      
+
     return changed_files[filename]
 
   def GetBaseFile(self, filename):
     base_filename = self.GetBaseFilename(filename)
     base_content = ""
     new_content = None
-    
+
     status = self.PerforceActionToSvnStatus(self.GetAction(filename))
-    
+
     if status != "A":
       revision = self.GetBaseRevision(base_filename)
       if not revision:
         ErrorExit("Couldn't find base revision for file %s" % filename)
       is_base_binary = self.IsBaseBinary(base_filename)
       base_content = self.GetFileContent(base_filename,
                                          revision,
                                          is_base_binary)
-    
+
     is_binary = self.IsPendingBinary(filename)
     if status != "D" and status != "SKIP":
       relpath = self.GetLocalFilename(filename)
       if is_binary and self.IsImage(relpath):
         new_content = open(relpath, "rb").read()
-    
+
     return base_content, new_content, is_binary, status
 
 # NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
 def SplitPatch(data):
   """Splits a patch into separate pieces for each file.
 
   Args:
     data: A string containing the output of svn diff.
 
   Returns:
@@ skipping 69 matching lines @@
     and is one of VCS_GIT, VCS_MERCURIAL, VCS_SUBVERSION, VCS_PERFORCE,
     VCS_CVS, or VCS_UNKNOWN.
     Since local perforce repositories can't be easily detected, this method
     will only guess VCS_PERFORCE if any perforce options have been specified.
     output is a string containing any interesting output from the vcs
     detection routine, or None if there is nothing interesting.
   """
   for attribute, value in options.__dict__.iteritems():
     if attribute.startswith("p4") and value != None:
       return (VCS_PERFORCE, None)
-  
+
   def RunDetectCommand(vcs_type, command):
     """Helper to detect VCS by executing command.
-    
+
     Returns:
        A pair (vcs, output) or None. Throws exception on error.
     """
     try:
       out, returncode = RunShellWithReturnCode(command)
       if returncode == 0:
         return (vcs_type, out.strip())
     except OSError, (errcode, message):
       if errcode != errno.ENOENT:  # command not found code
         raise
-  
+
   # Mercurial has a command to get the base directory of a repository
   # Try running it, but don't die if we don't have hg installed.
   # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
   res = RunDetectCommand(VCS_MERCURIAL, ["hg", "root"])
   if res != None:
     return res
 
   # Subversion has a .svn in all working directories.
   if os.path.isdir('.svn'):
     logging.info("Guessed VCS = Subversion")
@@ skipping 281 matching lines @@
       checksum = md5(info[0]).hexdigest()
       if base_hashes:
         base_hashes += "|"
       base_hashes += checksum + ":" + file
   form_fields.append(("base_hashes", base_hashes))
   if options.private:
     if options.issue:
       print "Warning: Private flag ignored when updating an existing issue."
     else:
       form_fields.append(("private", "1"))
+  if options.send_patch:
+    options.send_mail = True
   # If we're uploading base files, don't send the email before the uploads, so
   # that it contains the file status.
   if options.send_mail and options.download_base:
     form_fields.append(("send_mail", "1"))
   if not options.download_base:
     form_fields.append(("content_upload", "1"))
   if len(data) > MAX_UPLOAD_SIZE:
     print "Patch is large, so uploading file patches separately."
     uploaded_diff_file = []
     form_fields.append(("separate_patches", "1"))
@@ skipping 19 matching lines @@
   issue = msg[msg.rfind("/")+1:]
 
   if not uploaded_diff_file:
     result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
     if not options.download_base:
       patches = result
 
   if not options.download_base:
     vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
     if options.send_mail:
-      rpc_server.Send("/" + issue + "/mail", payload="")
+      payload = ""
+      if options.send_patch:
+        payload=urllib.urlencode({"attach_patch": "yes"})
+      rpc_server.Send("/" + issue + "/mail", payload=payload)
   return issue, patchset
 
 
 def main():
   try:
     logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
                                 "%(lineno)s %(message)s "))
     os.environ['LC_ALL'] = 'C'
     RealMain(sys.argv)
   except KeyboardInterrupt:
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()