If we're running in nohooks mode, don't bother to accumulate file_list in gclient.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import collections
 import logging
 import os
 import posixpath
@@ skipping 119 matching lines @@
     self._root_dir = root_dir
     if self._root_dir:
       self._root_dir = self._root_dir.replace('/', os.sep)
     self.relpath = relpath
     if self.relpath:
       self.relpath = self.relpath.replace('/', os.sep)
     if self.relpath and self._root_dir:
       self.checkout_path = os.path.join(self._root_dir, self.relpath)
 
   def RunCommand(self, command, options, args, file_list=None):
-    # file_list will have all files that are modified appended to it.
-    if file_list is None:
-      file_list = []
-
     commands = ['cleanup', 'update', 'updatesingle', 'revert',
                 'revinfo', 'status', 'diff', 'pack', 'runhooks']
 
     if not command in commands:
       raise gclient_utils.Error('Unknown command %s' % command)
 
     if not command in dir(self):
       raise gclient_utils.Error('Command %s not implemented in %s wrapper' % (
           command, self.__class__.__name__))
 
@@ skipping 59 matching lines @@
       result, version = scm.GIT.AssertVersion('1.7')
       if not result:
         raise gclient_utils.Error('Git version is older than 1.7: %s' % version)
       return result
     except OSError:
       return False
 
   def GetCheckoutRoot(self):
     return scm.GIT.GetCheckoutRoot(self.checkout_path)
 
-  def GetRevisionDate(self, revision):
+  def GetRevisionDate(self, _revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     # TODO(floitsch): get the time-stamp of the given revision and not just the
     # time-stamp of the currently checked out revision.
     return self._Capture(['log', '-n', '1', '--format=%ai'])
 
   @staticmethod
   def cleanup(options, args, file_list):
     """'Cleanup' the repo.
 
     There's no real git equivalent for the svn cleanup command, do a no-op.
     """
 
-  def diff(self, options, args, file_list):
+  def diff(self, options, _args, _file_list):
     merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
     self._Run(['diff', merge_base], options)
 
-  def pack(self, options, args, file_list):
+  def pack(self, _options, _args, _file_list):
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
     merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
     gclient_utils.CheckCallAndFilter(
         ['git', 'diff', merge_base],
         cwd=self.checkout_path,
@@ skipping 34 matching lines @@
     quiet = []
     if not options.verbose:
       quiet = ['--quiet']
     self._UpdateBranchHeads(options, fetch=False)
 
     fetch_cmd = [
       '-c', 'core.deltaBaseCacheLimit=2g', 'fetch', 'origin', '--prune']
     self._Run(fetch_cmd + quiet, options)
     self._Run(['reset', '--hard', revision] + quiet, options)
     self.UpdateSubmoduleConfig()
-    files = self._Capture(['ls-files']).splitlines()
-    file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+    if file_list is not None:
+      files = self._Capture(['ls-files']).splitlines()
+      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     if args:
@@ skipping 17 matching lines @@
 
     if gclient_utils.IsDateRevision(revision):
       # Date-revisions only work on git-repositories if the reflog hasn't
       # expired yet. Use rev-list to get the corresponding revision.
       #  git rev-list -n 1 --before='time-stamp' branchname
       if options.transitive:
         print('Warning: --transitive only works for SVN repositories.')
         revision = default_rev
 
     rev_str = ' at %s' % revision
-    files = []
+    files = [] if file_list is not None else None
 
     printed_path = False
     verbose = []
     if options.verbose:
       print('\n_____ %s%s' % (self.relpath, rev_str))
       verbose = ['--verbose']
       printed_path = True
 
     url = self._CreateOrUpdateCache(url, options)
 
     if revision.startswith('refs/'):
       rev_type = "branch"
     elif revision.startswith('origin/'):
       # For compatability with old naming, translate 'origin' to 'refs/heads'
       revision = revision.replace('origin/', 'refs/heads/')
       rev_type = "branch"
     else:
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
     if not os.path.exists(self.checkout_path) or (
         os.path.isdir(self.checkout_path) and
         not os.listdir(self.checkout_path)):
       gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
       self._Clone(revision, url, options)
       self.UpdateSubmoduleConfig()
-      files = self._Capture(['ls-files']).splitlines()
-      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+      if file_list is not None:
+        files = self._Capture(['ls-files']).splitlines()
+        file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
         print('')
       return
 
     if not managed:
       self._UpdateBranchHeads(options, fetch=False)
       self.UpdateSubmoduleConfig()
       print ('________ unmanaged solution; skipping %s' % self.relpath)
@@ skipping 129 matching lines @@
       if not printed_path:
         print('\n_____ %s%s' % (self.relpath, rev_str))
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
                      "OR git checkout -b <some new branch> %s" % new_base)
       raise gclient_utils.Error(switch_error)
     else:
       # case 3 - the default case
-      files = self._Capture(['diff', upstream_branch, '--name-only']).split()
+      if files is not None:
+        files = self._Capture(['diff', upstream_branch, '--name-only']).split()
       if verbose:
         print('Trying fast-forward merge to branch : %s' % upstream_branch)
       try:
         merge_args = ['merge']
         if not options.merge:
           merge_args.append('--ff-only')
         merge_args.append(upstream_branch)
         merge_output = scm.GIT.Capture(merge_args, cwd=self.checkout_path)
       except subprocess2.CalledProcessError as e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
@@ skipping 41 matching lines @@
           if not printed_path:
             print('\n_____ %s%s' % (self.relpath, rev_str))
             printed_path = True
           print(merge_output.strip())
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
             print('')
 
     self.UpdateSubmoduleConfig()
-    file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+    if file_list is not None:
+      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
     # If the rebase generated a conflict, abort and ask user to fix
     if self._IsRebasing():
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\nConflict while rebasing this branch.\n'
                                 'Fix the conflict and run gclient again.\n'
                                 'See man git-rebase for details.\n'
                                 % (self.relpath, rev_str))
 
     if verbose:
       print('Checked out revision %s' % self.revinfo(options, (), None))
 
     # If --reset and --delete_unversioned_trees are specified, remove any
     # untracked directories.
     if options.reset and options.delete_unversioned_trees:
       # GIT.CaptureStatus() uses 'dit diff' to compare to a specific SHA1 (the
       # merge-base by default), so doesn't include untracked files. So we use
       # 'git ls-files --directory --others --exclude-standard' here directly.
       paths = scm.GIT.Capture(
           ['ls-files', '--directory', '--others', '--exclude-standard'],
           self.checkout_path)
       for path in (p for p in paths.splitlines() if p.endswith('/')):
         full_path = os.path.join(self.checkout_path, path)
         if not os.path.islink(full_path):
           print('\n_____ removing unversioned directory %s' % path)
           gclient_utils.rmtree(full_path)
 
 
