Replace --no-pager with GIT_PAGER=cat

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."""
 
 import difflib
@@ skipping 51 matching lines @@
     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', '--no-pager'] + args, **kwargs)
+  return RunCommand(['git'] + args, **kwargs)
 
 
 def RunGitWithCode(args):
   """Returns return code and stdout."""
   try:
-    out, code = subprocess2.communicate(['git', '--no-pager'] + args,
+    env = os.environ
+    env['GIT_PAGER'] = 'cat' # Magic string that prevents a pager.

[M-A Ruel, 2013/07/08 19:10:50]

Move the comment on its own line.

Does this work on Windows?

[iannucci, 2013/07/08 20:21:56]

(Drive-by: Yeah, GIT_PAGER=cat is a magic value)

[Daniel Bratell, 2013/07/08 22:08:06]

It seems to work when I test manually and according to the documentation cat is
a magic keyword that disables paging (the unix utility program cat isn't
mentioned).

+    out, code = subprocess2.communicate(['git'] + args,
+                                        env=env,
                                         stdout=subprocess2.PIPE)
     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 usage(more):
   def hook(fn):
@@ skipping 129 matching lines @@
 
 
 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()
   if 'GIT_EXTERNAL_DIFF' in env:
     del env['GIT_EXTERNAL_DIFF']
+  env['GIT_PAGER'] = 'cat' # Magical string that disables pagers.

[M-A Ruel, 2013/07/08 19:10:50]

Comment on its own line

 
   if find_copies:
     similarity_options = ['--find-copies-harder', '-l100000',
                           '-C%s' % similarity]
   else:
     similarity_options = ['-M%s' % similarity]
 
   return subprocess2.call(
-      ['git', '--no-pager',
+      ['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.is_git_svn = None
@@ skipping 47 matching lines @@
         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

[M-A Ruel, 2013/07/08 19:10:50]

env = os.environ.copy()

[Daniel Bratell, 2013/07/08 22:08:06]

I considered it but it's not really necessary since we want this value globally
anyway. I'll add it though.

[M-A Ruel, 2013/07/08 22:15:13]

First rule of maintainability is to not mutate global states in inner functions.

So either mutate globally at the start of the program or use a copy of the
environment at each call sites. You are doing the later, either is fine with me.

+      env['GIT_PAGER'] = 'cat' # Magical string that disables pagers.

[M-A Ruel, 2013/07/08 19:10:50]

Comment on its own line.

+
       # 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', '--no-pager', 'log', '-100', '--pretty=medium']
-      proc = subprocess2.Popen(cmd, stdout=subprocess2.PIPE)
+      cmd = ['git', 'log', '-100', '--pretty=medium']
+      proc = subprocess2.Popen(cmd, stdout=subprocess2.PIPE, env=env)
       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 358 matching lines @@
         RunGit(['config', self._RietveldServer(), self.rietveld_server])
     else:
       RunGit(['config', '--unset', self._IssueSetting()])
       self.SetPatchset(0)
     self.has_issue = False
 
   def GetChange(self, upstream_branch, author):
     if not self.GitSanityChecks(upstream_branch):
       DieWithError('\nGit sanity check failure')
 
-    root = RunCommand(['git', '--no-pager', 'rev-parse', '--show-cdup']).strip()
+    env = os.environ

[M-A Ruel, 2013/07/08 19:10:50]

same

+    env['GIT_PAGER'] = 'cat' # Magical string that disables pagers.
+
+    root = RunCommand(['git', 'rev-parse', '--show-cdup'], env=env).strip()
     if not root:
       root = '.'
     absroot = os.path.abspath(root)
 
     # We use the sha1 of HEAD as a name of this change.
-    name = RunCommand(['git', '--no-pager', 'rev-parse', 'HEAD']).strip()
+    name = RunCommand(['git', 'rev-parse', 'HEAD'], env=env).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', '--no-pager',
+      description = RunCommand(['git',
                                 'log', '--pretty=format:%s%n%n%b',
-                                '%s...' % (upstream_branch)]).strip()
+                                '%s...' % (upstream_branch)],
+                               env=env).strip()
 
     if not author:
       author = RunGit(['config', 'user.email']).strip() or None
     return presubmit_support.GitChange(
         name,
         description,
         absroot,
         files,
         issue,
         patchset,
@@ skipping 1017 matching lines @@
   # 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

[M-A Ruel, 2013/07/08 19:10:50]

same

+  env['GIT_PAGER'] = 'cat' # Magical string that disables pagers.
+
   # 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', '--no-pager', 'apply', '--index', '-p0']
+  cmd = ['git', 'apply', '--index', '-p0']
   if options.reject:
     cmd.append('--reject')
   try:
-    subprocess2.check_call(cmd, stdin=patch_data, stdout=subprocess2.VOID)
+    subprocess2.check_call(cmd, env=env,
+                           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 options.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):
   """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.
-  return subprocess2.call(['git', '--no-pager', 'svn', 'rebase'] + args)
+  env = os.environ

[M-A Ruel, 2013/07/08 19:10:50]

same

+  env['GIT_PAGER'] = 'cat' # Magical string that disables pagers.
+
+  return subprocess2.call(['git', 'svn', 'rebase'] + args, env=env)
 
 
 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'
@@ skipping 348 matching lines @@
   GenUsage(parser, 'help')
   return CMDhelp(parser, argv)
 
 
 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:]))