Initial commit for future import parsing.

Author: Nurdok

pep257.py

@@ -100,9 +100,9 @@ def __eq__(self, other):
         return other and vars(self) == vars(other)
 
     def __repr__(self):
-        kwargs = ', '.join('{}={!r}'.format(field, getattr(self, field))
+        kwargs = ', '.join('{0}={1!r}'.format(field, getattr(self, field))
                            for field in self._fields)
-        return '{}({})'.format(self.__class__.__name__, kwargs)
+        return '{0}({1})'.format(self.__class__.__name__, kwargs)
 
 
 class Definition(Value):
@@ -131,7 +131,7 @@ def __str__(self):
 class Module(Definition):
 
     _fields = ('name', '_source', 'start', 'end', 'decorators', 'docstring',
-               'children', 'parent', '_all')
+               'children', 'parent', '_all', 'unicode_literals')
     is_public = True
     _nest = staticmethod(lambda s: {'def': Function, 'class': Class}[s])
     module = property(lambda self: self)
@@ -251,6 +251,8 @@ def __call__(self, filelike, filename):
         self.stream = TokenStream(StringIO(src))
         self.filename = filename
         self.all = None
+        # TODO: what about Python 3.x?
+        self.unicode_literals = False
         self._accumulated_decorators = []
         return self.parse_module()
 
@@ -349,6 +351,8 @@ def parse_definitions(self, class_, all=False):
             elif self.current.kind == tk.DEDENT:
                 self.consume(tk.DEDENT)
                 return
+            elif self.current.value == 'from':
+                self.parse_from_import_statement()
             else:
                 self.stream.move()
 
@@ -410,6 +414,7 @@ def parse_module(self):
                      [], docstring, children, None, self.all)
         for child in module.children:
             child.parent = module
+        module.unicode_literals = self.unicode_literals
         log.debug("finished parsing module.")
         return module
 
@@ -460,6 +465,24 @@ def parse_definition(self, class_):
                   self.current.value)
         return definition
 
+    def parse_from_import_statement(self):
+        """Parse a 'from x import y' statement.
+
+        The purpose is to find __future__ statements.
+
+        """
+        log.debug('parsing from/import statement.')
+        assert self.current.value == 'from', self.current.value
+        self.stream.move()
+        if self.current.value != '__future__':
+            return
+        self.stream.move()
+        assert self.current.value == 'import', self.current.value
+        self.stream.move()
+        # TODO: lookout for parenthesis, comments, line breaks, etc.
+        if self.current.value == 'unicode_literals':
+            self.unicode_literals = True
+
 
 class Error(object):
 
@@ -1123,6 +1146,9 @@ def check_unicode_docstring(self, definition, docstring):
         For Unicode docstrings, use u"""Unicode triple-quoted strings""".
 
         '''
+        if definition.module.unicode_literals:
+            return
+
         # Just check that docstring is unicode, check_triple_double_quotes
         # ensures the correct quotes.
         if docstring and sys.version_info[0] <= 2:

test.py

@@ -286,4 +286,11 @@ def a_following_valid_function(x):
 
     """
 
+
+def outer_function():
+    """Do something."""
+    def inner_function():
+        """Do inner something."""
+        return 0
+
 expect('test.py', 'D100: Missing docstring in public module')

test_definitions.py

@@ -35,14 +35,19 @@ def nested_3(self):
     # Inconvenient comment.
     'a', 'b' 'c',]
 '''
+source_unicode_literals = '''
+from __future__ import unicode_literals
+'''
 
 
 def test_parser():
     dunder_all = ('a', 'bc')
+    unicode_literals = False
     module = parse(StringIO(source), 'file.py')
     assert len(list(module)) == 8
     assert Module('file.py', _, 1, len(source.split('\n')),
-                  _, '"""Module."""', _, _, dunder_all) == module
+                  _, '"""Module."""', _, _, dunder_all, unicode_literals) == \
+        module
 
     function, class_ = module.children
     assert Function('function', _, _, _, _, '"Function."', _,
@@ -70,12 +75,17 @@ def test_parser():
 
     module = parse(StringIO(source_alt), 'file_alt.py')
     assert Module('file_alt.py', _, 1, len(source_alt.split('\n')),
-                  _, None, _, _, dunder_all) == module
+                  _, None, _, _, dunder_all, unicode_literals) == module
 
     module = parse(StringIO(source_alt_nl_at_bracket), 'file_alt_nl.py')
     assert Module('file_alt_nl.py', _, 1,
                   len(source_alt_nl_at_bracket.split('\n')), _, None, _, _,
-                  dunder_all) == module
+                  dunder_all, unicode_literals) == module
+
+    module = parse(StringIO(source_unicode_literals), 'file_ucl.py')
+    assert Module('file_ucl.py', _, 1,
+                  _, _, None, _, _,
+                  _, True) == module
 
 
 def _test_module():

test_pep257.py

@@ -297,3 +297,75 @@ def test_illegal_convention():
         assert code == 2
         assert "Illegal convention 'illegal_conv'." in err
         assert 'Possible conventions: pep257' in err
+
+
+def test_unicode_literals():
+
+    if sys.version_info[0] >= 3:
+        return  # ur"" is a syntax error in python 3.x
+
+    # This is all to avoid a syntax error for python 3.2
+    from codecs import unicode_escape_decode
+
+    def u(x):
+        return unicode_escape_decode(x)[0]
+
+    # Check that D302 is reported with unicode docstring
+    with Pep257Env() as env:
+        with env.open('example.py', 'wt') as example:
+            example.write(textwrap.dedent(u('''\
+                # -*- coding: utf-8 -*-
+                """This is a modue."""
+
+                def foo():
+                    """Check unicode: \u2611."""
+            ''').encode('utf-8')))
+        _, err, code = env.invoke_pep257()
+        assert code == 1
+        assert 'D302' in err
+
+    # Check that D302 is not reported when import unicode_literals
+    with Pep257Env() as env:
+        with env.open('example.py', 'wt') as example:
+            example.write(textwrap.dedent(u('''\
+                # -*- coding: utf-8 -*-
+                """This is a module."""
+
+                from __future__ import unicode_literals
+
+                def foo():
+                    """Check unicode: \u2611."""
+            ''').encode('utf-8')))
+        _, err, code = env.invoke_pep257()
+        assert code == 0, err
+
+    with Pep257Env() as env:
+        with env.open('example.py', 'wt') as example:
+            example.write(textwrap.dedent(u('''\
+                # -*- coding: utf-8 -*-
+                """This is a module."""
+
+                from __future__ import (nested_scopes as ns,
+                unicode_literals)
+
+                def foo():
+                    """Check unicode: \u2611."""
+            ''').encode('utf-8')))
+        _, err, code = env.invoke_pep257()
+        assert code == 0, err
+
+    with Pep257Env() as env:
+        with env.open('example.py', 'wt') as example:
+            example.write(textwrap.dedent(u('''\
+                # -*- coding: utf-8 -*-
+                """This is a module."""
+
+                from __future__ import \
+                    nested_scopes, \
+                    unicode_literals as ul
+
+                def foo():
+                    """Check unicode: \u2611."""
+            ''').encode('utf-8')))
+        _, err, code = env.invoke_pep257()
+        assert code == 0, err