Remove unnecessary rev_str variable from gclient_scm

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."""
 
 from __future__ import print_function
 
 import errno
 import logging
@@ skipping 343 matching lines @@
       Error: if can't get URL for relative path.
     """
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     self._CheckMinVersion("1.6.6")
 
     # If a dependency is not pinned, track the default remote branch.
     default_rev = 'refs/remotes/%s/master' % self.remote
     url, deps_revision = gclient_utils.SplitUrlRevision(self.url)
-    rev_str = ""
     revision = deps_revision
     managed = True
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if revision == 'unmanaged':
       # Check again for a revision in case an initial ref was specified
       # in the url, for example bla.git@refs/heads/custombranch
       revision = deps_revision
       managed = False
     if not revision:
       revision = default_rev
 
     if managed:
       self._DisableHooks()
 
-    rev_str = ' at %s' % revision
     files = [] if file_list is not None else None
 
     printed_path = False
     verbose = []
     if options.verbose:
-      self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+      self.Print('_____ %s at %s' % (self.relpath, revision), timestamp=False)
       verbose = ['--verbose']
       printed_path = True
 
     remote_ref = scm.GIT.RefToRemoteRef(revision, self.remote)
     if remote_ref:
       # Rewrite remote refs to their local equivalents.
       revision = ''.join(remote_ref)
       rev_type = "branch"
     elif revision.startswith('refs/'):
       # Local branch? We probably don't want to support, since DEPS should
@@ skipping 60 matching lines @@
     # This allows devs to use experimental repos which have a different url
     # but whose branch(s) are the same as official repos.
     if (current_url.rstrip('/') != url.rstrip('/') and
         url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
             cwd=self.checkout_path).strip() != 'False'):
       self.Print('_____ switching %s to a new upstream' % self.relpath)
       if not (options.force or options.reset):
         # Make sure it's clean
-        self._CheckClean(rev_str)
+        self._CheckClean(revision)
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', self.remote, url], options)
       if mirror:
         with open(os.path.join(
             self.checkout_path, '.git', 'objects', 'info', 'alternates'),
             'w') as fh:
           fh.write(os.path.join(url, 'objects'))
       self._EnsureValidHeadObjectOrCheckout(revision, options, url)
       self._FetchAndReset(revision, file_list, options)
 
@@ skipping 56 matching lines @@
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
       target = 'HEAD'
       if options.upstream and upstream_branch:
         target = upstream_branch
       self._Run(['reset', '--hard', target], options)
 
     if current_type == 'detached':
       # case 0
-      self._CheckClean(rev_str)
-      self._CheckDetachedHead(rev_str, options)
+      self._CheckClean(revision)
+      self._CheckDetachedHead(revision, options)
       if self._Capture(['rev-list', '-n', '1', 'HEAD']) == revision:
         self.Print('Up-to-date; skipping checkout.')
       else:
         # 'git checkout' may need to overwrite existing untracked files. Allow
         # it only when nuclear options are enabled.
         self._Checkout(
             options,
             revision,
             force=(options.force and options.delete_unversioned_trees),
             quiet=True,
         )
       if not printed_path:
-        self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+        self.Print('_____ %s at %s' % (self.relpath, revision), timestamp=False)
     elif current_type == 'hash':
       # case 1
       # Can't find a merge-base since we don't know our upstream. That makes
       # this command VERY likely to produce a rebase failure. For now we
       # assume origin is our upstream since that's what the old behavior was.
       upstream_branch = self.remote
       if options.revision or deps_revision:
         upstream_branch = revision
       self._AttemptRebase(upstream_branch, files, options,
                           printed_path=printed_path, merge=options.merge)
       printed_path = True
     elif rev_type == 'hash':
       # case 2
       self._AttemptRebase(upstream_branch, files, options,
                           newbase=revision, printed_path=printed_path,
                           merge=options.merge)
       printed_path = True
     elif remote_ref and ''.join(remote_ref) != upstream_branch:
       # case 4
       new_base = ''.join(remote_ref)
       if not printed_path:
