Add safe fixer for division: 3 / 5 -> old_div(3, 5)

Also move ``old_div`` to ``past.utils``

Author: edschofield

future/tests/test_futurize.py

@@ -49,10 +49,11 @@ def test_shebang_blank_with_future_division_import(self):
         """
         after = """
         #!/usr/bin/env python
-        from __future__ import division
 
+        from __future__ import division
+        from past.utils import old_div
         import math
-        1 / 5
+        old_div(1, 5)
         """
         self.convert_check(before, after)
 
@@ -515,7 +516,6 @@ def test_literal_prefixes_are_not_stripped(self):
         '''
         self.unchanged(code)
 
-    @unittest.expectedFailure
     def test_division(self):
         """
         TODO: implement this!
@@ -524,7 +524,7 @@ def test_division(self):
         x = 1 / 2
         """
         after = """
-        from future.utils import old_div
+        from past.utils import old_div
         x = old_div(1, 2)
         """
         self.convert_check(before, after, stages=[1, 2])
@@ -1038,9 +1038,9 @@ def test_safe_division(self):
         """
         after = """
         from __future__ import division
-        from future.utils import old_div
+        from past.utils import old_div
         x = old_div(3, 2)
-        y = old_div(3. / 2)
+        y = old_div(3., 2)
         assert x == 1 and isinstance(x, int)
         assert y == 1.5 and isinstance(y, float)
         """
@@ -1055,6 +1055,8 @@ def test_safe_division_overloaded(self):
         before = """
         class Path(str):
             def __div__(self, other):
+                return self.__truediv__(other)
+            def __truediv__(self, other):
                 return Path(str(self) + '/' + str(other))
         path1 = Path('home')
         path2 = Path('user')
@@ -1064,13 +1066,15 @@ def __div__(self, other):
         """
         after = """
         from __future__ import division
-        from future.utils import old_div
+        from past.utils import old_div
         class Path(str):
+            def __div__(self, other):
+                return self.__truediv__(other)
             def __truediv__(self, other):
                 return Path(str(self) + '/' + str(other))
         path1 = Path('home')
         path2 = Path('user')
-        z = old_div(path1 / path2)
+        z = old_div(path1, path2)
         assert isinstance(z, Path)
         assert str(z) == 'home/user'
         """

future/utils/__init__.py

@@ -617,8 +617,11 @@ def exec_(code, globs=None, locs=None):
         exec("""exec code in globs, locs""")
 
 
+# Defined here too for backward compatibility:
 def old_div(a, b):
     """
+    DEPRECATED: import ``old_div`` from ``past.utils`` instead.
+
     Equivalent to ``a / b`` on Python 2 without ``from __future__ import
     division``.
 

libfuturize/fixes/__init__.py

@@ -70,7 +70,6 @@
 
 libfuturize_fix_names_stage1 = set([
     'libfuturize.fixes.fix_absolute_import',
-    'libfuturize.fixes.fix_division',
     'libfuturize.fixes.fix_next_call',  # obj.next() -> next(obj). Unlike
                                         # lib2to3.fixes.fix_next, doesn't change
                                         # the ``next`` method to ``__next__``.
@@ -82,6 +81,7 @@
 libfuturize_fix_names_stage2 = set([
     # 'libfuturize.fixes.fix_add__future__imports_except_unicode_literals',  # just in case
     'libfuturize.fixes.fix_cmp',
+    'libfuturize.fixes.fix_division_safe',
     'libfuturize.fixes.fix_execfile',
     'libfuturize.fixes.fix_future_builtins',
     'libfuturize.fixes.fix_future_standard_library',

libfuturize/fixes/fix_division_safe.py

@@ -6,13 +6,14 @@
     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
+past.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
+from lib2to3.fixer_util import (Node, Call, Name, parenthesize,
+                                syms, LParen, RParen, Comma, Number)
+from libfuturize.fixer_util import token, future_import, touch_import_top
 
 def match_division(node):
     u"""
@@ -23,18 +24,37 @@ def match_division(node):
     return node.type == slash and not node.next_sibling.type == slash and \
                                   not node.prev_sibling.type == slash
 
+
+def parenthesize_two(expr1, expr2):
+    return Node(syms.atom, [LParen(), expr1, Comma(), expr2, RParen()])
+
+
 class FixDivisionSafe(fixer_base.BaseFix):
+    # BM_compatible = True
     run_order = 4    # this seems to be ignored?
 
+    _accept_type = token.SLASH
+
+    PATTERN = """
+    term<(not('/') any)+ '/' ((not('/') any))>
+    """
+
     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)
+        if (node.type == self.syms.term and 
+                    len(node.children) == 3 and
+                    match_division(node.children[1])):
+            expr1, expr2 = node.children[0], node.children[2]
+        return expr1, expr2
 
     def transform(self, node, results):
-        import pdb
-        pdb.set_trace()
         future_import(u"division", node)
-        touch_import(u'future.utils', u'old_div', node)
+        touch_import_top(u'past.utils', u'old_div', node)
+        expr1, expr2 = results[0].clone(), results[1].clone()
+        # Strip any leading space for the first number:
+        expr1.prefix = u''
+        return Call(Name("old_div"), [expr1, Comma(), expr2], prefix=node.prefix)
+

past/utils/__init__.py

@@ -1,4 +1,5 @@
 import sys
+import numbers
 
 PY3 = sys.version_info[0] == 3
 PY2 = sys.version_info[0] == 2
@@ -64,6 +65,18 @@ def native(obj):
         return obj
 
 
+def old_div(a, b):
+    """
+    Equivalent to ``a / b`` on Python 2 without ``from __future__ import
+    division``.
+
+    TODO: generalize this to other objects (like arrays etc.)
+    """
+    if isinstance(a, numbers.Integral) and isinstance(b, numbers.Integral):
+        return a // b
+    else:
+        return a / b
+
 
-__all__ = ['PY3', 'PY2', 'PYPY', 'with_metaclass', 'native']
+__all__ = ['PY3', 'PY2', 'PYPY', 'with_metaclass', 'native', 'old_div']