Add pylintrc and fix style for many scripts.

gclient_scm.py

 # Copyright (c) 2010 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 logging
 import os
 import posixpath
 import re
@@ skipping 12 matching lines @@
   original_prefix = "--- "
   working_prefix = "+++ "
 
   def __init__(self, relpath):
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
     self._relpath = relpath.replace("\\", "/")
     self._current_file = ""
     self._replacement_file = ""
 
-  def SetCurrentFile(self, file):
-    self._current_file = file
+  def SetCurrentFile(self, current_file):
+    self._current_file = current_file
     # Note that we always use '/' as the path separator to be
     # consistent with svn's cygwin-style output on Windows
-    self._replacement_file = posixpath.join(self._relpath, file)
+    self._replacement_file = posixpath.join(self._relpath, current_file)
 
   def ReplaceAndPrint(self, line):
     print(line.replace(self._current_file, self._replacement_file))
 
   def Filter(self, line):
     if (line.startswith(self.index_string)):
       self.SetCurrentFile(line[len(self.index_string):])
       self.ReplaceAndPrint(line)
     else:
       if (line.startswith(self.original_prefix) or
@@ skipping 59 matching lines @@
     if not command in dir(self):
       raise gclient_utils.Error('Command %s not implemented in %s wrapper' % (
           command, self.scm_name))
 
     return getattr(self, command)(options, args, file_list)
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
 
-  def cleanup(self, options, args, file_list):
+  @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.
     """
-    __pychecker__ = 'unusednames=options,args,file_list'
 
   def diff(self, options, args, file_list):
-    __pychecker__ = 'unusednames=options,args,file_list'
     merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
     self._Run(['diff', merge_base], redirect_stdout=False)
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path.
 
     Exports into the specified directory, creating the path if it does
     already exist.
     """
-    __pychecker__ = 'unusednames=options,file_list'
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     if not os.path.exists(export_path):
       os.makedirs(export_path)
     self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path],
               redirect_stdout=False)
 
   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.
     """
-    __pychecker__ = 'unusednames=options,args,file_list'
     path = os.path.join(self._root_dir, self.relpath)
     merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
     command = ['diff', merge_base]
     filterer = DiffFilterer(self.relpath)
     scm.GIT.RunAndFilterOutput(command, path, False, False, filterer.Filter)
 
   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.
@@ skipping 235 matching lines @@
                                 % (self.relpath, rev_str))
 
     if verbose:
       print "Checked out revision %s" % self.revinfo(options, (), None)
 
   def revert(self, options, args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
-    __pychecker__ = 'unusednames=args'
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(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"
-    url, deps_revision = gclient_utils.SplitUrlRevision(self.url)
+    _, 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._Run(['diff', deps_revision, '--name-only']).split()
     self._Run(['reset', '--hard', deps_revision], redirect_stdout=False)
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def revinfo(self, options, args, file_list):
     """Display revision"""
-    __pychecker__ = 'unusednames=options,args,file_list'
     return self._Run(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
-    __pychecker__ = 'unusednames=options,args'
     if not os.path.isdir(self.checkout_path):
       print('\n________ couldn\'t run status in %s:\nThe directory '
             'does not exist.' % self.checkout_path)
     else:
       merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
       self._Run(['diff', '--name-status', merge_base], redirect_stdout=False)
       files = self._Run(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
@@ skipping 120 matching lines @@
                                   + "%s" % ' '.join(rebase_cmd))
 
     print rebase_output.strip()
     if rebase_err:
       print "Rebase produced error output:\n%s" % rebase_err.strip()
     if not verbose:
       # Make the output a little prettier. It's nice to have some
       # whitespace between projects when syncing.
       print ""
 
-  def _CheckMinVersion(self, min_version):
+  @staticmethod
+  def _CheckMinVersion(min_version):
     (ok, current_version) = scm.GIT.AssertVersion(min_version)
     if not ok:
       raise gclient_utils.Error('git version %s < minimum required %s' %
                                 (current_version, min_version))
 
   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):
     # Make sure the tree is clean; see git-rebase.sh for reference
     try:
       scm.GIT.Capture(['update-index', '--ignore-submodules', '--refresh'],
                       self.checkout_path, print_error=False)
-    except gclient_utils.CheckCallError, e:
-        raise gclient_utils.Error('\n____ %s%s\n'
-                                  '\tYou have unstaged changes.\n'
-                                  '\tPlease commit, stash, or reset.\n'
-                                   % (self.relpath, rev_str))
+    except gclient_utils.CheckCallError:
+      raise gclient_utils.Error('\n____ %s%s\n'
+                                '\tYou have unstaged changes.\n'
+                                '\tPlease commit, stash, or reset.\n'
+                                  % (self.relpath, rev_str))
     try:
       scm.GIT.Capture(['diff-index', '--cached', '--name-status', '-r',
                        '--ignore-submodules', 'HEAD', '--'], self.checkout_path,
                        print_error=False)
-    except gclient_utils.CheckCallError, e:
-        raise gclient_utils.Error('\n____ %s%s\n'
-                                  '\tYour index contains uncommitted changes\n'
-                                  '\tPlease commit, stash, or reset.\n'
-                                   % (self.relpath, rev_str))
+    except gclient_utils.CheckCallError:
+      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):
     # 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:
-      out, err = scm.GIT.Capture(
+      _, _ = scm.GIT.Capture(
         ['name-rev', '--no-undefined', 'HEAD'],
         self.checkout_path,
         print_error=False)
-    except gclient_utils.CheckCallError, e:
+    except gclient_utils.CheckCallError:
       # 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'
                                   '\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))
       # Let's just save off the commit so we can proceed.
@@ skipping 31 matching lines @@
                                 (args[0], sp.returncode))
     if output is not None:
       return output.strip()
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
-    __pychecker__ = 'unusednames=file_list,options'
     command = ['cleanup']
     command.extend(args)
     scm.SVN.Run(command, os.path.join(self._root_dir, self.relpath))
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
-    __pychecker__ = 'unusednames=file_list,options'
     command = ['diff']
     command.extend(args)
     scm.SVN.Run(command, os.path.join(self._root_dir, self.relpath))
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path."""
-    __pychecker__ = 'unusednames=file_list,options'
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     try:
       os.makedirs(export_path)
     except OSError:
       pass
     assert os.path.exists(export_path)
     command = ['export', '--force', '.']
     command.append(export_path)
     scm.SVN.Run(command, os.path.join(self._root_dir, self.relpath))
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
-    __pychecker__ = 'unusednames=file_list,options'
     path = os.path.join(self._root_dir, self.relpath)
     command = ['diff']
     command.extend(args)
 
     filterer = DiffFilterer(self.relpath)
     scm.SVN.RunAndFilterOutput(command, path, False, False, filterer.Filter)
 
   def update(self, options, args, file_list):
     """Runs svn to update or transparently checkout the working copy.
 
@@ skipping 127 matching lines @@
                  os.path.join(checkout_path, filename)]
       command = self.AddAdditionalFlags(command, options, options.revision)
       scm.SVN.Run(command, self._root_dir)
 
   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.
     """