-        self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+        self.Print('_____ %s at %s' % (self.relpath, revision), timestamp=False)
       switch_error = ("Could not switch upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please use --force or 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)
       force_switch = False
       if options.force:
         try:
-          self._CheckClean(rev_str)
+          self._CheckClean(revision)
           # case 4a
           force_switch = True
         except gclient_utils.Error as e:
           if options.reset:
             # case 4b
             force_switch = True
           else:
             switch_error = '%s\n%s' % (e.message, switch_error)
       if force_switch:
         self.Print("Switching upstream branch from %s to %s" %
@@ skipping 15 matching lines @@
         if options.merge:
           merge_args.append('--ff')
         else:
           merge_args.append('--ff-only')
         merge_args.append(upstream_branch)
         merge_output = self._Capture(merge_args)
       except subprocess2.CalledProcessError as e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           files = []
           if not printed_path:
-            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+            self.Print('_____ %s at %s' % (self.relpath, revision),
+                       timestamp=False)
             printed_path = True
           while True:
             if not options.auto_rebase:
               try:
                 action = self._AskForData(
                     'Cannot %s, attempt to rebase? '
                     '(y)es / (q)uit / (s)kip : ' %
                         ('merge' if options.merge else 'fast-forward merge'),
                     options)
               except ValueError:
@@ skipping 11 matching lines @@
             elif re.match(r'skip|s', action, re.I):
               self.Print('Skipping %s' % self.relpath)
               return
             else:
               self.Print('Input not recognized')
         elif re.match("error: Your local changes to '.*' would be "
                       "overwritten by merge.  Aborting.\nPlease, commit your "
                       "changes or stash them before you can merge.\n",
                       e.stderr):
           if not printed_path:
-            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+            self.Print('_____ %s at %s' % (self.relpath, revision),
+                       timestamp=False)
             printed_path = True
           raise gclient_utils.Error(e.stderr)
         else:
           # Some other problem happened with the merge
           logging.error("Error during fast-forward merge in %s!" % self.relpath)
           self.Print(e.stderr)
           raise
       else:
         # Fast-forward merge was successful
         if not re.match('Already up-to-date.', merge_output) or verbose:
           if not printed_path:
-            self.Print('_____ %s%s' % (self.relpath, rev_str), timestamp=False)
+            self.Print('_____ %s at %s' % (self.relpath, revision),
+                       timestamp=False)
             printed_path = True
           self.Print(merge_output.strip())
           if not verbose:
             # Make the output a little prettier. It's nice to have some
             # whitespace between projects when syncing.
             self.Print('')
 
     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'
+      raise gclient_utils.Error('\n____ %s at %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))
+                                % (self.relpath, revision))
 
     if verbose:
       self.Print('Checked out revision %s' % self.revinfo(options, (), None),
                  timestamp=False)
 
     # 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
@@ skipping 343 matching lines @@
 
   def _IsRebasing(self):
     # Check for any of REBASE-i/REBASE-m/REBASE/AM. Unfortunately git doesn't
     # have a plumbing command to determine whether a rebase is in progress, so
     # for now emualate (more-or-less) git-rebase.sh / git-completion.bash
     g = os.path.join(self.checkout_path, '.git')
     return (
       os.path.isdir(os.path.join(g, "rebase-merge")) or
       os.path.isdir(os.path.join(g, "rebase-apply")))
 
-  def _CheckClean(self, rev_str):
+  def _CheckClean(self, revision):
     lockfile = os.path.join(self.checkout_path, ".git", "index.lock")
     if os.path.exists(lockfile):
       raise gclient_utils.Error(
-        '\n____ %s%s\n'
+        '\n____ %s at %s\n'
         '\tYour repo is locked, possibly due to a concurrent git process.\n'
         '\tIf no git executable is running, then clean up %r and try again.\n'
-        % (self.relpath, rev_str, lockfile))
+        % (self.relpath, revision, lockfile))
 
     # Make sure the tree is clean; see git-rebase.sh for reference
     try:
       scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
                       cwd=self.checkout_path)
     except subprocess2.CalledProcessError:
-      raise gclient_utils.Error('\n____ %s%s\n'
+      raise gclient_utils.Error('\n____ %s at %s\n'
                                 '\tYou have unstaged changes.\n'
                                 '\tPlease commit, stash, or reset.\n'
-                                  % (self.relpath, rev_str))
+                                  % (self.relpath, revision))
     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'
+      raise gclient_utils.Error('\n____ %s at %s\n'
                                 '\tYour index contains uncommitted changes\n'
                                 '\tPlease commit, stash, or reset.\n'
-                                  % (self.relpath, rev_str))
+                                  % (self.relpath, revision))
 
-  def _CheckDetachedHead(self, rev_str, _options):
+  def _CheckDetachedHead(self, revision, _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
-        raise gclient_utils.Error('\n____ %s%s\n'
+        raise gclient_utils.Error('\n____ %s at %s\n'
                                   '\tAlready in a conflict, i.e. (no branch).\n'
                                   '\tFix the conflict and run gclient again.\n'
                                   '\tOr to abort run:\n\t\tgit-rebase --abort\n'
                                   '\tSee man git-rebase for details.\n'
-                                   % (self.relpath, rev_str))
+                                   % (self.relpath, revision))
       # Let's just save off the commit so we can proceed.
       name = ('saved-by-gclient-' +
               self._Capture(['rev-parse', '--short', 'HEAD']))
       self._Capture(['branch', '-f', name])
       self.Print('_____ found an unreferenced commit and saved it as \'%s\'' %
           name)
 
   def _GetCurrentBranch(self):
     # Returns name of current branch or None for detached HEAD
     branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
@@ skipping 69 matching lines @@
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stdout', self.out_fh)
     kwargs['filter_fn'] = self.filter
     kwargs.setdefault('print_stdout', False)
     env = scm.GIT.ApplyEnvVars(kwargs)
     cmd = ['git'] + args
     if show_header:
       gclient_utils.CheckCallAndFilterAndHeader(cmd, env=env, **kwargs)
     else:
       gclient_utils.CheckCallAndFilter(cmd, env=env, **kwargs)