Move git-cl into depot_tools.
BUG=none
TEST=git-cl works after move
Review URL: http://codereview.chromium.org/5012006
git-svn-id: svn://svn.chromium.org/chrome/trunk/tools/depot_tools@70011 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/git_cl/git_cl.py b/git_cl/git_cl.py
new file mode 100644
index 0000000..ea12382
--- /dev/null
+++ b/git_cl/git_cl.py
@@ -0,0 +1,1254 @@
+#!/usr/bin/python
+# git-cl -- a git-command for integrating reviews on Rietveld
+# Copyright (C) 2008 Evan Martin <martine@danga.com>
+
+import errno
+import logging
+import optparse
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import textwrap
+import upload
+import urllib2
+
+try:
+ import readline
+except ImportError:
+ pass
+
+try:
+ # Add the parent directory in case it's a depot_tools checkout.
+ depot_tools_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ sys.path.append(depot_tools_path)
+ import breakpad
+except ImportError:
+ pass
+
+DEFAULT_SERVER = 'http://codereview.appspot.com'
+PREDCOMMIT_HOOK = '.git/hooks/pre-cl-dcommit'
+PREUPLOAD_HOOK = '.git/hooks/pre-cl-upload'
+DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
+
+def DieWithError(message):
+ print >>sys.stderr, message
+ sys.exit(1)
+
+
+def Popen(cmd, **kwargs):
+ """Wrapper for subprocess.Popen() that logs and watch for cygwin issues"""
+ logging.info('Popen: ' + ' '.join(cmd))
+ try:
+ return subprocess.Popen(cmd, **kwargs)
+ except OSError, e:
+ if e.errno == errno.EAGAIN and sys.platform == 'cygwin':
+ DieWithError(
+ 'Visit '
+ 'http://code.google.com/p/chromium/wiki/CygwinDllRemappingFailure to '
+ 'learn how to fix this error; you need to rebase your cygwin dlls')
+ raise
+
+
+def RunCommand(cmd, error_ok=False, error_message=None,
+ redirect_stdout=True, swallow_stderr=False):
+ if redirect_stdout:
+ stdout = subprocess.PIPE
+ else:
+ stdout = None
+ if swallow_stderr:
+ stderr = subprocess.PIPE
+ else:
+ stderr = None
+ proc = Popen(cmd, stdout=stdout, stderr=stderr)
+ output = proc.communicate()[0]
+ if not error_ok and proc.returncode != 0:
+ DieWithError('Command "%s" failed.\n' % (' '.join(cmd)) +
+ (error_message or output or ''))
+ return output
+
+
+def RunGit(args, **kwargs):
+ cmd = ['git'] + args
+ return RunCommand(cmd, **kwargs)
+
+
+def RunGitWithCode(args):
+ proc = Popen(['git'] + args, stdout=subprocess.PIPE)
+ output = proc.communicate()[0]
+ return proc.returncode, output
+
+
+def usage(more):
+ def hook(fn):
+ fn.usage_more = more
+ return fn
+ return hook
+
+
+def FixUrl(server):
+ """Fix a server url to defaults protocol to http:// if none is specified."""
+ if not server:
+ return server
+ if not re.match(r'[a-z]+\://.*', server):
+ return 'http://' + server
+ return server
+
+
+class Settings(object):
+ def __init__(self):
+ self.default_server = None
+ self.cc = None
+ self.root = None
+ self.is_git_svn = None
+ self.svn_branch = None
+ self.tree_status_url = None
+ self.viewvc_url = None
+ self.updated = False
+
+ def LazyUpdateIfNeeded(self):
+ """Updates the settings from a codereview.settings file, if available."""
+ if not self.updated:
+ cr_settings_file = FindCodereviewSettingsFile()
+ if cr_settings_file:
+ LoadCodereviewSettingsFromFile(cr_settings_file)
+ self.updated = True
+
+ def GetDefaultServerUrl(self, error_ok=False):
+ if not self.default_server:
+ self.LazyUpdateIfNeeded()
+ self.default_server = FixUrl(self._GetConfig('rietveld.server',
+ error_ok=True))
+ if error_ok:
+ return self.default_server
+ if not self.default_server:
+ error_message = ('Could not find settings file. You must configure '
+ 'your review setup by running "git cl config".')
+ self.default_server = FixUrl(self._GetConfig(
+ 'rietveld.server', error_message=error_message))
+ return self.default_server
+
+ def GetCCList(self):
+ """Return the users cc'd on this CL.
+
+ Return is a string suitable for passing to gcl with the --cc flag.
+ """
+ if self.cc is None:
+ self.cc = self._GetConfig('rietveld.cc', error_ok=True)
+ more_cc = self._GetConfig('rietveld.extracc', error_ok=True)
+ if more_cc is not None:
+ self.cc += ',' + more_cc
+ return self.cc
+
+ def GetRoot(self):
+ if not self.root:
+ self.root = os.path.abspath(RunGit(['rev-parse', '--show-cdup']).strip())
+ return self.root
+
+ def GetIsGitSvn(self):
+ """Return true if this repo looks like it's using git-svn."""
+ if self.is_git_svn is None:
+ # If you have any "svn-remote.*" config keys, we think you're using svn.
+ self.is_git_svn = RunGitWithCode(
+ ['config', '--get-regexp', r'^svn-remote\.'])[0] == 0
+ return self.is_git_svn
+
+ def GetSVNBranch(self):
+ if self.svn_branch is None:
+ if not self.GetIsGitSvn():
+ DieWithError('Repo doesn\'t appear to be a git-svn repo.')
+
+ # Try to figure out which remote branch we're based on.
+ # Strategy:
+ # 1) find all git-svn branches and note their svn URLs.
+ # 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:
+ match = git_svn_re.search(RunGit(['cat-file', '-p', ref]))
+ # Prefer origin/HEAD over all others.
+ if match and (match.group(1) not in svn_refs or
+ ref == "refs/remotes/origin/HEAD"):
+ 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
+ # pipe at a time.
+ # The -100 is an arbitrary limit so we don't search forever.
+ cmd = ['git', 'log', '-100', '--pretty=medium']
+ proc = Popen(cmd, stdout=subprocess.PIPE)
+ for line in proc.stdout:
+ match = git_svn_re.match(line)
+ if match:
+ url = match.group(1)
+ if url in svn_refs:
+ self.svn_branch = svn_refs[url]
+ proc.stdout.close() # Cut pipe.
+ break
+
+ if not self.svn_branch:
+ DieWithError('Can\'t guess svn branch -- try specifying it on the '
+ 'command line')
+
+ return self.svn_branch
+
+ def GetTreeStatusUrl(self, error_ok=False):
+ if not self.tree_status_url:
+ error_message = ('You must configure your tree status URL by running '
+ '"git cl config".')
+ self.tree_status_url = self._GetConfig('rietveld.tree-status-url',
+ error_ok=error_ok,
+ error_message=error_message)
+ return self.tree_status_url
+
+ def GetViewVCUrl(self):
+ if not self.viewvc_url:
+ self.viewvc_url = self._GetConfig('rietveld.viewvc-url', error_ok=True)
+ return self.viewvc_url
+
+ def _GetConfig(self, param, **kwargs):
+ self.LazyUpdateIfNeeded()
+ return RunGit(['config', param], **kwargs).strip()
+
+
+settings = Settings()
+
+
+did_migrate_check = False
+def CheckForMigration():
+ """Migrate from the old issue format, if found.
+
+ We used to store the branch<->issue mapping in a file in .git, but it's
+ better to store it in the .git/config, since deleting a branch deletes that
+ branch's entry there.
+ """
+
+ # Don't run more than once.
+ global did_migrate_check
+ if did_migrate_check:
+ return
+
+ gitdir = RunGit(['rev-parse', '--git-dir']).strip()
+ storepath = os.path.join(gitdir, 'cl-mapping')
+ if os.path.exists(storepath):
+ print "old-style git-cl mapping file (%s) found; migrating." % storepath
+ store = open(storepath, 'r')
+ for line in store:
+ branch, issue = line.strip().split()
+ RunGit(['config', 'branch.%s.rietveldissue' % ShortBranchName(branch),
+ issue])
+ store.close()
+ os.remove(storepath)
+ did_migrate_check = True
+
+
+def ShortBranchName(branch):
+ """Convert a name like 'refs/heads/foo' to just 'foo'."""
+ return branch.replace('refs/heads/', '')
+
+
+class Changelist(object):
+ def __init__(self, branchref=None):
+ # Poke settings so we get the "configure your server" message if necessary.
+ settings.GetDefaultServerUrl()
+ self.branchref = branchref
+ if self.branchref:
+ self.branch = ShortBranchName(self.branchref)
+ else:
+ self.branch = None
+ self.rietveld_server = None
+ self.upstream_branch = None
+ self.has_issue = False
+ self.issue = None
+ self.has_description = False
+ self.description = None
+ self.has_patchset = False
+ self.patchset = None
+
+ def GetBranch(self):
+ """Returns the short branch name, e.g. 'master'."""
+ if not self.branch:
+ self.branchref = RunGit(['symbolic-ref', 'HEAD']).strip()
+ self.branch = ShortBranchName(self.branchref)
+ return self.branch
+
+ def GetBranchRef(self):
+ """Returns the full branch name, e.g. 'refs/heads/master'."""
+ self.GetBranch() # Poke the lazy loader.
+ return self.branchref
+
+ def FetchUpstreamTuple(self):
+ """Returns a tuple containg remote and remote ref,
+ e.g. 'origin', 'refs/heads/master'
+ """
+ remote = '.'
+ branch = self.GetBranch()
+ upstream_branch = RunGit(['config', 'branch.%s.merge' % branch],
+ error_ok=True).strip()
+ if upstream_branch:
+ remote = RunGit(['config', 'branch.%s.remote' % branch]).strip()
+ else:
+ # Fall back on trying a git-svn upstream branch.
+ if settings.GetIsGitSvn():
+ upstream_branch = settings.GetSVNBranch()
+ else:
+ # Else, try to guess the origin remote.
+ remote_branches = RunGit(['branch', '-r']).split()
+ if 'origin/master' in remote_branches:
+ # Fall back on origin/master if it exits.
+ remote = 'origin'
+ upstream_branch = 'refs/heads/master'
+ elif 'origin/trunk' in remote_branches:
+ # Fall back on origin/trunk if it exists. Generally a shared
+ # git-svn clone
+ remote = 'origin'
+ upstream_branch = 'refs/heads/trunk'
+ else:
+ DieWithError("""Unable to determine default branch to diff against.
+Either pass complete "git diff"-style arguments, like
+ git cl upload origin/master
+or verify this branch is set up to track another (via the --track argument to
+"git checkout -b ...").""")
+
+ return remote, upstream_branch
+
+ def GetUpstreamBranch(self):
+ if self.upstream_branch is None:
+ remote, upstream_branch = self.FetchUpstreamTuple()
+ if remote is not '.':
+ upstream_branch = upstream_branch.replace('heads', 'remotes/' + remote)
+ self.upstream_branch = upstream_branch
+ return self.upstream_branch
+
+ def GetRemoteUrl(self):
+ """Return the configured remote URL, e.g. 'git://example.org/foo.git/'.
+
+ Returns None if there is no remote.
+ """
+ remote = self.FetchUpstreamTuple()[0]
+ if remote == '.':
+ return None
+ return RunGit(['config', 'remote.%s.url' % remote], error_ok=True).strip()
+
+ def GetIssue(self):
+ if not self.has_issue:
+ CheckForMigration()
+ issue = RunGit(['config', self._IssueSetting()], error_ok=True).strip()
+ if issue:
+ self.issue = issue
+ self.rietveld_server = FixUrl(RunGit(
+ ['config', self._RietveldServer()], error_ok=True).strip())
+ else:
+ self.issue = None
+ if not self.rietveld_server:
+ self.rietveld_server = settings.GetDefaultServerUrl()
+ self.has_issue = True
+ return self.issue
+
+ def GetRietveldServer(self):
+ self.GetIssue()
+ return self.rietveld_server
+
+ def GetIssueURL(self):
+ """Get the URL for a particular issue."""
+ return '%s/%s' % (self.GetRietveldServer(), self.GetIssue())
+
+ def GetDescription(self, pretty=False):
+ if not self.has_description:
+ if self.GetIssue():
+ path = '/' + self.GetIssue() + '/description'
+ rpc_server = self._RpcServer()
+ self.description = rpc_server.Send(path).strip()
+ self.has_description = True
+ if pretty:
+ wrapper = textwrap.TextWrapper()
+ wrapper.initial_indent = wrapper.subsequent_indent = ' '
+ return wrapper.fill(self.description)
+ return self.description
+
+ def GetPatchset(self):
+ if not self.has_patchset:
+ patchset = RunGit(['config', self._PatchsetSetting()],
+ error_ok=True).strip()
+ if patchset:
+ self.patchset = patchset
+ else:
+ self.patchset = None
+ self.has_patchset = True
+ return self.patchset
+
+ def SetPatchset(self, patchset):
+ """Set this branch's patchset. If patchset=0, clears the patchset."""
+ if patchset:
+ RunGit(['config', self._PatchsetSetting(), str(patchset)])
+ else:
+ RunGit(['config', '--unset', self._PatchsetSetting()],
+ swallow_stderr=True, error_ok=True)
+ self.has_patchset = False
+
+ def SetIssue(self, issue):
+ """Set this branch's issue. If issue=0, clears the issue."""
+ if issue:
+ RunGit(['config', self._IssueSetting(), str(issue)])
+ if self.rietveld_server:
+ RunGit(['config', self._RietveldServer(), self.rietveld_server])
+ else:
+ RunGit(['config', '--unset', self._IssueSetting()])
+ self.SetPatchset(0)
+ self.has_issue = False
+
+ def CloseIssue(self):
+ rpc_server = self._RpcServer()
+ # Newer versions of Rietveld require us to pass an XSRF token to POST, so
+ # we fetch it from the server. (The version used by Chromium has been
+ # modified so the token isn't required when closing an issue.)
+ xsrf_token = rpc_server.Send('/xsrf_token',
+ extra_headers={'X-Requesting-XSRF-Token': '1'})
+
+ # You cannot close an issue with a GET.
+ # We pass an empty string for the data so it is a POST rather than a GET.
+ data = [("description", self.description),
+ ("xsrf_token", xsrf_token)]
+ ctype, body = upload.EncodeMultipartFormData(data, [])
+ rpc_server.Send('/' + self.GetIssue() + '/close', body, ctype)
+
+ def _RpcServer(self):
+ """Returns an upload.RpcServer() to access this review's rietveld instance.
+ """
+ server = self.GetRietveldServer()
+ return upload.GetRpcServer(server, save_cookies=True)
+
+ def _IssueSetting(self):
+ """Return the git setting that stores this change's issue."""
+ return 'branch.%s.rietveldissue' % self.GetBranch()
+
+ def _PatchsetSetting(self):
+ """Return the git setting that stores this change's most recent patchset."""
+ return 'branch.%s.rietveldpatchset' % self.GetBranch()
+
+ def _RietveldServer(self):
+ """Returns the git setting that stores this change's rietveld server."""
+ return 'branch.%s.rietveldserver' % self.GetBranch()
+
+
+def GetCodereviewSettingsInteractively():
+ """Prompt the user for settings."""
+ server = settings.GetDefaultServerUrl(error_ok=True)
+ prompt = 'Rietveld server (host[:port])'
+ prompt += ' [%s]' % (server or DEFAULT_SERVER)
+ newserver = raw_input(prompt + ': ')
+ if not server and not newserver:
+ newserver = DEFAULT_SERVER
+ if newserver and newserver != server:
+ RunGit(['config', 'rietveld.server', newserver])
+
+ def SetProperty(initial, caption, name):
+ prompt = caption
+ if initial:
+ prompt += ' ("x" to clear) [%s]' % initial
+ new_val = raw_input(prompt + ': ')
+ if new_val == 'x':
+ RunGit(['config', '--unset-all', 'rietveld.' + name], error_ok=True)
+ elif new_val and new_val != initial:
+ RunGit(['config', 'rietveld.' + name, new_val])
+
+ SetProperty(settings.GetCCList(), 'CC list', 'cc')
+ SetProperty(settings.GetTreeStatusUrl(error_ok=True), 'Tree status URL',
+ 'tree-status-url')
+ SetProperty(settings.GetViewVCUrl(), 'ViewVC URL', 'viewvc-url')
+
+ # TODO: configure a default branch to diff against, rather than this
+ # svn-based hackery.
+
+
+def FindCodereviewSettingsFile(filename='codereview.settings'):
+ """Finds the given file starting in the cwd and going up.
+
+ Only looks up to the top of the repository unless an
+ 'inherit-review-settings-ok' file exists in the root of the repository.
+ """
+ inherit_ok_file = 'inherit-review-settings-ok'
+ cwd = os.getcwd()
+ root = os.path.abspath(RunGit(['rev-parse', '--show-cdup']).strip())
+ if os.path.isfile(os.path.join(root, inherit_ok_file)):
+ root = '/'
+ while True:
+ if filename in os.listdir(cwd):
+ if os.path.isfile(os.path.join(cwd, filename)):
+ return open(os.path.join(cwd, filename))
+ if cwd == root:
+ break
+ cwd = os.path.dirname(cwd)
+
+
+def LoadCodereviewSettingsFromFile(fileobj):
+ """Parse a codereview.settings file and updates hooks."""
+ def DownloadToFile(url, filename):
+ filename = os.path.join(settings.GetRoot(), filename)
+ contents = urllib2.urlopen(url).read()
+ fileobj = open(filename, 'w')
+ fileobj.write(contents)
+ fileobj.close()
+ os.chmod(filename, 0755)
+ return 0
+
+ keyvals = {}
+ for line in fileobj.read().splitlines():
+ if not line or line.startswith("#"):
+ continue
+ k, v = line.split(": ", 1)
+ keyvals[k] = v
+
+ def GetProperty(name):
+ return keyvals.get(name)
+
+ def SetProperty(name, setting, unset_error_ok=False):
+ fullname = 'rietveld.' + name
+ if setting in keyvals:
+ RunGit(['config', fullname, keyvals[setting]])
+ else:
+ RunGit(['config', '--unset-all', fullname], error_ok=unset_error_ok)
+
+ SetProperty('server', 'CODE_REVIEW_SERVER')
+ # Only server setting is required. Other settings can be absent.
+ # In that case, we ignore errors raised during option deletion attempt.
+ SetProperty('cc', 'CC_LIST', unset_error_ok=True)
+ SetProperty('tree-status-url', 'STATUS', unset_error_ok=True)
+ SetProperty('viewvc-url', 'VIEW_VC', unset_error_ok=True)
+
+ if 'PUSH_URL_CONFIG' in keyvals and 'ORIGIN_URL_CONFIG' in keyvals:
+ #should be of the form
+ #PUSH_URL_CONFIG: url.ssh://gitrw.chromium.org.pushinsteadof
+ #ORIGIN_URL_CONFIG: http://src.chromium.org/git
+ RunGit(['config', keyvals['PUSH_URL_CONFIG'],
+ keyvals['ORIGIN_URL_CONFIG']])
+
+ # Update the hooks if the local hook files aren't present already.
+ if GetProperty('GITCL_PREUPLOAD') and not os.path.isfile(PREUPLOAD_HOOK):
+ DownloadToFile(GetProperty('GITCL_PREUPLOAD'), PREUPLOAD_HOOK)
+ if GetProperty('GITCL_PREDCOMMIT') and not os.path.isfile(PREDCOMMIT_HOOK):
+ DownloadToFile(GetProperty('GITCL_PREDCOMMIT'), PREDCOMMIT_HOOK)
+ return 0
+
+
+@usage('[repo root containing codereview.settings]')
+def CMDconfig(parser, args):
+ """edit configuration for this tree"""
+
+ (options, args) = parser.parse_args(args)
+ if len(args) == 0:
+ GetCodereviewSettingsInteractively()
+ return 0
+
+ url = args[0]
+ if not url.endswith('codereview.settings'):
+ url = os.path.join(url, 'codereview.settings')
+
+ # Load code review settings and download hooks (if available).
+ LoadCodereviewSettingsFromFile(urllib2.urlopen(url))
+ return 0
+
+
+def CMDstatus(parser, args):
+ """show status of changelists"""
+ parser.add_option('--field',
+ help='print only specific field (desc|id|patch|url)')
+ (options, args) = parser.parse_args(args)
+
+ # TODO: maybe make show_branches a flag if necessary.
+ show_branches = not options.field
+
+ if show_branches:
+ branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads'])
+ if branches:
+ print 'Branches associated with reviews:'
+ for branch in sorted(branches.splitlines()):
+ cl = Changelist(branchref=branch)
+ print " %10s: %s" % (cl.GetBranch(), cl.GetIssue())
+
+ cl = Changelist()
+ if options.field:
+ if options.field.startswith('desc'):
+ print cl.GetDescription()
+ elif options.field == 'id':
+ issueid = cl.GetIssue()
+ if issueid:
+ print issueid
+ elif options.field == 'patch':
+ patchset = cl.GetPatchset()
+ if patchset:
+ print patchset
+ elif options.field == 'url':
+ url = cl.GetIssueURL()
+ if url:
+ print url
+ else:
+ print
+ print 'Current branch:',
+ if not cl.GetIssue():
+ print 'no issue assigned.'
+ return 0
+ print cl.GetBranch()
+ print 'Issue number:', cl.GetIssue(), '(%s)' % cl.GetIssueURL()
+ print 'Issue description:'
+ print cl.GetDescription(pretty=True)
+ return 0
+
+
+@usage('[issue_number]')
+def CMDissue(parser, args):
+ """Set or display the current code review issue number.
+
+ Pass issue number 0 to clear the current issue.
+"""
+ (options, args) = parser.parse_args(args)
+
+ cl = Changelist()
+ if len(args) > 0:
+ try:
+ issue = int(args[0])
+ except ValueError:
+ DieWithError('Pass a number to set the issue or none to list it.\n'
+ 'Maybe you want to run git cl status?')
+ cl.SetIssue(issue)
+ print 'Issue number:', cl.GetIssue(), '(%s)' % cl.GetIssueURL()
+ return 0
+
+
+def CreateDescriptionFromLog(args):
+ """Pulls out the commit log to use as a base for the CL description."""
+ log_args = []
+ if len(args) == 1 and not args[0].endswith('.'):
+ log_args = [args[0] + '..']
+ elif len(args) == 1 and args[0].endswith('...'):
+ log_args = [args[0][:-1]]
+ elif len(args) == 2:
+ log_args = [args[0] + '..' + args[1]]
+ else:
+ log_args = args[:] # Hope for the best!
+ return RunGit(['log', '--pretty=format:%s\n\n%b'] + log_args)
+
+
+def UserEditedLog(starting_text):
+ """Given some starting text, let the user edit it and return the result."""
+ editor = os.getenv('EDITOR', 'vi')
+
+ (file_handle, filename) = tempfile.mkstemp()
+ fileobj = os.fdopen(file_handle, 'w')
+ fileobj.write(starting_text)
+ fileobj.close()
+
+ ret = subprocess.call(editor + ' ' + filename, shell=True)
+ if ret != 0:
+ os.remove(filename)
+ return
+
+ fileobj = open(filename)
+ text = fileobj.read()
+ fileobj.close()
+ os.remove(filename)
+ stripcomment_re = re.compile(r'^#.*$', re.MULTILINE)
+ return stripcomment_re.sub('', text).strip()
+
+
+def RunHook(hook, upstream_branch, error_ok=False):
+ """Run a given hook if it exists. By default, we fail on errors."""
+ hook = '%s/%s' % (settings.GetRoot(), hook)
+ if not os.path.exists(hook):
+ return
+ return RunCommand([hook, upstream_branch], error_ok=error_ok,
+ redirect_stdout=False)
+
+
+def CMDpresubmit(parser, args):
+ """run presubmit tests on the current changelist"""
+ parser.add_option('--upload', action='store_true',
+ help='Run upload hook instead of the push/dcommit hook')
+ (options, args) = parser.parse_args(args)
+
+ # Make sure index is up-to-date before running diff-index.
+ RunGit(['update-index', '--refresh', '-q'], error_ok=True)
+ if RunGit(['diff-index', 'HEAD']):
+ # TODO(maruel): Is this really necessary?
+ print 'Cannot presubmit with a dirty tree. You must commit locally first.'
+ return 1
+
+ if args:
+ base_branch = args[0]
+ else:
+ # Default to diffing against the "upstream" branch.
+ base_branch = Changelist().GetUpstreamBranch()
+
+ if options.upload:
+ print '*** Presubmit checks for UPLOAD would report: ***'
+ return not RunHook(PREUPLOAD_HOOK, upstream_branch=base_branch,
+ error_ok=True)
+ else:
+ print '*** Presubmit checks for DCOMMIT would report: ***'
+ return not RunHook(PREDCOMMIT_HOOK, upstream_branch=base_branch,
+ error_ok=True)
+
+
+@usage('[args to "git diff"]')
+def CMDupload(parser, args):
+ """upload the current changelist to codereview"""
+ parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
+ help='bypass upload presubmit hook')
+ parser.add_option('-m', dest='message', help='message for patch')
+ parser.add_option('-r', '--reviewers',
+ help='reviewer email addresses')
+ parser.add_option('--send-mail', action='store_true',
+ help='send email to reviewer immediately')
+ parser.add_option("--emulate_svn_auto_props", action="store_true",
+ dest="emulate_svn_auto_props",
+ help="Emulate Subversion's auto properties feature.")
+ parser.add_option("--desc_from_logs", action="store_true",
+ dest="from_logs",
+ help="""Squashes git commit logs into change description and
+ uses message as subject""")
+ (options, args) = parser.parse_args(args)
+
+ # Make sure index is up-to-date before running diff-index.
+ RunGit(['update-index', '--refresh', '-q'], error_ok=True)
+ if RunGit(['diff-index', 'HEAD']):
+ print 'Cannot upload with a dirty tree. You must commit locally first.'
+ return 1
+
+ cl = Changelist()
+ if args:
+ base_branch = args[0]
+ else:
+ # Default to diffing against the "upstream" branch.
+ base_branch = cl.GetUpstreamBranch()
+ args = [base_branch + "..."]
+
+ if not options.bypass_hooks:
+ RunHook(PREUPLOAD_HOOK, upstream_branch=base_branch, error_ok=False)
+
+ # --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']
+ subprocess.call(['git', 'diff', '--no-ext-diff', '--stat', '-M'] + args,
+ env=env)
+
+ upload_args = ['--assume_yes'] # Don't ask about untracked files.
+ upload_args.extend(['--server', cl.GetRietveldServer()])
+ if options.reviewers:
+ upload_args.extend(['--reviewers', options.reviewers])
+ upload_args.extend(['--cc', settings.GetCCList()])
+ if options.emulate_svn_auto_props:
+ upload_args.append('--emulate_svn_auto_props')
+ if options.send_mail:
+ if not options.reviewers:
+ DieWithError("Must specify reviewers to send email.")
+ upload_args.append('--send_mail')
+ if options.from_logs and not options.message:
+ print 'Must set message for subject line if using desc_from_logs'
+ return 1
+
+ change_desc = None
+
+ if cl.GetIssue():
+ if options.message:
+ upload_args.extend(['--message', options.message])
+ upload_args.extend(['--issue', cl.GetIssue()])
+ print ("This branch is associated with issue %s. "
+ "Adding patch to that issue." % cl.GetIssue())
+ else:
+ log_desc = CreateDescriptionFromLog(args)
+ if options.from_logs:
+ # Uses logs as description and message as subject.
+ subject = options.message
+ change_desc = subject + '\n\n' + log_desc
+ else:
+ initial_text = """# Enter a description of the change.
+# This will displayed on the codereview site.
+# The first line will also be used as the subject of the review.
+"""
+ if 'BUG=' not in log_desc:
+ log_desc += '\nBUG='
+ if 'TEST=' not in log_desc:
+ log_desc += '\nTEST='
+ change_desc = UserEditedLog(initial_text + log_desc)
+ subject = ''
+ if change_desc:
+ subject = change_desc.splitlines()[0]
+ if not change_desc:
+ print "Description is empty; aborting."
+ return 1
+ upload_args.extend(['--message', subject])
+ upload_args.extend(['--description', change_desc])
+
+ # Include the upstream repo's URL in the change -- this is useful for
+ # projects that have their source spread across multiple repos.
+ remote_url = None
+ if settings.GetIsGitSvn():
+ data = RunGit(['svn', 'info'])
+ if data:
+ keys = dict(line.split(': ', 1) for line in data.splitlines()
+ if ': ' in line)
+ remote_url = keys.get('URL', None)
+ else:
+ if cl.GetRemoteUrl() and '/' in cl.GetUpstreamBranch():
+ remote_url = (cl.GetRemoteUrl() + '@'
+ + cl.GetUpstreamBranch().split('/')[-1])
+ if remote_url:
+ upload_args.extend(['--base_url', remote_url])
+
+ try:
+ issue, patchset = upload.RealMain(['upload'] + upload_args + args)
+ except:
+ # If we got an exception after the user typed a description for their
+ # change, back up the description before re-raising.
+ if change_desc:
+ backup_path = os.path.expanduser(DESCRIPTION_BACKUP_FILE)
+ print '\nGot exception while uploading -- saving description to %s\n' \
+ % backup_path
+ backup_file = open(backup_path, 'w')
+ backup_file.write(change_desc)
+ backup_file.close()
+ raise
+
+ if not cl.GetIssue():
+ cl.SetIssue(issue)
+ cl.SetPatchset(patchset)
+ return 0
+
+
+def SendUpstream(parser, args, cmd):
+ """Common code for CmdPush and CmdDCommit
+
+ Squashed commit into a single.
+ Updates changelog with metadata (e.g. pointer to review).
+ Pushes/dcommits the code upstream.
+ Updates review and closes.
+ """
+ parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
+ help='bypass upload presubmit hook')
+ parser.add_option('-m', dest='message',
+ help="override review description")
+ parser.add_option('-f', action='store_true', dest='force',
+ help="force yes to questions (don't prompt)")
+ parser.add_option('-c', dest='contributor',
+ help="external contributor for patch (appended to " +
+ "description and used as author for git). Should be " +
+ "formatted as 'First Last <email@example.com>'")
+ parser.add_option('--tbr', action='store_true', dest='tbr',
+ help="short for 'to be reviewed', commit branch " +
+ "even without uploading for review")
+ (options, args) = parser.parse_args(args)
+ cl = Changelist()
+
+ if not args or cmd == 'push':
+ # Default to merging against our best guess of the upstream branch.
+ args = [cl.GetUpstreamBranch()]
+
+ base_branch = args[0]
+
+ if RunGit(['diff-index', 'HEAD']):
+ print 'Cannot %s with a dirty tree. You must commit locally first.' % cmd
+ return 1
+
+ # This rev-list syntax means "show all commits not in my branch that
+ # are in base_branch".
+ upstream_commits = RunGit(['rev-list', '^' + cl.GetBranchRef(),
+ base_branch]).splitlines()
+ if upstream_commits:
+ print ('Base branch "%s" has %d commits '
+ 'not in this branch.' % (base_branch, len(upstream_commits)))
+ print 'Run "git merge %s" before attempting to %s.' % (base_branch, cmd)
+ return 1
+
+ if cmd == 'dcommit':
+ # This is the revision `svn dcommit` will commit on top of.
+ svn_head = RunGit(['log', '--grep=^git-svn-id:', '-1',
+ '--pretty=format:%H'])
+ extra_commits = RunGit(['rev-list', '^' + svn_head, base_branch])
+ if extra_commits:
+ print ('This branch has %d additional commits not upstreamed yet.'
+ % len(extra_commits.splitlines()))
+ print ('Upstream "%s" or rebase this branch on top of the upstream trunk '
+ 'before attempting to %s.' % (base_branch, cmd))
+ return 1
+
+ if not options.force and not options.bypass_hooks:
+ RunHook(PREDCOMMIT_HOOK, upstream_branch=base_branch, error_ok=False)
+
+ if cmd == 'dcommit':
+ # Check the tree status if the tree status URL is set.
+ status = GetTreeStatus()
+ if 'closed' == status:
+ print ('The tree is closed. Please wait for it to reopen. Use '
+ '"git cl dcommit -f" to commit on a closed tree.')
+ return 1
+ elif 'unknown' == status:
+ print ('Unable to determine tree status. Please verify manually and '
+ 'use "git cl dcommit -f" to commit on a closed tree.')
+
+ description = options.message
+ if not options.tbr:
+ # It is important to have these checks early. Not only for user
+ # convenience, but also because the cl object then caches the correct values
+ # of these fields even as we're juggling branches for setting up the commit.
+ if not cl.GetIssue():
+ print 'Current issue unknown -- has this branch been uploaded?'
+ print 'Use --tbr to commit without review.'
+ return 1
+
+ if not description:
+ description = cl.GetDescription()
+
+ if not description:
+ print 'No description set.'
+ print 'Visit %s/edit to set it.' % (cl.GetIssueURL())
+ return 1
+
+ description += "\n\nReview URL: %s" % cl.GetIssueURL()
+ else:
+ if not description:
+ # Submitting TBR. See if there's already a description in Rietveld, else
+ # create a template description. Eitherway, give the user a chance to edit
+ # it to fill in the TBR= field.
+ if cl.GetIssue():
+ description = cl.GetDescription()
+
+ if not description:
+ description = """# Enter a description of the change.
+# This will be used as the change log for the commit.
+
+"""
+ description += CreateDescriptionFromLog(args)
+
+ description = UserEditedLog(description + '\nTBR=')
+
+ if not description:
+ print "Description empty; aborting."
+ return 1
+
+ if options.contributor:
+ if not re.match('^.*\s<\S+@\S+>$', options.contributor):
+ print "Please provide contibutor as 'First Last <email@example.com>'"
+ return 1
+ description += "\nPatch from %s." % options.contributor
+ print 'Description:', repr(description)
+
+ branches = [base_branch, cl.GetBranchRef()]
+ if not options.force:
+ subprocess.call(['git', 'diff', '--stat'] + branches)
+ raw_input("About to commit; enter to confirm.")
+
+ # 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 RunGitWithCode(['show-ref', '--quiet', '--verify',
+ 'refs/heads/' + MERGE_BRANCH])[0] == 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.
+ # We wrap in a try...finally block so if anything goes wrong,
+ # we clean up the branches.
+ try:
+ RunGit(['checkout', '-q', '-b', MERGE_BRANCH, base_branch])
+ RunGit(['merge', '--squash', cl.GetBranchRef()])
+ if options.contributor:
+ RunGit(['commit', '--author', options.contributor, '-m', description])
+ else:
+ RunGit(['commit', '-m', description])
+ if cmd == 'push':
+ # push the merge branch.
+ remote, branch = cl.FetchUpstreamTuple()
+ retcode, output = RunGitWithCode(
+ ['push', '--porcelain', remote, 'HEAD:%s' % branch])
+ logging.debug(output)
+ else:
+ # dcommit the merge branch.
+ output = RunGit(['svn', 'dcommit', '--no-rebase'])
+ finally:
+ # And then swap back to the original branch and clean up.
+ RunGit(['checkout', '-q', cl.GetBranch()])
+ RunGit(['branch', '-D', MERGE_BRANCH])
+
+ if cl.GetIssue():
+ if cmd == 'dcommit' and 'Committed r' in output:
+ revision = re.match('.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1)
+ elif cmd == 'push' and retcode == 0:
+ revision = output.splitlines()[1].split('\t')[2].split('..')[1]
+ else:
+ return 1
+ viewvc_url = settings.GetViewVCUrl()
+ if viewvc_url and revision:
+ cl.description += ('\n\nCommitted: ' + viewvc_url + revision)
+ print ('Closing issue '
+ '(you may be prompted for your codereview password)...')
+ cl.CloseIssue()
+ cl.SetIssue(0)
+ return 0
+
+
+@usage('[upstream branch to apply against]')
+def CMDdcommit(parser, args):
+ """commit the current changelist via git-svn"""
+ if not settings.GetIsGitSvn():
+ print('This doesn\'t appear to be an SVN repository.')
+ print('Are you sure you didn\'t mean \'git cl push\'?')
+ raw_input('[Press enter to dcommit or ctrl-C to quit]')
+ return SendUpstream(parser, args, 'dcommit')
+
+
+@usage('[upstream branch to apply against]')
+def CMDpush(parser, args):
+ """commit the current changelist via git"""
+ if settings.GetIsGitSvn():
+ print('This appears to be an SVN repository.')
+ print('Are you sure you didn\'t mean \'git cl dcommit\'?')
+ raw_input('[Press enter to push or ctrl-C to quit]')
+ return SendUpstream(parser, args, 'push')
+
+
+@usage('<patch url or issue id>')
+def CMDpatch(parser, args):
+ """patch in a code review"""
+ parser.add_option('-b', dest='newbranch',
+ help='create a new branch off trunk for the patch')
+ parser.add_option('-f', action='store_true', dest='force',
+ help='with -b, clobber any existing branch')
+ parser.add_option('--reject', action='store_true', dest='reject',
+ help='allow failed patches and spew .rej files')
+ parser.add_option('-n', '--no-commit', action='store_true', dest='nocommit',
+ help="don't commit after patch applies")
+ (options, args) = parser.parse_args(args)
+ if len(args) != 1:
+ parser.print_help()
+ return 1
+ input = args[0]
+
+ if re.match(r'\d+', input):
+ # Input is an issue id. Figure out the URL.
+ issue = input
+ server = settings.GetDefaultServerUrl()
+ fetch = urllib2.urlopen('%s/%s' % (server, issue)).read()
+ m = re.search(r'/download/issue[0-9]+_[0-9]+.diff', fetch)
+ if not m:
+ DieWithError('Must pass an issue ID or full URL for '
+ '\'Download raw patch set\'')
+ url = '%s%s' % (server, m.group(0).strip())
+ else:
+ # Assume it's a URL to the patch. Default to http.
+ input = FixUrl(input)
+ match = re.match(r'.*?/issue(\d+)_\d+.diff', input)
+ if match:
+ issue = match.group(1)
+ url = input
+ else:
+ DieWithError('Must pass an issue ID or full URL for '
+ '\'Download raw patch set\'')
+
+ if options.newbranch:
+ if options.force:
+ RunGit(['branch', '-D', options.newbranch],
+ swallow_stderr=True, error_ok=True)
+ RunGit(['checkout', '-b', options.newbranch,
+ Changelist().GetUpstreamBranch()])
+
+ # Switch up to the top-level directory, if necessary, in preparation for
+ # applying the patch.
+ top = RunGit(['rev-parse', '--show-cdup']).strip()
+ if top:
+ os.chdir(top)
+
+ patch_data = urllib2.urlopen(url).read()
+ # Git patches have a/ at the beginning of source paths. We strip that out
+ # with a sed script rather than the -p flag to patch so we can feed either
+ # Git or svn-style patches into the same apply command.
+ # re.sub() should be used but flags=re.MULTILINE is only in python 2.7.
+ sed_proc = Popen(['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+ patch_data = sed_proc.communicate(patch_data)[0]
+ if sed_proc.returncode:
+ DieWithError('Git patch mungling failed.')
+ logging.info(patch_data)
+ # We use "git apply" to apply the patch instead of "patch" so that we can
+ # pick up file adds.
+ # The --index flag means: also insert into the index (so we catch adds).
+ cmd = ['git', 'apply', '--index', '-p0']
+ if options.reject:
+ cmd.append('--reject')
+ patch_proc = Popen(cmd, stdin=subprocess.PIPE)
+ patch_proc.communicate(patch_data)
+ if patch_proc.returncode:
+ DieWithError('Failed to apply the patch')
+
+ # If we had an issue, commit the current state and register the issue.
+ if not options.nocommit:
+ RunGit(['commit', '-m', 'patch from issue %s' % issue])
+ cl = Changelist()
+ cl.SetIssue(issue)
+ print "Committed patch."
+ else:
+ print "Patch applied to index."
+ return 0
+
+
+def CMDrebase(parser, args):
+ """rebase current branch on top of svn repo"""
+ # Provide a wrapper for git svn rebase to help avoid accidental
+ # git svn dcommit.
+ # It's the only command that doesn't use parser at all since we just defer
+ # execution to git-svn.
+ RunGit(['svn', 'rebase'] + args, redirect_stdout=False)
+ return 0
+
+
+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 or status == '0':
+ return 'closed'
+ elif status.find('open') != -1 or status == '1':
+ return 'open'
+ return 'unknown'
+
+ return 'unset'
+
+def GetTreeStatusReason():
+ """Fetches the tree status from a json url and returns the message
+ with the reason for the tree to be opened or closed."""
+ # Don't import it at file level since simplejson is not installed by default
+ # on python 2.5 and it is only used for git-cl tree which isn't often used,
+ # forcing everyone to install simplejson isn't efficient.
+ try:
+ import simplejson as json
+ except ImportError:
+ try:
+ import json
+ # Some versions of python2.5 have an incomplete json module. Check to make
+ # sure loads exists.
+ json.loads
+ except (ImportError, AttributeError):
+ print >> sys.stderr, 'Please install simplejson'
+ sys.exit(1)
+
+ json_url = 'http://chromium-status.appspot.com/current?format=json'
+ connection = urllib2.urlopen(json_url)
+ status = json.loads(connection.read())
+ connection.close()
+ return status['message']
+
+def CMDtree(parser, args):
+ """show the status of the tree"""
+ (options, args) = parser.parse_args(args)
+ status = GetTreeStatus()
+ if 'unset' == status:
+ print 'You must configure your tree status URL by running "git cl config".'
+ return 2
+
+ print "The tree is %s" % status
+ print
+ print GetTreeStatusReason()
+ if status != 'open':
+ return 1
+ return 0
+
+
+def CMDupstream(parser, args):
+ """print the name of the upstream branch, if any"""
+ (options, args) = parser.parse_args(args)
+ cl = Changelist()
+ print cl.GetUpstreamBranch()
+ return 0
+
+
+def Command(name):
+ return getattr(sys.modules[__name__], 'CMD' + name, None)
+
+
+def CMDhelp(parser, args):
+ """print list of commands or help for a specific command"""
+ (options, args) = parser.parse_args(args)
+ if len(args) == 1:
+ return main(args + ['--help'])
+ parser.print_help()
+ return 0
+
+
+def GenUsage(parser, command):
+ """Modify an OptParse object with the function's documentation."""
+ obj = Command(command)
+ more = getattr(obj, 'usage_more', '')
+ if command == 'help':
+ command = '<command>'
+ else:
+ # OptParser.description prefer nicely non-formatted strings.
+ parser.description = re.sub('[\r\n ]{2,}', ' ', obj.__doc__)
+ parser.set_usage('usage: %%prog %s [options] %s' % (command, more))
+
+
+def main(argv):
+ """Doesn't parse the arguments here, just find the right subcommand to
+ execute."""
+ # Do it late so all commands are listed.
+ CMDhelp.usage_more = ('\n\nCommands are:\n' + '\n'.join([
+ ' %-10s %s' % (fn[3:], Command(fn[3:]).__doc__.split('\n')[0].strip())
+ for fn in dir(sys.modules[__name__]) if fn.startswith('CMD')]))
+
+ # Create the option parse and add --verbose support.
+ parser = optparse.OptionParser()
+ parser.add_option('-v', '--verbose', action='store_true')
+ old_parser_args = parser.parse_args
+ def Parse(args):
+ options, args = old_parser_args(args)
+ if options.verbose:
+ logging.basicConfig(level=logging.DEBUG)
+ else:
+ logging.basicConfig(level=logging.WARNING)
+ return options, args
+ parser.parse_args = Parse
+
+ if argv:
+ command = Command(argv[0])
+ if command:
+ # "fix" the usage and the description now that we know the subcommand.
+ GenUsage(parser, argv[0])
+ try:
+ return command(parser, argv[1:])
+ except urllib2.HTTPError, e:
+ if e.code != 500:
+ raise
+ DieWithError(
+ ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
+ 'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
+
+ # Not a known command. Default to help.
+ GenUsage(parser, 'help')
+ return CMDhelp(parser, argv)
+
+
+if __name__ == '__main__':
+ sys.exit(main(sys.argv[1:]))