- bring pluggy to 0.3

- offering a add_hookcall_monitoring interface for adding before/after
  functions.
- a tox.ini that makes pluggy run against pytest27 and pytest trunk

Author: hpk42

MANIFEST.in

@@ -0,0 +1,6 @@
+include CHANGELOG
+include README.rst
+include setup.py
+include tox.ini
+include LICENSE
+include test_pluggy.py

pluggy.py

@@ -67,7 +67,7 @@
 import sys
 import inspect
 
-__version__ = '0.2.0'
+__version__ = '0.3.0'
 __all__ = ["PluginManager", "PluginValidationError",
            "HookspecMarker", "HookimplMarker"]
 
@@ -294,10 +294,10 @@ def __init__(self, pluginmanager, before, after):
         assert not isinstance(self.oldcall, _TracedHookExecution)
         self.pluginmanager._inner_hookexec = self
 
-    def __call__(self, hook, methods, kwargs):
-        self.before(hook, methods, kwargs)
-        outcome = _CallOutcome(lambda: self.oldcall(hook, methods, kwargs))
-        self.after(outcome, hook, methods, kwargs)
+    def __call__(self, hook, hook_impls, kwargs):
+        self.before(hook.name, hook_impls, kwargs)
+        outcome = _CallOutcome(lambda: self.oldcall(hook, hook_impls, kwargs))
+        self.after(outcome, hook.name, hook_impls, kwargs)
         return outcome.get_result()
 
     def undo(self):
@@ -337,20 +337,35 @@ def _hookexec(self, hook, methods, kwargs):
         # enable_tracing will set its own wrapping function at self._inner_hookexec
         return self._inner_hookexec(hook, methods, kwargs)
 
+    def add_hookcall_monitoring(self, before, after):
+        """ add before/after tracing functions for all hooks
+        and return an undo function which, when called,
+        will remove the added tracers.
+
+        ``before(hook_name, hook_impls, kwargs)`` will be called ahead
+        of all hook calls and receive a hookcaller instance, a list
+        of HookImpl instances and the keyword arguments for the hook call.
+
+        ``after(outcome, hook_name, hook_impls, kwargs)`` receives the
+        same arguments as ``before`` but also a :py:class:`_CallOutcome`` object
+        which represents the result of the overall hook call.
+        """
+        return _TracedHookExecution(self, before, after).undo
+
     def enable_tracing(self):
         """ enable tracing of hook calls and return an undo function. """
         hooktrace = self.hook._trace
 
-        def before(hook, methods, kwargs):
+        def before(hook_name, methods, kwargs):
             hooktrace.root.indent += 1
-            hooktrace(hook.name, kwargs)
+            hooktrace(hook_name, kwargs)
 
-        def after(outcome, hook, methods, kwargs):
+        def after(outcome, hook_name, methods, kwargs):
             if outcome.excinfo is None:
-                hooktrace("finish", hook.name, "-->", outcome.result)
+                hooktrace("finish", hook_name, "-->", outcome.result)
             hooktrace.root.indent -= 1
 
