Add tests for safe (correct) division changes in futurize

Author: edschofield

future/tests/test_futurize.py

@@ -436,16 +436,16 @@ def addup(*x):
         assert addup(*(10,20)) == 30
         """
         self.convert_check(before, after)
-    
+
     @unittest.skip('not implemented yet')
     def test_download_pypi_package_and_test(self):
         URL = 'http://pypi.python.org/pypi/{0}/json'
-        
+
         import requests
         package = 'future'
         r = requests.get(URL.format(package))
         pprint.pprint(r.json())
-        
+
         download_url = r.json()['urls'][0]['url']
         filename = r.json()['urls'][0]['filename']
         # r2 = requests.get(download_url)
@@ -527,7 +527,7 @@ def test_division(self):
         from future.utils import old_div
         x = old_div(1, 2)
         """
-        self.convert_check(before, after, stages=[1])
+        self.convert_check(before, after, stages=[1, 2])
 
 
 class TestFuturizeRenamedStdlib(CodeHandler):
@@ -546,7 +546,7 @@ def test_renamed_modules(self):
         import io
         """
         self.convert_check(before, after)
-    
+
     @unittest.skip('Not working yet ...')
     def test_urllib_refactor(self):
         # Code like this using urllib is refactored by futurize --stage2 to use
@@ -818,7 +818,7 @@ def test_print(self):
 
     def test_print_already_function(self):
         """
-        Running futurize --stage1 should not add a second set of parentheses 
+        Running futurize --stage1 should not add a second set of parentheses
         """
         before = """
         print('Hello')
@@ -1025,6 +1025,78 @@ def test_issue_12(self):
         """
         self.unchanged(code)
 
+    def test_safe_division(self):
+        """
+        Tests whether Py2 scripts using old-style division still work
+        after futurization.
+        """
+        before = """
+        x = 3 / 2
+        y = 3. / 2
+        assert x == 1 and isinstance(x, int)
+        assert y == 1.5 and isinstance(y, float)
+        """
+        after = """
+        from __future__ import division
+        from future.utils import old_div
+        x = old_div(3, 2)
+        y = old_div(3. / 2)
+        assert x == 1 and isinstance(x, int)
+        assert y == 1.5 and isinstance(y, float)
+        """
+        self.convert_check(before, after)
+
+    def test_safe_division_overloaded(self):
+        """
+        If division is overloaded, futurize may produce spurious old_div
+        calls.  This test is for whether the code still works on Py2
+        despite these calls.
+        """
+        before = """
+        class Path(str):
+            def __div__(self, other):
+                return Path(str(self) + '/' + str(other))
+        path1 = Path('home')
+        path2 = Path('user')
+        z = path1 / path2
+        assert isinstance(z, Path)
+        assert str(z) == 'home/user'
+        """
+        after = """
+        from __future__ import division
+        from future.utils import old_div
+        class Path(str):
+            def __truediv__(self, other):
+                return Path(str(self) + '/' + str(other))
+        path1 = Path('home')
+        path2 = Path('user')
+        z = old_div(path1 / path2)
+        assert isinstance(z, Path)
+        assert str(z) == 'home/user'
+        """
+        self.convert_check(before, after)
+
+    def test_range_necessary_list_calls(self):
+        before = """
+        l = range(10)
+        assert isinstance(l, list)
+        for i in range(3):
+            print i
+        for i in xrange(3):
+            print i
+        """
+        after = """
+        from __future__ import print_function
+        from future.builtins import range
+        l = list(range(10))
+        assert isinstance(l, list)
+        for i in range(3):
+            print(i)
+        for i in range(3):
+            print(i)
+        """
+        self.convert_check(before, after)
+
 
 if __name__ == '__main__':
     unittest.main()

libfuturize/fixes/fix_division_safe.py

@@ -0,0 +1,40 @@
+"""
+For the ``future`` package.
+
+Adds this import line:
+
+    from __future__ import division
+
+at the top and changes any old-style divisions to be calls to
+future.utils.old_div so the code runs as before on Py2.6/2.7 and has the same
+behaviour on Py3.
+"""
+
+from lib2to3 import fixer_base
+from lib2to3.fixer_util import touch_import
+from libfuturize.fixer_util import token, future_import
+
+def match_division(node):
+    u"""
+    __future__.division redefines the meaning of a single slash for division,
+    so we match that and only that.
+    """
+    slash = token.SLASH
+    return node.type == slash and not node.next_sibling.type == slash and \
+                                  not node.prev_sibling.type == slash
+
+class FixDivisionSafe(fixer_base.BaseFix):
+    run_order = 4    # this seems to be ignored?
+
+    def match(self, node):
+        u"""
+        Since the tree needs to be fixed once and only once if and only if it
+        matches, then we can start discarding matches after we make the first.
+        """
+        return match_division(node)
+
+    def transform(self, node, results):
+        import pdb
+        pdb.set_trace()
+        future_import(u"division", node)
+        touch_import(u'future.utils', u'old_div', node)