Cleanup: Merge a bunch of redundent env['GIT_PAGER'] = 'cat' statements.

git_cl.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld."""
 
 from distutils.version import LooseVersion
@@ skipping 45 matching lines @@
 
 # Initialized in main()
 settings = None
 
 
 def DieWithError(message):
   print >> sys.stderr, message
   sys.exit(1)
 
 
+def GetNoGitPagerEnv():
+  env = os.environ.copy()
+  # 'cat' is a magical git string that disables pagers on all platforms.
+  env['GIT_PAGER'] = 'cat'
+  return env
+
 def RunCommand(args, error_ok=False, error_message=None, **kwargs):
   try:
     return subprocess2.check_output(args, shell=False, **kwargs)
   except subprocess2.CalledProcessError as e:
     logging.debug('Failed running %s', args)
     if not error_ok:
       DieWithError(
           'Command "%s" failed.\n%s' % (
             ' '.join(args), error_message or e.stdout or ''))
     return e.stdout
 
 
 def RunGit(args, **kwargs):
   """Returns stdout."""
   return RunCommand(['git'] + args, **kwargs)
 
 
 def RunGitWithCode(args, suppress_stderr=False):
   """Returns return code and stdout."""
   try:
-    env = os.environ.copy()
-    # 'cat' is a magical git string that disables pagers on all platforms.
-    env['GIT_PAGER'] = 'cat'
     if suppress_stderr:
       stderr = subprocess2.VOID
     else:
       stderr = sys.stderr
     out, code = subprocess2.communicate(['git'] + args,
-                                        env=env,
+                                        env=GetNoGitPagerEnv(),
                                         stdout=subprocess2.PIPE,
                                         stderr=stderr)
     return code, out[0]
   except ValueError:
     # When the subprocess fails, it returns None.  That triggers a ValueError
     # when trying to unpack the return value into (out, code).
     return 1, ''
 
 
 def IsGitVersionAtLeast(min_version):
@@ skipping 127 matching lines @@
   if full_url == url:
     return as_ref
   return None
 
 
 def print_stats(similarity, find_copies, args):
   """Prints statistics about the change to the user."""
   # --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()
+  env = GetNoGitPagerEnv()
   if 'GIT_EXTERNAL_DIFF' in env:
     del env['GIT_EXTERNAL_DIFF']
-  # 'cat' is a magical git string that disables pagers on all platforms.
-  env['GIT_PAGER'] = 'cat'
 
   if find_copies:
     similarity_options = ['--find-copies-harder', '-l100000',
                           '-C%s' % similarity]
   else:
     similarity_options = ['-M%s' % similarity]
 
   return subprocess2.call(
       ['git',
        'diff', '--no-ext-diff', '--stat'] + similarity_options + args,
       env=env)
 
 
 class Settings(object):
   def __init__(self):
     self.default_server = None
     self.cc = None
-    self.root = None
+    self.relative_root = None
     self.is_git_svn = None
     self.svn_branch = None
     self.tree_status_url = None
     self.viewvc_url = None
     self.updated = False
     self.is_gerrit = None
     self.git_editor = None
 
   def LazyUpdateIfNeeded(self):
     """Updates the settings from a codereview.settings file, if available."""
@@ skipping 10 matching lines @@
         # set updated to True to avoid infinite calling loop
         # through DownloadHooks
         self.updated = True
         DownloadHooks(False)
       self.updated = True
 
   def GetDefaultServerUrl(self, error_ok=False):
     if not self.default_server:
       self.LazyUpdateIfNeeded()
       self.default_server = gclient_utils.UpgradeToHttps(
-          self._GetConfig('rietveld.server', error_ok=True))
+          self._GetRietveldConfig('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 = gclient_utils.UpgradeToHttps(
-            self._GetConfig('rietveld.server', error_message=error_message))
+            self._GetRietveldConfig('server', error_message=error_message))
     return self.default_server
 
+  def GetRelativeRoot(self):
+    if self.relative_root is None:
+      self.relative_root = RunGit(['rev-parse', '--show-cdup']).strip()
+    return self.relative_root
+
   def GetRoot(self):
-    if not self.root:
-      self.root = os.path.abspath(RunGit(['rev-parse', '--show-cdup']).strip())
-    return self.root
+    return os.path.abspath(self.GetRelativeRoot())
 
   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', '--local', '--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) iterate through our branch history and find the svn URL.
       # 2) find the svn-remote that fetches from the URL.
 
       # regexp matching the git-svn line that contains the URL.
       git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE)
 
-      env = os.environ.copy()
-      # 'cat' is a magical git string that disables pagers on all platforms.
-      env['GIT_PAGER'] = 'cat'
-
       # 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 = subprocess2.Popen(cmd, stdout=subprocess2.PIPE, env=env)
+      proc = subprocess2.Popen(cmd, stdout=subprocess2.PIPE,
+                               env=GetNoGitPagerEnv())
       url = None
       for line in proc.stdout:
         match = git_svn_re.match(line)
         if match:
           url = match.group(1)
           proc.stdout.close()  # Cut pipe.
           break
 
       if url:
         svn_remote_re = re.compile(r'^svn-remote\.([^.]+)\.url (.*)$')
@@ skipping 34 matching lines @@
       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)
+      self.tree_status_url = self._GetRietveldConfig(
+          '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)
+      self.viewvc_url = self._GetRietveldConfig('viewvc-url', error_ok=True)
     return self.viewvc_url
 
   def GetBugPrefix(self):
-    return self._GetConfig('rietveld.bug-prefix', error_ok=True)
+    return self._GetRietveldConfig('bug-prefix', error_ok=True)
 
   def GetDefaultCCList(self):
-    return self._GetConfig('rietveld.cc', error_ok=True)
+    return self._GetRietveldConfig('cc', error_ok=True)
 
   def GetDefaultPrivateFlag(self):
-    return self._GetConfig('rietveld.private', error_ok=True)
+    return self._GetRietveldConfig('private', error_ok=True)
 
   def GetIsGerrit(self):
     """Return true if this repo is assosiated with gerrit code review system."""
     if self.is_gerrit is None:
       self.is_gerrit = self._GetConfig('gerrit.host', error_ok=True)
     return self.is_gerrit
 
   def GetGitEditor(self):
     """Return the editor specified in the git config, or None if none is."""
     if self.git_editor is None:
       self.git_editor = self._GetConfig('core.editor', error_ok=True)
     return self.git_editor or None
 
+  def _GetRietveldConfig(self, param, **kwargs):
+    return self._GetConfig('rietveld.' + param, **kwargs)
+
   def _GetConfig(self, param, **kwargs):
     self.LazyUpdateIfNeeded()
     return RunGit(['config', param], **kwargs).strip()
 
 
 def ShortBranchName(branch):
   """Convert a name like 'refs/heads/foo' to just 'foo'."""
   return branch.replace('refs/heads/', '')
 
 
@@ skipping 92 matching lines @@
             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 GetCommonAncestorWithUpstream(self):
+    return RunGit(['merge-base', self.GetUpstreamBranch(), 'HEAD']).strip()
+
   def GetUpstreamBranch(self):
     if self.upstream_branch is None:
       remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
       if remote is not '.':
         upstream_branch = upstream_branch.replace('heads', 'remotes/' + remote)
       self.upstream_branch = upstream_branch
     return self.upstream_branch
 
   def GetRemoteBranch(self):
     if not self._remote:
@@ skipping 181 matching lines @@
       current_issue = self.GetIssue()
       if current_issue:
         RunGit(['config', '--unset', self._IssueSetting()])
       self.issue = None
       self.SetPatchset(None)
 
   def GetChange(self, upstream_branch, author):
     if not self.GitSanityChecks(upstream_branch):
       DieWithError('\nGit sanity check failure')
 
-    env = os.environ.copy()
-    # 'cat' is a magical git string that disables pagers on all platforms.
-    env['GIT_PAGER'] = 'cat'
-
-    root = RunCommand(['git', 'rev-parse', '--show-cdup'], env=env).strip()
+    root = settings.GetRelativeRoot()
     if not root:
       root = '.'
     absroot = os.path.abspath(root)
 
     # We use the sha1 of HEAD as a name of this change.
-    name = RunCommand(['git', 'rev-parse', 'HEAD'], env=env).strip()
+    name = RunGitWithCode(['rev-parse', 'HEAD'])[1].strip()
     # Need to pass a relative path for msysgit.
     try:
       files = scm.GIT.CaptureStatus([root], '.', upstream_branch)
     except subprocess2.CalledProcessError:
       DieWithError(
           ('\nFailed to diff against upstream branch %s\n\n'
            'This branch probably doesn\'t exist anymore. To reset the\n'
            'tracking branch, please run\n'
            '    git branch --set-upstream %s trunk\n'
            'replacing trunk with origin/master or the relevant branch') %
           (upstream_branch, self.GetBranch()))
 
     issue = self.GetIssue()
     patchset = self.GetPatchset()
     if issue:
       description = self.GetDescription()
     else:
       # If the change was never uploaded, use the log messages of all commits
       # up to the branch point, as git cl upload will prefill the description
       # with these log messages.
-      description = RunCommand(['git',
-                                'log', '--pretty=format:%s%n%n%b',
-                                '%s...' % (upstream_branch)],
-                               env=env).strip()
+      args = ['log', '--pretty=format:%s%n%n%b', '%s...' % (upstream_branch)]
+      description = RunGitWithCode(args)[1].strip()
 
     if not author:
       author = RunGit(['config', 'user.email']).strip() or None
     return presubmit_support.GitChange(
         name,
         description,
         absroot,
         files,
         issue,
         patchset,
@@ skipping 222 matching lines @@
 
 
 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())
+  root = settings.GetRoot()
   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)
 
@@ skipping 349 matching lines @@
 
   if not options.force and is_dirty_git_tree('presubmit'):
     print 'use --force to check even if tree is dirty.'
     return 1
 
   cl = Changelist()
   if args:
     base_branch = args[0]
   else:
     # Default to diffing against the common ancestor of the upstream branch.
-    base_branch = RunGit(['merge-base', cl.GetUpstreamBranch(), 'HEAD']).strip()
+    base_branch = cl.GetCommonAncestorWithUpstream()
 
   cl.RunHook(
       committing=not options.upload,
       may_prompt=False,
       verbose=options.verbose,
       change=cl.GetChange(base_branch, None))
   return 0
 
 
 def AddChangeIdToCommitMessage(options, args):
@@ skipping 215 matching lines @@
 
   options.reviewers = cleanup_list(options.reviewers)
   options.cc = cleanup_list(options.cc)
 
   cl = Changelist()
   if args:
     # TODO(ukai): is it ok for gerrit case?
     base_branch = args[0]
   else:
     # Default to diffing against common ancestor of upstream branch
-    base_branch = RunGit(['merge-base', cl.GetUpstreamBranch(), 'HEAD']).strip()
+    base_branch = cl.GetCommonAncestorWithUpstream()
     args = [base_branch, 'HEAD']
 
   # Apply watchlists on upload.
   change = cl.GetChange(base_branch, None)
   watchlist = watchlists.Watchlists(change.RepositoryRoot())
   files = [f.LocalPath() for f in change.AffectedFiles()]
   if not options.bypass_watchlists:
     cl.SetWatchers(watchlist.GetWatchersForPaths(files))
 
   if not options.bypass_hooks:
@@ skipping 176 matching lines @@
   # Delete the branches if they exist.
   for branch in [MERGE_BRANCH, CHERRY_PICK_BRANCH]:
     showref_cmd = ['show-ref', '--quiet', '--verify', 'refs/heads/%s' % branch]
     result = RunGitWithCode(showref_cmd)
     if result[0] == 0:
       RunGit(['branch', '-D', 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()
+  rel_base_path = settings.GetRelativeRoot()
   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.
   retcode = -1
   try:
     RunGit(['checkout', '-q', '-b', MERGE_BRANCH])
     RunGit(['reset', '--soft', base_branch])
@@ skipping 142 matching lines @@
     match = re.match(r'.*?/issue(\d+)_(\d+).diff', issue_url)
     if not match:
       DieWithError('Must pass an issue ID or full URL for '
           '\'Download raw patch set\'')
     issue = int(match.group(1))
     patchset = int(match.group(2))
     patch_data = urllib2.urlopen(issue_arg).read()
 
   # Switch up to the top-level directory, if necessary, in preparation for
   # applying the patch.
-  top = RunGit(['rev-parse', '--show-cdup']).strip()
+  top = settings.GetRelativeRoot()
   if top:
     os.chdir(top)
 
   # 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.
   try:
     patch_data = subprocess2.check_output(
         ['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'], stdin=patch_data)
   except subprocess2.CalledProcessError:
     DieWithError('Git patch mungling failed.')
   logging.info(patch_data)
-  env = os.environ.copy()
-  # 'cat' is a magical git string that disables pagers on all platforms.
-  env['GIT_PAGER'] = 'cat'
 
   # 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 directory:
     cmd.extend(('--directory', directory))
   if reject:
     cmd.append('--reject')
   elif IsGitVersionAtLeast('1.7.12'):
     cmd.append('--3way')
   try:
-    subprocess2.check_call(cmd, env=env,
+    subprocess2.check_call(cmd, env=GetNoGitPagerEnv(),
                            stdin=patch_data, stdout=subprocess2.VOID)
   except subprocess2.CalledProcessError:
     DieWithError('Failed to apply the patch')
 
   # If we had an issue, commit the current state and register the issue.
   if not nocommit:
     RunGit(['commit', '-m', 'patch from issue %s' % issue])
     cl = Changelist()
     cl.SetIssue(issue)
     cl.SetPatchset(patchset)
     print "Committed patch locally."
   else:
     print "Patch applied to index."
   return 0
 
 
 def CMDrebase(parser, args):
   """Rebases 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.