-        return _TracedHookExecution(self, before, after).undo
+        return self.add_hookcall_monitoring(before, after)
 
     def subset_hook_caller(self, name, remove_plugins):
         """ Return a new _HookCaller instance for the named method
@@ -394,7 +409,7 @@ def register(self, plugin, name=None):
             if hookimpl_opts is not None:
                 normalize_hookimpl_opts(hookimpl_opts)
                 method = getattr(plugin, name)
-                hookimpl = _HookImpl(plugin, plugin_name, method, hookimpl_opts)
+                hookimpl = HookImpl(plugin, plugin_name, method, hookimpl_opts)
                 hook = getattr(self.hook, name, None)
                 if hook is None:
                     hook = _HookCaller(name, self._hookexec)
@@ -561,8 +576,8 @@ class _MultiCall:
     # so we can remove it soon, allowing to avoid the below recursion
     # in execute() and simplify/speed up the execute loop.
 
-    def __init__(self, methods, kwargs, specopts={}):
-        self.methods = methods
+    def __init__(self, hook_impls, kwargs, specopts={}):
+        self.hook_impls = hook_impls
         self.kwargs = kwargs
         self.kwargs["__multicall__"] = self
         self.specopts = specopts
@@ -572,12 +587,12 @@ def execute(self):
         self.results = results = []
         firstresult = self.specopts.get("firstresult")
 
-        while self.methods:
-            method = self.methods.pop()
-            args = [all_kwargs[argname] for argname in method.argnames]
-            if method.hookwrapper:
-                return _wrapped_call(method.function(*args), self.execute)
-            res = method.function(*args)
+        while self.hook_impls:
+            hook_impl = self.hook_impls.pop()
+            args = [all_kwargs[argname] for argname in hook_impl.argnames]
+            if hook_impl.hookwrapper:
+                return _wrapped_call(hook_impl.function(*args), self.execute)
+            res = hook_impl.function(*args)
             if res is not None:
                 if firstresult:
                     return res
@@ -587,7 +602,7 @@ def execute(self):
             return results
 
     def __repr__(self):
-        status = "%d meths" % (len(self.methods),)
+        status = "%d meths" % (len(self.hook_impls),)
         if hasattr(self, "results"):
             status = ("%d results, " % len(self.results)) + status
         return "<_MultiCall %s, kwargs=%r>" % (status, self.kwargs)
@@ -718,7 +733,7 @@ def call_extra(self, methods, kwargs):
         old = list(self._nonwrappers), list(self._wrappers)
         for method in methods:
             opts = dict(hookwrapper=False, trylast=False, tryfirst=False)
-            hookimpl = _HookImpl(None, "<temp>", method, opts)
+            hookimpl = HookImpl(None, "<temp>", method, opts)
             self._add_hookimpl(hookimpl)
         try:
             return self(**kwargs)
@@ -733,7 +748,7 @@ def _maybe_apply_history(self, method):
                     proc(res[0])
 
 
-class _HookImpl:
+class HookImpl:
     def __init__(self, plugin, plugin_name, function, hook_impl_opts):
         self.function = function
         self.argnames = varnames(self.function)

test_pluggy.py

@@ -6,7 +6,7 @@
 from pluggy import (PluginManager, varnames, PluginValidationError,
                     HookimplMarker, HookspecMarker)
 
-from pluggy import (_MultiCall, _TagTracer, _HookImpl)
+from pluggy import (_MultiCall, _TagTracer, HookImpl)
 
 hookspec = HookspecMarker("example")
 hookimpl = HookimplMarker("example")
@@ -305,7 +305,7 @@ def addmeth(tryfirst=False, trylast=False, hookwrapper=False):
             def wrap(func):
                 hookimpl(tryfirst=tryfirst, trylast=trylast,
                          hookwrapper=hookwrapper)(func)
-                hc._add_hookimpl(_HookImpl(None, "<temp>", func, func.example_impl))
+                hc._add_hookimpl(HookImpl(None, "<temp>", func, func.example_impl))
                 return func
             return wrap
         return addmeth
@@ -497,6 +497,44 @@ def test_load_setuptools_not_installed(self, monkeypatch, pm):
         with pytest.raises(ImportError):
             pm.load_setuptools_entrypoints("qwe")
 
+    def test_add_tracefuncs(self, he_pm):
+        l = []
+
+        class api1:
+            @hookimpl
+            def he_method1(self):
+                l.append("he_method1-api1")
+
+        class api2:
+            @hookimpl
+            def he_method1(self):
+                l.append("he_method1-api2")
+
+        he_pm.register(api1())
+        he_pm.register(api2())
+
+        def before(hook_name, hook_impls, kwargs):
+            l.append((hook_name, list(hook_impls), kwargs))
+
+        def after(outcome, hook_name, hook_impls, kwargs):
+            l.append((outcome, hook_name, list(hook_impls), kwargs))
+
+        undo = he_pm.add_hookcall_monitoring(before, after)
+
+        he_pm.hook.he_method1()
+        assert len(l) == 4
+        assert l[0][0] == "he_method1"
+        assert len(l[0][1]) == 2
+        assert isinstance(l[0][2], dict)
+        assert l[1] == "he_method1-api2"
+        assert l[2] == "he_method1-api1"
+        assert len(l[3]) == 4
+        assert l[3][1] == l[0][0]
+
+        undo()
+        he_pm.hook.he_method1()
+        assert len(l) == 4 + 2
+
     def test_hook_tracing(self, he_pm):
         saveindent = []
 
@@ -639,7 +677,7 @@ def test_uses_copy_of_methods(self):
     def MC(self, methods, kwargs, firstresult=False):
         hookfuncs = []
         for method in methods:
-            f = _HookImpl(None, "<temp>", method, method.example_impl)
+            f = HookImpl(None, "<temp>", method, method.example_impl)
             hookfuncs.append(f)
         return _MultiCall(hookfuncs, kwargs, {"firstresult": firstresult})
 
@@ -648,14 +686,14 @@ class P1:
             @hookimpl
             def m(self, __multicall__, x):
                 assert len(__multicall__.results) == 1
-                assert not __multicall__.methods
+                assert not __multicall__.hook_impls
                 return 17
 
         class P2:
             @hookimpl
             def m(self, __multicall__, x):
                 assert __multicall__.results == []
-                assert __multicall__.methods
+                assert __multicall__.hook_impls
                 return 23
 
         p1 = P1()

tox.ini

@@ -1,19 +1,20 @@
 [tox]
-envlist=pep8,flakes,py26,py27,py34,pypy
+envlist=check,{py26,py27,py34,pypy}-{pytest27,pytest}
 
 [testenv]
 commands= py.test {posargs:test_pluggy.py}
 deps=
-    pytest
+    pytest27: pytest>=2.7.0,<2.8.0
+    pytest: pytest>=2.8.0.dev1
 
-[testenv:pep8]
-deps = pytest-pep8
-commands = py.test --pep8 
-
-[testenv:flakes]
+[testenv:check]
 usedevelop=True
-deps = pytest-flakes
-commands = py.test --flakes -m flakes pluggy.py test_pluggy.py
+deps = pytest>=2.7.0,<2.8.0
+       pytest-pep8
+       pytest-flakes
+commands =
+    py.test --pep8
+    py.test --flakes -m flakes --pyargs pluggy test_pluggy
 
 [pytest]
 minversion=2.0