Issue 4044 - Added handling for __future__ unicode_literals import to check_quotes()

flake8-abp/flake8_abp.py

 # This file is part of Adblock Plus <https://adblockplus.org/>,
 # Copyright (C) 2006-2016 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus 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
@@ skipping 26 matching lines @@
     're.match': 're.search',
     'codecs.open': 'io.open',
 }
 
 ESSENTIAL_BUILTINS = set(dir(builtins)) - {'apply', 'buffer', 'coerce',
                                            'intern', 'file'}
 
 LEAVE_BLOCK = (ast.Return, ast.Raise, ast.Continue, ast.Break)
 VOLATILE = object()
 
+is_unicode_literals = False
+
 
 def evaluate(node):
     try:
         return eval(compile(ast.Expression(node), '', 'eval'), {})
     except Exception:
         return VOLATILE
 
 
 def is_const(node):
     return evaluate(node) is not VOLATILE
@@ skipping 313 matching lines @@
 def check_non_default_encoding(physical_line, line_number):
     if line_number <= 2 and re.search(r'^\s*#.*coding[:=]', physical_line):
         return (0, 'A303 non-default file encoding')
 
 check_non_default_encoding.name = 'abp-non-default-encoding'
 check_non_default_encoding.version = __version__
 
 
 def check_quotes(logical_line, tokens, previous_logical):
     first_token = True
+    global is_unicode_literals
+
+    # check if this is beginning of file
+    if tokens[0][3][0] == 1:
+        is_unicode_literals = False
+
+    # check if in unicode_literals mode
+    token_strings = [t[1] for t in tokens]
+    if token_strings[:3] == ['from', '__future__', 'import']:
+        if 'unicode_literals' in token_strings:
+            is_unicode_literals = True
 
     for kind, token, start, end, _ in tokens:
         if kind == tokenize.INDENT or kind == tokenize.DEDENT:
             continue
 
         if kind == tokenize.STRING:
             match = re.search(r'^(u)?(b)?(r)?((""")?.*)$',
                               token, re.IGNORECASE | re.DOTALL)
             (is_unicode, is_bytes, is_raw,
              literal, has_doc_quotes) = match.groups()
 
             if first_token and re.search(r'^(?:(?:def|class)\s|$)',
                                          previous_logical):
                 if not has_doc_quotes:
                     yield (start, 'A109 use triple double '
                                   'quotes for docstrings')
-                elif is_unicode or is_bytes or is_raw:
-                    yield (start, "A109 don't use u'', b'' "
-                                  "or r'' for doc strings")
+                if is_unicode and not is_unicode_literals:

[Vasily Kuznetsov, 2016/05/26 19:29:44]

Actually if is_unicode_literals is True, this error should still be raised
because u is even more redundant.

And this check can be moved out of the `if` (and another copy of it below
removed) since we want to do it for all strings, single-line and multiline,
docstrings or not.

+                    yield (start, 'A112 use "from __future__ import'
+                                  'unicode_literals" instead of '
+                                  'prefixing literals with "u"')
             elif start[0] == end[0]:
                 if is_raw:
                     literal = re.sub(r'\\(?!{})'.format(literal[0]),
                                      '\\\\\\\\', literal)
-
+                if is_unicode and not is_unicode_literals:
+                    yield (start, 'A112 use "from __future__ import'
+                                  'unicode_literals" instead of '
+                                  'prefixing literals with "u"')
                 if sys.version_info[0] >= 3:
                     if is_bytes:
                         literal = 'b' + literal
-                elif is_unicode:
+                elif not is_bytes:
                     literal = 'u' + literal
 
                 if ascii(eval(literal)) != literal:
                     yield (start, "A110 string literal doesn't match "
                                   '{}()'.format(ascii.__name__))
 
         first_token = False
 
 check_quotes.name = 'abp-quotes'
 check_quotes.version = __version__
@@ skipping 44 matching lines @@
                     if tokens[i + 1][:2] != (tokenize.OP, ':'):
                         break
 
                     return [(pos, 'A111 redundant parenthesis for {} '
                                   'statement'.format(statement))]
 
     return []
 
 check_redundant_parenthesis.name = 'abp-redundant-parenthesis'
 check_redundant_parenthesis.version = __version__