Noissue - Fix edge cases with raw strings in flake8-abp

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 366 matching lines @@
 
 
 def check_quotes(logical_line, tokens, previous_logical):
     first_token = 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)?((""")?.*)$',
+            match = re.search(r'^([rub]*)([\'"]{1,3})(.*)\2$',

[Sebastian Noack, 2016/05/30 09:57:42]

On Python 3, you can write br'' as well as rb''. The old regexp, however, relied
on 'b' always occurring before 'r'.

                               token, re.IGNORECASE | re.DOTALL)
-            (is_unicode, is_bytes, is_raw,
-             literal, has_doc_quotes) = match.groups()
+            prefixes, quote, text = match.groups()
+            prefixes = prefixes.lower()
 
             if first_token and re.search(r'^(?:(?:def|class)\s|$)',
                                          previous_logical):
-                if not has_doc_quotes:
+                if quote != '"""':
                     yield (start, 'A109 use triple double '
                                   'quotes for docstrings')
-                elif is_unicode or is_bytes or is_raw:
+                elif prefixes:
                     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]),

[Sebastian Noack, 2016/05/30 09:57:42]

The problem with old logic was that there are cases in which a string if using
raw syntax requires double quotes while repr() would use single quotes.

Example: r"'\"" -> '\'\\"'

Since backslashes in raw strings are both interpreted as literal backslashes and
escape quotes at the same time. We cannot write the above raw string like r'\'"'
since this is interpreted as '\\\'"'.

[Vasily Kuznetsov, 2016/05/30 10:08:19]

I think it would be good to add a test for this case.

[Sebastian Noack, 2016/05/30 10:18:04]

Done.

-                                     '\\\\\\\\', literal)
+                if 'r' in prefixes:
+                    if quote != "'" and not (quote == '"' and "'" in text):
+                        yield (start, 'A110 use single quotes for raw string')
+                else:
+                    prefix = 'b' if sys.version_info[0] >= 3 else 'u'
+                    if prefix not in prefixes:
+                        prefix = ''
 
-                if sys.version_info[0] >= 3:
-                    if is_bytes:
-                        literal = 'b' + literal
-                elif is_unicode:
-                    literal = 'u' + literal
-
-                if ascii(eval(literal)) != literal:
-                    yield (start, "A110 string literal doesn't match "
-                                  '{}()'.format(ascii.__name__))
+                    literal = '{0}{1}{2}{1}'.format(prefix, quote, text)
+                    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__
 
 
 def check_redundant_parenthesis(logical_line, tokens):
     start_line = tokens[0][2][0]
     level = 0
@@ skipping 39 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__