-    __pychecker__ = 'unusednames=args'
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # svn 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)
 
     for file_status in scm.SVN.CaptureStatus(path):
       file_path = os.path.join(path, file_status[1])
@@ skipping 32 matching lines @@
       # "svn up --revision BASE" achieve the same effect.
       scm.SVN.RunAndGetFileList(options, ['update', '--revision', 'BASE'], path,
                                 file_list)
     except OSError, e:
       # Maybe the directory disapeared meanwhile. We don't want it to throw an
       # exception.
       logging.error('Failed to update:\n%s' % str(e))
 
   def revinfo(self, options, args, file_list):
     """Display revision"""
-    __pychecker__ = 'unusednames=args,file_list,options'
     return scm.SVN.CaptureBaseRevision(self.checkout_path)
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     path = os.path.join(self._root_dir, self.relpath)
     command = ['status']
     command.extend(args)
     if not os.path.isdir(path):
       # svn status won't work if the directory doesn't exist.
       print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
             "does not exist."
             % (' '.join(command), path))
       # There's no file list to retrieve.
     else:
       scm.SVN.RunAndGetFileList(options, command, path, file_list)
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
 
-  def AddAdditionalFlags(self, command, options, revision):
+  @staticmethod
+  def AddAdditionalFlags(command, options, revision):
     """Add additional flags to command depending on what options are set.
     command should be a list of strings that represents an svn command.
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if options.force and scm.SVN.AssertVersion("1.5")[0]:
       new_command.append('--force')
     return new_command