Sync git-cl and git-try to the master branch.

git-cl.py

 #!/usr/bin/python
 # git-cl -- a git-command for integrating reviews on Rietveld
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 import getpass
 import optparse
 import os
 import re
-import readline
 import subprocess
 import sys
 import tempfile
 import textwrap
 import upload
 import urllib2
 
+try:
+  import readline
+except ImportError:
+  pass
+
 DEFAULT_SERVER = 'codereview.appspot.com'
 
 def DieWithError(message):
   print >>sys.stderr, message
   sys.exit(1)
 
 
-def RunGit(args, error_ok=False, error_message=None, exit_code=False):
+def RunGit(args, error_ok=False, error_message=None, exit_code=False,
+           redirect_stdout=True):
   cmd = ['git'] + args
   # Useful for debugging:
   # print >>sys.stderr, ' '.join(cmd)
-  proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+  if redirect_stdout:
+    stdout = subprocess.PIPE
+  else:
+    stdout = None
+  proc = subprocess.Popen(cmd, stdout=stdout)
   output = proc.communicate()[0]
   if exit_code:
     return proc.returncode
   if not error_ok and proc.returncode != 0:
     DieWithError('Command "%s" failed.\n' % (' '.join(cmd)) +
                  (error_message or output))
   return output
 
 
 class Settings:
@@ skipping 40 matching lines @@
       # 2) iterate through our branch history and match up the URLs.
 
       # regexp matching the git-svn line that contains the URL.
       git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE)
 
       # Get the refname and svn url for all refs/remotes/*.
       remotes = RunGit(['for-each-ref', '--format=%(refname)',
                         'refs/remotes']).splitlines()
       svn_refs = {}
       for ref in remotes:
-        # git-svn remote refs are generally directly in the refs/remotes/dir,
-        # not a subdirectory (like refs/remotes/origin/master).
-        if '/' in ref[len('refs/remotes/'):]:
-          continue
         match = git_svn_re.search(RunGit(['cat-file', '-p', ref]))
         if match:
           svn_refs[match.group(1)] = ref
 
       if len(svn_refs) == 1:
         # Only one svn branch exists -- seems like a good candidate.
         self.svn_branch = svn_refs.values()[0]
       elif len(svn_refs) > 1:
         # We have more than one remote branch available.  We don't
         # want to go through all of history, so read a line from the
@@ skipping 267 matching lines @@
 
   file = tempfile.NamedTemporaryFile()
   filename = file.name
   file.write(starting_text)
   file.flush()
 
   ret = subprocess.call(editor + ' ' + filename, shell=True)
   if ret != 0:
     return
 
-  text = open(filename).read()
+  file.flush()
+  file.seek(0)
+  text = file.read()
   file.close()
   stripcomment_re = re.compile(r'^#.*$', re.MULTILINE)
   return stripcomment_re.sub('', text).strip()
 
 
 def CmdUpload(args):
   parser = optparse.OptionParser(
       usage='git cl upload [options] [args to "git diff"]')
   parser.add_option('-m', dest='message', help='message for patch')
   parser.add_option('-r', '--reviewers',
@@ skipping 123 matching lines @@
 
   # We want to squash all this branch's commits into one commit with the
   # proper description.
   # We do this by doing a "merge --squash" into a new commit branch, then
   # dcommitting that.
   MERGE_BRANCH = 'git-cl-commit'
   # Delete the merge branch if it already exists.
   if RunGit(['show-ref', '--quiet', '--verify', 'refs/heads/' + MERGE_BRANCH],
             exit_code=True) == 0:
     RunGit(['branch', '-D', MERGE_BRANCH])
+
+  # We might be in a directory that's present in this branch but not in the
+  # trunk.  Move up to the top of the tree so that git commands that expect a
+  # valid CWD won't fail after we check out the merge branch.
+  rel_base_path = RunGit(['rev-parse', '--show-cdup']).strip()
+  if rel_base_path:
+    os.chdir(rel_base_path)
+
   # Stuff our change into the merge branch.
   RunGit(['checkout', '-q', '-b', MERGE_BRANCH, base_branch])
   RunGit(['merge', '--squash', cl.GetBranchRef()])
   RunGit(['commit', '-m', description])
   # dcommit the merge branch.
   output = RunGit(['svn', 'dcommit'])
   # And then swap back to the original branch and clean up.
   RunGit(['checkout', '-q', cl.GetBranch()])
   RunGit(['branch', '-D', MERGE_BRANCH])
   if output.find("Committed r") != -1:
@@ skipping 77 matching lines @@
     RunGit(['commit', '-m', 'patch from issue %s' % issue])
     cl = Changelist()
     cl.SetIssue(issue)
     print "Committed patch."
   else:
     print "Patch applied to index."
 
 def CmdRebase(args):
   # Provide a wrapper for git svn rebase to help avoid accidental
   # git svn dcommit.
-  RunGit(['svn', 'rebase'])
+  RunGit(['svn', 'rebase'], redirect_stdout=False)
 
 def GetTreeStatus():
   """Fetches the tree status and returns either 'open', 'closed',
   'unknown' or 'unset'."""
   url = settings.GetTreeStatusUrl(error_ok=True)
   if url:
     status = urllib2.urlopen(url).read().lower()
     if status.find('closed') != -1:
       return 'closed'
     elif status.find('open') != -1:
@@ skipping 41 matching lines @@
   command = argv[1]
   for name, _, func in COMMANDS:
     if name == command:
       return func(argv[2:])
   print 'unknown command: %s' % command
   Usage(argv[0])
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))