Bazaar Support For upload.py

static/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
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Tool for uploading diffs from a version control system to the codereview app.
 
 Usage summary: upload.py [options] [-- diff_options]
 
 Diff options are passed to the diff command of the underlying system.
 
 Supported version control systems:
+  Bazaar
   Git
   Mercurial
   Subversion
 
 It is important for Git/Mercurial users to specify a tree/node/branch to diff
 against by using the '--rev' option.
 """
 # This code is derived from appcfg.py in the App Engine SDK (open source),
 # and from ASPN recipe #146306.
 
@@ skipping 534 matching lines @@
   p.wait()
   errout = p.stderr.read()
   if print_output and errout:
     print >>sys.stderr, errout
   p.stdout.close()
   p.stderr.close()
   return output, p.returncode
 
 
 def RunShell(command, silent_ok=False, universal_newlines=True,
-             print_output=False):
+             print_output=False,check_returncode=True):
   data, retcode = RunShellWithReturnCode(command, print_output,
                                          universal_newlines)
-  if retcode:
+  
+  if retcode and check_returncode:
     ErrorExit("Got error status from %s:\n%s" % (command, data))
   if not silent_ok and not data:
     ErrorExit("No output from %s" % command)
   return data
 
 
 class VersionControlSystem(object):
   """Abstract base class providing an interface to the VCS."""
 
   def __init__(self, options):
@@ skipping 42 matching lines @@
         is_binary: True iff the file is binary.
         status: The status of the file.
     """
 
     raise NotImplementedError(
         "abstract method -- subclass %s must override" % self.__class__)
 
 
   def GetBaseFiles(self, diff):
     """Helper that calls GetBase file for each file in the patch.
-
+    
     Returns:
       A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
       are retrieved based on lines that start with "Index:" or
       "Property changes on:".
     """
     files = {}
     for line in diff.splitlines(True):
       if line.startswith('Index:') or line.startswith('Property changes on:'):
         unused, filename = line.split(':', 1)
         # On Windows if a file has property changes its filename uses '\'
@@ skipping 453 matching lines @@
     is_binary = False
     oldrelpath = relpath = self._GetRelPath(filename)
     # "hg status -C" returns two lines for moved/copied files, one otherwise
     out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
     out = out.splitlines()
     # HACK: strip error message about missing file/directory if it isn't in
     # the working copy
     if out[0].startswith('%s: ' % relpath):
       out = out[1:]
     if len(out) > 1:
-      # Moved/copied => considered as modified, use old filename to
+      # Moved/copied => considered as modified, use old filename to 
       # retrieve base contents
       oldrelpath = out[1].strip()
       status = "M"
     else:
       status, _ = out[0].split(' ', 1)
     if status != "A":
       base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
         silent_ok=True)
       is_binary = "\0" in base_content  # Mercurial's heuristic
     if status != "R":
       new_content = open(relpath, "rb").read()
       is_binary = is_binary or "\0" in new_content
     if is_binary and base_content:
       # Fetch again without converting newlines
       base_content = RunShell(["hg", "cat", "-r", self.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 BazaarVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Bazaar."""
+
+  def GenerateDiff(self, args):
+    """Return the current diff as a string.
+
+    Args:
+      args: Extra arguments to pass to the diff command.
+    """
+    if self.options.revision:
+      args = ["-r", self.options.revision] + args
+    # We need check_returncode = False because bzr diff returns 1 if changes
+    # are found.
+
+    data,retcode = RunShellWithReturnCode(["bzr", "diff"] + args, True)
+    filecount = 0
+    lines = data.splitlines()
+    for i, line in enumerate(lines):
+      match = re.match(r"^=== (added|removed|modified) file '(.*)'$", line)
+      if match:
+        # Modify line to make it look like as it comes from svn diff.
+        lines[i] = "Index: %s" % match.group(2)
+        filecount += 1
+        logging.info(line)
+    if not filecount:
+      ErrorExit("No valid patches found in output from bzr diff")
+    return "\n".join(lines)
+
+  def GetUnknownFiles(self):
+    """Return a list of files unknown to the VCS."""
+    args = ["-S"]
+    if self.options.revision:
+      args += ["-r", self.options.revision]
+    status = RunShell(["bzr", "status"] + args, silent_ok=True)
+    unknown_files = []
+    for line in status.splitlines():
+      if line and line[0] == "?":
+        unknown_files.append(line)
+    return unknown_files
+
+  def GetBaseFile(self, filename):
+    """Get the content of the upstream version of a file.
+
+    Returns:
+      A tuple (content, status) representing the file content and the status of
+      the file.
+    """
+    st_args = []
+    cat_args = []
+    new_content = None
+    if self.options.revision:
+      if '..' in self.options.revision:
+        start_rev = self.options.revision.split('..', 1)[0]
+        cat_args += ["-r", start_rev]
+      else:
+        cat_args += ["-r", self.options.revision]
+      st_args += ["-r", self.options.revision]
+    status = RunShell(["bzr", "status", "-S"] + st_args + [filename])
+    if status[1] == "N":
+      content = ""
+    else:
+      content = RunShell(["bzr", "cat"] + cat_args + [filename])
+    return content, new_content, False, status[0:4]
 
 
 # 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 71 matching lines @@
   # 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.
   try:
     out, returncode = RunShellWithReturnCode(["hg", "root"])
     if returncode == 0:
       return MercurialVCS(options, out.strip())
   except OSError, (errno, message):
     if errno != 2:  # ENOENT -- they don't have hg installed.
       raise
-
+  try:

[bialix, 2009/03/24 22:49:23]

I think you need either use command ["bzr", "--no-plugins", "root"] OR move bzr
detection down to the end of this function, at least it should be after
hg/svn/git. Because if user has bzr-svn or bzr-git plugin installed, then bzr
can open foreign branches and provide support for them.

Other changes looks good for me.

+    out, returncode = RunShellWithReturnCode(["bzr", "root"])
+    if returncode == 0:
+      os.chdir(out.strip())
+      return BazaarVCS(options)
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have bzr installed.
+      raise
   # Subversion has a .svn in all working directories.
   if os.path.isdir('.svn'):
     logging.info("Guessed VCS = Subversion")
     return SubversionVCS(options)
-
+  
   # Git has a command to test if you're in a git tree.
   # Try running it, but don't die if we don't have git installed.
   try:
     out, returncode = RunShellWithReturnCode(["git", "rev-parse",
                                               "--is-inside-work-tree"])
     if returncode == 0:
       return GitVCS(options)
   except OSError, (errno, message):
     if errno != 2:  # ENOENT -- they don't have git installed.
       raise
 
   ErrorExit(("Could not guess version control system. "
              "Are you in a working copy directory?"))
 
 
 def RealMain(argv, data=None):
-  """The real main function.
-
-  Args:
-    argv: Command line arguments.
-    data: Diff contents. If None (default) the diff is generated by
-      the VersionControlSystem implementation returned by GuessVCS().
-
-  Returns:
-    A 2-tuple (issue id, patchset id).
-    The patchset id is None if the base files are not uploaded by this
-    script (applies only to SVN checkouts).
-  """
   logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
                               "%(lineno)s %(message)s "))
   os.environ['LC_ALL'] = 'C'
   options, args = parser.parse_args(argv[1:])
   global verbosity
   verbosity = options.verbose
   if verbosity >= 3:
     logging.getLogger().setLevel(logging.DEBUG)
   elif verbosity >= 2:
     logging.getLogger().setLevel(logging.INFO)
@@ skipping 65 matching lines @@
   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"))
   else:
     uploaded_diff_file = [("data", "data.diff", data)]
   ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
   response_body = rpc_server.Send("/upload", body, content_type=ctype)
-  patchset = None
   if not options.download_base or not uploaded_diff_file:
     lines = response_body.splitlines()
     if len(lines) >= 2:
       msg = lines[0]
       patchset = lines[1].strip()
       patches = [x.split(" ", 1) for x in lines[2:]]
     else:
       msg = response_body
   else:
     msg = response_body
@@ skipping 19 matching lines @@
   try:
     RealMain(sys.argv)
   except KeyboardInterrupt:
     print
     StatusUpdate("Interrupted.")
     sys.exit(1)
 
 
 if __name__ == "__main__":
   main()