-  def revert(self, options, args, file_list):
+  def revert(self, options, _args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
     if not os.path.isdir(self.checkout_path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       print('\n_____ %s is missing, synching instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     if options.upstream:
       if self._GetCurrentBranch():
         upstream_branch = scm.GIT.GetUpstreamBranch(self.checkout_path)
         default_rev = upstream_branch or default_rev
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', 'origin/')
 
-    files = self._Capture(['diff', deps_revision, '--name-only']).split()
+    if file_list is not None:
+      files = self._Capture(['diff', deps_revision, '--name-only']).split()
+
     self._Run(['reset', '--hard', deps_revision], options)
     self._Run(['clean', '-f', '-d'], options)
-    file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
-  def revinfo(self, options, args, file_list):
+    if file_list is not None:
+      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+
+  def revinfo(self, _options, _args, _file_list):
     """Returns revision"""
     return self._Capture(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
-  def status(self, options, args, file_list):
+  def status(self, options, _args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
       print(('\n________ couldn\'t run status in %s:\n'
              'The directory does not exist.') % self.checkout_path)
     else:
       merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
       self._Run(['diff', '--name-status', merge_base], options)
-      files = self._Capture(['diff', '--name-only', merge_base]).split()
-      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+      if file_list is not None:
+        files = self._Capture(['diff', '--name-only', merge_base]).split()
+        file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def GetUsableRev(self, rev, options):
     """Finds a useful revision for this repository.
 
     If SCM is git-svn and the head revision is less than |rev|, git svn fetch
     will be called on the source."""
     sha1 = None
     if not os.path.isdir(self.checkout_path):
       raise gclient_utils.Error(
           ( 'We could not find a valid hash for safesync_url response "%s".\n'
@@ skipping 164 matching lines @@
       self._Capture(['checkout', '--quiet', '%s' % revision])
       print(
         ('Checked out %s to a detached HEAD. Before making any commits\n'
          'in this repo, you should use \'git checkout <branch>\' to switch to\n'
          'an existing branch or use \'git checkout origin -b <branch>\' to\n'
          'create a new branch for your work.') % revision)
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
                      branch=None, printed_path=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
-    files.extend(self._Capture(['diff', upstream, '--name-only']).split())
+    if files is not None:
+      files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
     if not printed_path:
       print('\n_____ %s : Attempting rebase onto %s...' % (
           self.relpath, revision))
       printed_path = True
     else:
       print('Attempting rebase onto %s...' % revision)
 
@@ skipping 104 matching lines @@
     try:
       scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
                        '--ignore-submodules', 'HEAD', '--'],
                        cwd=self.checkout_path)
     except subprocess2.CalledProcessError:
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tYour index contains uncommitted changes\n'
                                 '\tPlease commit, stash, or reset.\n'
                                   % (self.relpath, rev_str))
 
-  def _CheckDetachedHead(self, rev_str, options):
+  def _CheckDetachedHead(self, rev_str, _options):
     # HEAD is detached. Make sure it is safe to move away from (i.e., it is
     # reference by a commit). If not, error out -- most likely a rebase is
     # in progress, try to detect so we can give a better error.
     try:
       scm.GIT.Capture(['name-rev', '--no-undefined', 'HEAD'],
           cwd=self.checkout_path)
     except subprocess2.CalledProcessError:
       # Commit is not contained by any rev. See if the user is rebasing:
       if self._IsRebasing():
         # Punt to the user
@@ skipping 81 matching lines @@
     return scm.SVN.GetCheckoutRoot(self.checkout_path)
 
   def GetRevisionDate(self, revision):
     """Returns the given revision's date in ISO-8601 format (which contains the
     time zone)."""
     date = scm.SVN.Capture(
         ['propget', '--revprop', 'svn:date', '-r', revision],
         os.path.join(self.checkout_path, '.'))
     return date.strip()
 
-  def cleanup(self, options, args, file_list):
+  def cleanup(self, options, args, _file_list):
     """Cleanup working copy."""
     self._Run(['cleanup'] + args, options)
 
-  def diff(self, options, args, file_list):
+  def diff(self, options, args, _file_list):
     # NOTE: This function does not currently modify file_list.
     if not os.path.isdir(self.checkout_path):
       raise gclient_utils.Error('Directory %s is not present.' %
           self.checkout_path)
     self._Run(['diff'] + args, options)
 
-  def pack(self, options, args, file_list):
+  def pack(self, _options, args, _file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
     if not os.path.isdir(self.checkout_path):
       raise gclient_utils.Error('Directory %s is not present.' %
           self.checkout_path)
     gclient_utils.CheckCallAndFilter(
         ['svn', 'diff', '-x', '--ignore-eol-style'] + args,
         cwd=self.checkout_path,
         print_stdout=False,
         nag_timer=self.nag_timer,
@@ skipping 197 matching lines @@
       # information is not stored next to the file, so we will have to
       # re-export the file every time we sync.
       if not os.path.exists(self.checkout_path):
         gclient_utils.safe_makedirs(self.checkout_path)
       command = ["export", os.path.join(self.url, filename),
                  os.path.join(self.checkout_path, filename)]
       command = self._AddAdditionalUpdateFlags(command, options,
           options.revision)
       self._Run(command, options, cwd=self._root_dir)
 
-  def revert(self, options, args, file_list):
+  def revert(self, options, _args, file_list):
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
     if not os.path.isdir(self.checkout_path):
       if os.path.exists(self.checkout_path):
         gclient_utils.rmtree(self.checkout_path)
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
@@ skipping 11 matching lines @@
       if not options.force:
         raise gclient_utils.Error('Invalid checkout path, aborting')
       print(
           '\n_____ %s is not a valid svn checkout, synching instead' %
           self.relpath)
       gclient_utils.rmtree(self.checkout_path)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     def printcb(file_status):
-      file_list.append(file_status[1])
+      if file_list is not None:
+        file_list.append(file_status[1])
       if logging.getLogger().isEnabledFor(logging.INFO):
         logging.info('%s%s' % (file_status[0], file_status[1]))
       else:
         print(os.path.join(self.checkout_path, file_status[1]))
     scm.SVN.Revert(self.checkout_path, callback=printcb)
 
     # Revert() may delete the directory altogether.
     if not os.path.isdir(self.checkout_path):
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     try:
       # svn revert is so broken we don't even use it. Using
       # "svn up --revision BASE" achieve the same effect.
       # file_list will contain duplicates.
       self._RunAndGetFileList(['update', '--revision', 'BASE'], options,
           file_list)
     except OSError, e:
       # Maybe the directory disapeared meanwhile. Do not throw an exception.
       logging.error('Failed to update:\n%s' % str(e))
 
-  def revinfo(self, options, args, file_list):
+  def revinfo(self, _options, _args, _file_list):
     """Display revision"""
     try:
       return scm.SVN.CaptureRevision(self.checkout_path)
     except (gclient_utils.Error, subprocess2.CalledProcessError):
       return None
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     command = ['status'] + args
     if not os.path.isdir(self.checkout_path):
       # svn status won't work if the directory doesn't exist.
       print(('\n________ couldn\'t run \'%s\' in \'%s\':\n'
              'The directory does not exist.') %
                 (' '.join(command), self.checkout_path))
       # There's no file list to retrieve.
     else:
       self._RunAndGetFileList(command, options, file_list)
 
-  def GetUsableRev(self, rev, options):
+  def GetUsableRev(self, rev, _options):
     """Verifies the validity of the revision for this repository."""
     if not scm.SVN.IsValidRevision(url='%s@%s' % (self.url, rev)):
       raise gclient_utils.Error(
         ( '%s isn\'t a valid revision. Please check that your safesync_url is\n'
           'correct.') % rev)
     return rev
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
@@ skipping 38 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command