cleaning up

ring/callable.py

@@ -56,17 +56,15 @@ def is_barefunction(self):
             method_name = cc.__qualname__.split('<locals>.')[-1]
             if method_name == cc.__name__:
                 return True
-            if method_name.endswith('<locals>.' + cc.__name__):
-                return True
             return False
         else:
             if self.is_descriptor:
                 return False
             # im_class does not exist at this point
-            return not (self.is_method or self.is_classmethod)
+            return not (self.is_membermethod or self.is_classmethod)
 
     @cached_property
-    def is_method(self):
+    def is_membermethod(self):
         """Test given argument is a method or not.
 
         :param ring.callable.Callable c: A callable object.
@@ -81,7 +79,8 @@ def is_method(self):
             if not self.is_descriptor:
                 return True
 
-        return self.first_parameter and self.first_parameter.name == 'self'
+        return self.first_parameter is not None \
+            and self.first_parameter.name == 'self'
 
     @cached_property
     def is_classmethod(self):
@@ -98,7 +97,8 @@ def is_classmethod(self):
             if not self.is_descriptor:
                 return False
 
-        return self.first_parameter and self.first_parameter.name == 'cls'
+        return self.first_parameter is not None \
+            and self.first_parameter.name == 'cls'
 
     def kwargify(self, args, kwargs, bound_args=()):
         """Create a merged kwargs-like object with given args and kwargs."""

ring/func_base.py

@@ -32,7 +32,7 @@ def suggest_key_prefix(c, key_prefix):
         if six.PY2:
             cc = c.wrapped_callable
             # A proper solution is `im_class` of the bound method
-            if c.is_method:
+            if c.is_membermethod:
                 key_prefix = \
                     '{0.__module__}.{{self.__class__.__name__}}.{0.__name__}' \
                     .format(cc)

tests/_test_callable_py3.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import Any, Optional
 from ring.callable import Callable
 
@@ -31,3 +32,11 @@ def f(a: int, b: str, *c, d: Any=10, **e) -> Optional[float]:
 
     c = Callable(f)
     assert c.annotations == {'a': int, 'b': str, 'd': Any, 'return': Optional[float]}
+
+
+def test_code():
+    def f(a): pass  # noqa
+    assert Callable(f).code.co_name == 'f'
+
+    h = asyncio.coroutine(f)
+    assert Callable(h).code.co_name == 'f'

tests/test_callable.py

@@ -42,3 +42,42 @@ def test_kwargify_exc(f, args, kwargs, exc):
 def test_empty_annotations():
     c = Callable(lambda a, *b, **c: None)
     assert c.annotations == {}
+
+
+def test_callable_attributes():
+
+    def f():
+        pass
+    w = Callable(f)
+    assert w.is_barefunction is True
+    assert w.is_descriptor is False
+    assert w.is_membermethod is False
+    assert w.is_classmethod is False
+
+    class A():
+
+        def m(self):
+            pass
+        w = Callable(m)
+        assert w.is_barefunction is False
+        assert w.is_descriptor is False
+        assert w.is_membermethod is True
+        assert w.is_classmethod is False
+
+        @classmethod
+        def c(cls):
+            pass
+        w = Callable(c)
+        assert w.is_barefunction is False
+        assert w.is_descriptor is True
+        assert w.is_membermethod is False
+        assert w.is_classmethod is True
+
+        @staticmethod
+        def s():
+            pass
+        w = Callable(s)
+        assert w.is_barefunction is False
+        assert w.is_descriptor is True
+        assert w.is_membermethod is False
+        assert w.is_classmethod is False