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

[Sebastian Noack, 2016/05/27 12:33:48]

has_unicode_literals seems to be more correct grammatically.

+
 
 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:

[Sebastian Noack, 2016/05/27 12:13:55]

This is an superfluous level of indentation. I'd rather use an additional
variable to avoid a long line here:

  token_strings = [t[1] for t in tokens]
  future_import = token_strings[:3] == ['from', '__future__', 'import']
  if future_import and 'unicode_literals' in token_strings:
      is_unicode_literals = True

[Jon Sonesen, 2016/06/01 17:06:59]

I like that and will get it done.

+            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 is_unicode:
+                yield (start, 'A112 use "from __future__ import'

[Sebastian Noack, 2016/05/27 12:13:55]

A space is missing here. This message would be printed as "..
importunicode_literals .."

+                              'unicode_literals" instead of '
+                              'prefixing literals with "u"')
             if first_token and re.search(r'^(?:(?:def|class)\s|$)',

[Sebastian Noack, 2016/05/27 12:13:55]

Since this is not an else or elif block, I think the code reads a little better
with a blank line above, so that it's more obvious that the logic below is
independent of the logic above.

                                          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")
             elif start[0] == end[0]:
                 if is_raw:
                     literal = re.sub(r'\\(?!{})'.format(literal[0]),
                                      '\\\\\\\\', literal)
-
                 if sys.version_info[0] >= 3:
                     if is_bytes:
                         literal = 'b' + literal
-                elif is_unicode:
+                elif not is_bytes:

[Sebastian Noack, 2016/05/27 12:33:48]

Currently, the is_unicode_literals variable is never used. If I didn't miss
something the check here needs to be:

  is_unicode or is_unicode_literals and 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__