Fix pylint warnings in webkitpy/common/.

third_party/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/git.py

 # Copyright (c) 2009, 2010, 2011 Google Inc. All rights reserved.
 # Copyright (c) 2009 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import datetime
 import logging
 import re
 
-import webkitpy.common.config
 from webkitpy.common.checkout.scm.scm import SCM
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system.executive import Executive, ScriptError
 
 _log = logging.getLogger(__name__)
 
 
 class AmbiguousCommitError(Exception):
 
     def __init__(self, num_local_commits, has_working_directory_changes):
@@ skipping 151 matching lines @@
 
     def display_name(self):
         return "git"
 
     def most_recent_log_matching(self, grep_str, path):
         # We use '--grep=' + foo rather than '--grep', foo because
         # git 1.7.0.4 (and earlier) didn't support the separate arg.
         return self._run_git(['log', '-1', '--grep=' + grep_str, '--date=iso', self.find_checkout_root(path)])
 
     def _commit_position_from_git_log(self, git_log):
-        match = re.search("^\s*Cr-Commit-Position:.*@\{#(?P<commit_position>\d+)\}", git_log, re.MULTILINE)
+        match = re.search(r"^\s*Cr-Commit-Position:.*@\{#(?P<commit_position>\d+)\}", git_log, re.MULTILINE)
         if not match:
             return ""
         return int(match.group('commit_position'))
 
     def commit_position(self, path):
         git_log = self.most_recent_log_matching('Cr-Commit-Position:', path)
         return self._commit_position_from_git_log(git_log)
 
     def _commit_position_regex_for_timestamp(self):
         return 'Cr-Commit-Position:.*@{#%s}'
 
     def timestamp_of_revision(self, path, revision):
         git_log = self.most_recent_log_matching(self._commit_position_regex_for_timestamp() % revision, path)
-        match = re.search("^Date:\s*(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$", git_log, re.MULTILINE)
+        match = re.search(r"^Date:\s*(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$", git_log, re.MULTILINE)
         if not match:
             return ""
 
         # Manually modify the timezone since Git doesn't have an option to show it in UTC.
         # Git also truncates milliseconds but we're going to ignore that for now.
         time_with_timezone = datetime.datetime(int(match.group(1)), int(match.group(2)), int(match.group(3)),
                                                int(match.group(4)), int(match.group(5)), int(match.group(6)), 0)
 
         sign = 1 if match.group(7) == '+' else -1
         time_without_timezone = time_with_timezone - \
@@ skipping 47 matching lines @@
 
     def _remote_branch_ref(self):
         # Use references so that we can avoid collisions, e.g. we don't want to operate on refs/heads/trunk if it exists.
         remote_master_ref = 'refs/remotes/origin/master'
         if not self._branch_ref_exists(remote_master_ref):
             raise ScriptError(message="Can't find a branch to diff against. %s does not exist" % remote_master_ref)
         return remote_master_ref
 
     def commit_locally_with_message(self, message):
         command = ['commit', '--all', '-F', '-']
-        self._run_git(command, input=message)
+        self._run_git(command, input_func=message)
 
     # These methods are git specific and are meant to provide support for the Git oriented workflow
     # that Blink is moving towards, hence there are no equivalent methods in the SVN class.
 
     def pull(self):
         self._run_git(['pull'])
 
     def latest_git_commit(self):
         return self._run_git(['log', '-1', '--format=%H']).strip()
 
     def git_commits_since(self, commit):
         return self._run_git(['log', commit + '..master', '--format=%H', '--reverse']).split()
 
-    def git_commit_detail(self, commit, format=None):
+    def git_commit_detail(self, commit, log_format=None):
         args = ['log', '-1', commit]
         if format:
-            args.append('--format=' + format)
+            args.append('--format=' + log_format)
         return self._run_git(args)
 
     def affected_files(self, commit):
         output = self._run_git(['log', '-1', '--format=', '--name-only', commit])
         return output.strip().split('\n')
 
     def _branch_tracking_remote_master(self):
         origin_info = self._run_git(['remote', 'show', 'origin', '-n'])
-        match = re.search("^\s*(?P<branch_name>\S+)\s+merges with remote master$", origin_info, re.MULTILINE)
+        match = re.search(r"^\s*(?P<branch_name>\S+)\s+merges with remote master$", origin_info, re.MULTILINE)
         if not match:
             raise ScriptError(message="Unable to find local branch tracking origin/master.")
         branch = str(match.group("branch_name"))
         return self._branch_from_ref(self._run_git(['rev-parse', '--symbolic-full-name', branch]).strip())
 
     def is_cleanly_tracking_remote_master(self):
         if self.has_working_directory_changes():
             return False
         if self.current_branch() != self._branch_tracking_remote_master():
             return False
         if len(self._local_commits(self._branch_tracking_remote_master())) > 0:
             return False
         return True
 
     def ensure_cleanly_tracking_remote_master(self):
         self._discard_working_directory_changes()
         self._run_git(['checkout', '-q', self._branch_tracking_remote_master()])
         self._discard_local_commits()
 
     def get_issue_number(self):
         return str(self._run_git(['cl', 'issue']).split()[2])