pylint: upgrade to 1.4.0

third_party/pylint/checkers/logging.py

 # Copyright (c) 2009-2010 Google, Inc.
 # This program is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free Software
 # Foundation; either version 2 of the License, or (at your option) any later
 # version.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License along with
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """checker for use of Python logging
 """
 
 import astroid
 from pylint import checkers
 from pylint import interfaces
 from pylint.checkers import utils
 from pylint.checkers.utils import check_messages
 
+import six
+
+
 MSGS = {
     'W1201': ('Specify string format arguments as logging function parameters',
               'logging-not-lazy',
               'Used when a logging statement has a call form of '
               '"logging.<logging method>(format_string % (format_args...))". '
               'Such calls should leave string interpolation to the logging '
               'method itself and be written '
               '"logging.<logging method>(format_string, format_args...)" '
               'so that the program may avoid incurring the cost of the '
               'interpolation in those cases in which no message will be '
               'logged. For more, see '
               'http://www.python.org/dev/peps/pep-0282/.'),
+    'W1202': ('Use % formatting in logging functions but pass the % '
+              'parameters as arguments',
+              'logging-format-interpolation',
+              'Used when a logging statement has a call form of '
+              '"logging.<logging method>(format_string.format(format_args...))"'
+              '. Such calls should use % formatting instead, but leave '
+              'interpolation to the logging function by passing the parameters '
+              'as arguments.'),
     'E1200': ('Unsupported logging format character %r (%#02x) at index %d',
               'logging-unsupported-format',
               'Used when an unsupported format character is used in a logging\
               statement format string.'),
     'E1201': ('Logging format string ends in middle of conversion specifier',
               'logging-format-truncated',
               'Used when a logging statement format string terminates before\
               the end of a conversion specifier.'),
     'E1205': ('Too many arguments for logging format string',
               'logging-too-many-args',
               'Used when a logging format string is given too few arguments.'),
     'E1206': ('Not enough arguments for logging format string',
               'logging-too-few-args',
               'Used when a logging format string is given too many arguments'),
     }
 
 
 CHECKED_CONVENIENCE_FUNCTIONS = set([
     'critical', 'debug', 'error', 'exception', 'fatal', 'info', 'warn',
     'warning'])
 
+def is_method_call(callfunc_node, types=(), methods=()):
+    """Determines if a CallFunc node represents a method call.
+
+    Args:
+      callfunc_node: The CallFunc AST node to check.
+      types: Optional sequence of caller type names to restrict check.
+      methods: Optional sequence of method names to restrict check.
+
+    Returns:
+      True, if the node represents a method call for the given type and
+      method names, False otherwise.
+    """
+    if not isinstance(callfunc_node, astroid.CallFunc):
+        return False
+    func = utils.safe_infer(callfunc_node.func)
+    return (isinstance(func, astroid.BoundMethod)
+            and isinstance(func.bound, astroid.Instance)
+            and (func.bound.name in types if types else True)
+            and (func.name in methods if methods else True))
+
+
 
 class LoggingChecker(checkers.BaseChecker):
     """Checks use of the logging module."""
 
     __implements__ = interfaces.IAstroidChecker
     name = 'logging'
     msgs = MSGS
 
     options = (('logging-modules',
-                {'default' : ('logging',),
-                 'type' : 'csv',
-                 'metavar' : '<comma separated list>',
-                 'help' : 'Logging modules to check that the string format '
-                          'arguments are in logging function parameter format'}
+                {'default': ('logging',),
+                 'type': 'csv',
+                 'metavar': '<comma separated list>',
+                 'help': 'Logging modules to check that the string format '
+                         'arguments are in logging function parameter format'}
                ),
               )
 
-    def visit_module(self, unused_node):
+    def visit_module(self, node): # pylint: disable=unused-argument
         """Clears any state left in this checker from last module checked."""
         # The code being checked can just as easily "import logging as foo",
         # so it is necessary to process the imports and store in this field
         # what name the logging module is actually given.
         self._logging_names = set()
         logging_mods = self.config.logging_modules
 
         self._logging_modules = set(logging_mods)
         self._from_imports = {}
         for logging_mod in logging_mods:
@@ skipping 59 matching lines @@
             if node.starargs or node.kwargs or not node.args:
                 # Either no args, star args, or double-star args. Beyond the
                 # scope of this checker.
                 return
             format_pos = 0
         else:
             return
 
         if isinstance(node.args[format_pos], astroid.BinOp) and node.args[format_pos].op == '%':
             self.add_message('logging-not-lazy', node=node)
+        elif isinstance(node.args[format_pos], astroid.CallFunc):
+            self._check_call_func(node.args[format_pos])
         elif isinstance(node.args[format_pos], astroid.Const):
             self._check_format_string(node, format_pos)
 
+    def _check_call_func(self, callfunc_node):
+        """Checks that function call is not format_string.format().
+
+        Args:
+          callfunc_node: CallFunc AST node to be checked.
+        """
+        if is_method_call(callfunc_node, ('str', 'unicode'), ('format',)):
+            self.add_message('logging-format-interpolation', node=callfunc_node)
+
     def _check_format_string(self, node, format_arg):
         """Checks that format string tokens match the supplied arguments.
 
         Args:
           node: AST node to be checked.
           format_arg: Index of the format string in the node arguments.
         """
         num_args = _count_supplied_tokens(node.args[format_arg + 1:])
         if not num_args:
             # If no args were supplied, then all format strings are valid -
             # don't check any further.
             return
         format_string = node.args[format_arg].value
-        if not isinstance(format_string, basestring):
+        if not isinstance(format_string, six.string_types):
             # If the log format is constant non-string (e.g. logging.debug(5)),
             # ensure there are no arguments.
             required_num_args = 0
         else:
             try:
                 keyword_args, required_num_args = \
                     utils.parse_format_string(format_string)
                 if keyword_args:
                     # Keyword checking on logging strings is complicated by
                     # special keywords - out of scope.
                     return
-            except utils.UnsupportedFormatCharacter, ex:
+            except utils.UnsupportedFormatCharacter as ex:
                 char = format_string[ex.index]
                 self.add_message('logging-unsupported-format', node=node,
                                  args=(char, ord(char), ex.index))
                 return
             except utils.IncompleteFormatString:
                 self.add_message('logging-format-truncated', node=node)
                 return
         if num_args > required_num_args:
             self.add_message('logging-too-many-args', node=node)
         elif num_args < required_num_args:
@@ skipping 12 matching lines @@
 
     Returns:
       Number of AST nodes that aren't keywords.
     """
     return sum(1 for arg in args if not isinstance(arg, astroid.Keyword))
 
 
 def register(linter):
     """Required method to auto-register this checker."""
     linter.register_checker(LoggingChecker(linter))