-  env = os.environ.copy()
-  # 'cat' is a magical git string that disables pagers on all platforms.
-  env['GIT_PAGER'] = 'cat'
 
-  return subprocess2.call(['git', 'svn', 'rebase'] + args, env=env)
+  return RunGitWithCode(['svn', 'rebase'] + args)[1]
 
 
 def GetTreeStatus(url=None):
   """Fetches the tree status and returns either 'open', 'closed',
   'unknown' or 'unset'."""
   url = url or settings.GetTreeStatusUrl(error_ok=True)
   if url:
     status = urllib2.urlopen(url).read().lower()
     if status.find('closed') != -1 or status == '0':
       return 'closed'
@@ skipping 70 matching lines @@
   cl = Changelist()
   if not cl.GetIssue():
     parser.error('Need to upload first')
 
   if not options.name:
     options.name = cl.GetBranch()
 
   # Process --bot and --testfilter.
   if not options.bot:
     # Get try slaves from PRESUBMIT.py files if not specified.
-    change = cl.GetChange(
-      RunGit(['merge-base', cl.GetUpstreamBranch(), 'HEAD']).strip(),
-      None)
+    change = cl.GetChange(cl.GetCommonAncestorWithUpstream(), None)
     options.bot = presubmit_support.DoGetTrySlaves(
         change,
         change.LocalPaths(),
         settings.GetRoot(),
         None,
         None,
         options.verbose,
         sys.stdout)
   if not options.bot:
     parser.error('No default try builder to try, use --bot')
