Add full support for instance methods

Author: pganssle

src/variants/_variants.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Provides the variant form decorator."""
 
-import types
+import functools
 
 __all__ = ['variants']
 
@@ -30,26 +30,60 @@ def myfunc(url):
     class VariantFunction:
         __doc__ = f.__doc__
 
+        def __init__(self):
+            self._variants = set()
+
         def __call__(self, *args, **kwargs):
             return f(*args, **kwargs)
 
+        def _add_variant(self, var_name, vfunc):
+            self._variants.add(var_name)
+            setattr(self, var_name, vfunc)
+
         def variant(self, func_name):
             """Decorator to add a new variant form to the function."""
             def decorator(vfunc):
-                setattr(self.__class__, func_name, staticmethod(vfunc))
+                self._add_variant(func_name, vfunc)
+
                 return self
 
             return decorator
 
         def __get__(self, instance, owner):
             # This is necessary to bind instance methods
-            if instance is None:
-                return self
+            if instance is not None:
+                return VariantMethod(self, instance)
 
-            return types.MethodType(self, instance)
+            return self
 
         def __repr__(self):
-            return '<VariantFunction {}>'.format(self.__name__)
+            return '<{} {}>'.format(self.__class__.__name__, self.__name__)
+
+    class VariantMethod(VariantFunction):
+        def __init__(self, variant_func, instance):
+            self.__instance = instance
+            self.__name__ = variant_func.__name__
+
+            # Convert existing variants to methods
+            for vname in variant_func._variants:
+                vfunc = getattr(variant_func, vname)
+                vmethod = self._as_bound_method(vfunc)
+
+                setattr(self, vname, vmethod)
+
+        def __call__(self, *args, **kwargs):
+            return f(self.__instance, *args, **kwargs)
+
+        def _as_bound_method(self, vfunc):
+            @functools.wraps(vfunc)
+            def bound_method(*args, **kwargs):
+                return vfunc(self.__instance, *args, **kwargs)
+
+            return bound_method
+
+        def _add_variant(self, var_name, vfunc):
+            self._variants.add(var_name)
+            setattr(self, var_name, self._as_bound_method(vfunc))
 
     f_out = VariantFunction()
     f_out.__name__ = f.__name__

tests/test_instance_methods.py

@@ -48,41 +48,30 @@ def test_divide(x, y, expected):
     assert dv.divide(y) == expected
 
 
-
-@pytest.mark.xfail
 @pytest.mark.parametrize('x,y,expected', DivisionData.ROUND_VALS)
 def test_round(x, y, expected):
     dv = DivisionVariants(x)
     assert dv.divide.round(y) == expected
 
 
-
-
-@pytest.mark.xfail
 @pytest.mark.parametrize('x,y,expected', DivisionData.FLOOR_VALS)
 def test_floor(x, y, expected):
     dv = DivisionVariants(x)
     assert dv.divide.floor(y) == expected
 
 
-
-
-@pytest.mark.xfail
 @pytest.mark.parametrize('x,y,expected', DivisionData.CEIL_VALS)
-def test_floor(x, y, expected):
+def test_ceil(x, y, expected):
     dv = DivisionVariants(x)
-    assert dv.divide.floor(y) == expected
-
+    assert dv.divide.ceil(y) == expected
 
 
-@pytest.mark.xfail
 @pytest.mark.parametrize('x,y,expected,mode', DivisionData.MODE_VALS)
 def test_mode(x, y, expected, mode):
     dv = DivisionVariants(x)
     assert dv.divide.mode(y, mode) == expected
 
 
-@pytest.mark.xfail
 @pytest.mark.parametrize('x,y,expected,mode', DivisionData.MODE_VALS)
 def test_mode_change_x(x, y, expected, mode):
     # Test that with mutable values it still works after x is changed