Remodel will for better logic

Author: pwwang

tests/test_varname.py

@@ -410,14 +410,34 @@ def do(self):
     result = c.iwill.do()
     assert result == 'I will do something'
 
+def test_will_malformat():
+    """Function will has to be used in the format of `inst.attr` or
+    `inst.attr()`"""
+    class C1:
+        def __getitem__(self, name):
+            return will(raise_exc=True)
+
+    class C2:
+        def __getitem__(self, name):
+            return will(raise_exc=False)
+
+    c1 = C1()
+    with pytest.raises(VarnameRetrievingError):
+        c1[1]
+
+    c2_will = C2()[1]
+    assert c2_will is None
+
 def test_will_fail():
 
-    def get_will():
-        return {'a': will(raise_exc=True)}
+    def get_will(raise_exc):
+        return will(raise_exc=raise_exc)
 
     with pytest.raises(VarnameRetrievingError):
-        get_will()['a']
+        get_will(True)
 
+    the_will = get_will(False)
+    assert the_will is None
 
 def test_frame_fail(no_getframe):
     """Test when failed to retrieve the frame"""

varname.py

@@ -160,24 +160,28 @@ def i_will():
             raise VarnameRetrievingError("Unable to retrieve the frame.")
         return None
 
-    ret = None
-    try:
-        # have to be used in a call
-        assert isinstance(node, (ast.Attribute, ast.Call)), (
-            "Invalid use of function `will`"
-        )
-        node = node.parent
-    except (AssertionError, AttributeError):
-        pass
-    else:
-        if isinstance(node, ast.Attribute):
-            ret = node.attr
+    # have to be called like: inst.attr or inst.attr()
+    # see test_will_malformat
+    if not isinstance(node, (ast.Attribute, ast.Call)):
+        if raise_exc:
+            raise VarnameRetrievingError("Invalid use of function `will`")
+        return None
 
-        if not ret and raise_exc:
-            raise VarnameRetrievingError('Unable to retrieve the '
-                                         'next attribute name')
+    if isinstance(node, ast.Call):
+        # try to get not inst.attr from inst.attr()
+        # seemingly ast.Call always has parent, at least, ast.Expr
+        node = node.parent
 
-    return ret
+    # see test_will_fail
+    if not isinstance(node, ast.Attribute):
+        if raise_exc:
+            raise VarnameRetrievingError(
+                "Function `will` has to be called within "
+                "a method/property of a class."
+            ) from None
+        return None
+    # ast.Attribute
+    return node.attr
 
 def inject(obj):
     """Inject attribute `__varname__` to an object