@@ skipping 106 matching lines @@
 
 
 def CMDdiff(parser, args):
   """shows differences between local tree and last upload."""
   cl = Changelist()
   issue = cl.GetIssue()
   branch = cl.GetBranch()
   if not issue:
     DieWithError('No issue found for current branch (%s)' % branch)
   TMP_BRANCH = 'git-cl-diff'
-  base_branch = RunGit(['merge-base', cl.GetUpstreamBranch(), 'HEAD']).strip()
+  base_branch = cl.GetCommonAncestorWithUpstream()
 
   # Create a new branch based on the merge-base
   RunGit(['checkout', '-q', '-b', TMP_BRANCH, base_branch])
   try:
     # Patch in the latest changes from rietveld.
     rtn = PatchIssue(issue, False, False, None)
     if rtn != 0:
       return rtn
 
     # Switch back to starting brand and diff against the temporary
@@ skipping 17 matching lines @@
   author = RunGit(['config', 'user.email']).strip() or None
 
   cl = Changelist()
 
   if args:
     if len(args) > 1:
       parser.error('Unknown args')
     base_branch = args[0]
   else:
     # Default to diffing against the common ancestor of the upstream branch.
-    base_branch = RunGit(['merge-base', cl.GetUpstreamBranch(), 'HEAD']).strip()
+    base_branch = cl.GetCommonAncestorWithUpstream()
 
   change = cl.GetChange(base_branch, None)
   return owners_finder.OwnersFinder(
       [f.LocalPath() for f in
           cl.GetChange(base_branch, None).AffectedFiles()],
       change.RepositoryRoot(), author,
       fopen=file, os_path=os.path, glob=glob.glob,
       disable_color=options.no_color).run()
 
 
 @subcommand.usage('[files or directories to diff]')
 def CMDformat(parser, args):
   """Runs clang-format on the diff."""
   CLANG_EXTS = ['.cc', '.cpp', '.h', '.mm']
   parser.add_option('--full', action='store_true',
                     help='Reformat the full content of all touched files')
   parser.add_option('--dry-run', action='store_true',
                     help='Don\'t modify any file on disk.')
   opts, args = parser.parse_args(args)
 
   # git diff generates paths against the root of the repository.  Change
   # to that directory so clang-format can find files even within subdirs.
-  rel_base_path = RunGit(['rev-parse', '--show-cdup']).strip()
+  rel_base_path = settings.GetRelativeRoot()
   if rel_base_path:
     os.chdir(rel_base_path)
 
   # Generate diff for the current branch's changes.
   diff_cmd = ['diff', '--no-ext-diff', '--no-prefix']
   if opts.full:
     # Only list the names of modified files.
     diff_cmd.append('--name-only')
   else:
     # Only generate context-less patches.
@@ skipping 108 matching lines @@
         ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
           'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
 
 
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   colorama.init()
   sys.exit(main(sys.argv[1:]))