- add basic support for recognizing hook impls by prefix

- add list_plugin_distinfo and list_name_plugin helpers to
  get at pluginmanager information without using underscores.

Author: hpk42

pluggy.py

@@ -157,6 +157,13 @@ def setattr_hookimpl_opts(func):
             return setattr_hookimpl_opts(function)
 
 
+def normalize_hookimpl_opts(opts):
+    opts.setdefault("tryfirst", False)
+    opts.setdefault("trylast", False)
+    opts.setdefault("hookwrapper", False)
+    opts.setdefault("optionalhook", False)
+
+
 class _TagTracer:
     def __init__(self):
         self._tag2proc = {}
@@ -310,13 +317,16 @@ class PluginManager(object):
     which will subsequently send debug information to the trace helper.
     """
 
-    def __init__(self, project_name):
+    def __init__(self, project_name, implprefix=None):
+        """ if implprefix is given implementation functions
+        will be recognized if their name matches the implprefix. """
         self.project_name = project_name
         self._name2plugin = {}
         self._plugin2hookcallers = {}
         self._plugin_distinfo = []
         self.trace = _TagTracer().get("pluginmanage")
         self.hook = _HookRelay(self.trace.root.get("hook"))
+        self._implprefix = implprefix
         self._inner_hookexec = lambda hook, methods, kwargs: \
             _MultiCall(methods, kwargs, hook.spec_opts).execute()
 
@@ -380,6 +390,7 @@ def register(self, plugin, name=None):
         for name in dir(plugin):
             hookimpl_opts = self.parse_hookimpl_opts(plugin, name)
             if hookimpl_opts is not None:
+                normalize_hookimpl_opts(hookimpl_opts)
                 method = getattr(plugin, name)
                 hookimpl = _HookImpl(plugin, plugin_name, method, hookimpl_opts)
                 hook = getattr(self.hook, name, None)
@@ -399,6 +410,8 @@ def parse_hookimpl_opts(self, plugin, name):
         if res is not None and not isinstance(res, dict):
             # false positive
             res = None
+        elif res is None and self._implprefix and name.startswith(self._implprefix):
+           res = {}
         return res
 
     def parse_hookspec_opts(self, module_or_class, name):
@@ -524,9 +537,18 @@ def load_setuptools_entrypoints(self, entrypoint_name):
             except DistributionNotFound:
                 continue
             self.register(plugin, name=ep.name)
-            self._plugin_distinfo.append((ep.dist, plugin))
+            self._plugin_distinfo.append((plugin, ep.dist))
         return len(self._plugin_distinfo)
 
+    def list_plugin_distinfo(self):
+        """ return list of distinfo/plugin tuples for all setuptools registered
+        plugins. """
+        return list(self._plugin_distinfo)
+
+    def list_name_plugin(self):
+        """ return list of name/plugin pairs. """
+        return list(self._name2plugin.items())
+
 
 class _MultiCall:
     """ execute a call into multiple python functions/methods. """

test_pluggy.py

@@ -52,6 +52,10 @@ class A:
         assert pm.unregister(a1) == a1
         assert not pm.is_registered(a1)
 
+        l = pm.list_name_plugin()
+        assert len(l) == 1
+        assert l == [("hello", a2)]
+
     def test_register_dynamic_attr(self, he_pm):
         class A:
             def __getattr__(self, name):
@@ -484,7 +488,7 @@ class PseudoPlugin:
         assert num == 1
         plugin = pm.get_plugin("myname")
         assert plugin.x == 42
-        assert pm._plugin_distinfo == [(None, plugin)]
+        assert pm.list_plugin_distinfo() == [(plugin, None)]
 
     def test_load_setuptools_not_installed(self, monkeypatch, pm):
         monkeypatch.setitem(sys.modules, 'pkg_resources',
@@ -529,6 +533,61 @@ def he_method1(self):
         finally:
             undo()
 
+    def test_prefix_hookimpl(self):
+        pm = PluginManager(hookspec.project_name, "hello_")
+        class HookSpec:
+            @hookspec
+            def hello_myhook(self, arg1):
+                """ add to arg1 """
+
+        pm.add_hookspecs(HookSpec)
+
+        class Plugin:
+            def hello_myhook(self, arg1):
+                return arg1 + 1
+
+        pm.register(Plugin())
+        pm.register(Plugin())
+        results = pm.hook.hello_myhook(arg1=17)
+        assert results == [18, 18]
+
+def test_parse_hookimpl_override():
+    class MyPluginManager(PluginManager):
+        def parse_hookimpl_opts(self, module_or_class, name):
+            opts = PluginManager.parse_hookimpl_opts(self, module_or_class, name)
+            if opts is None:
+                if name.startswith("x1"):
+                    opts = {}
+            return opts
+
+    class Plugin:
+        def x1meth(self):
+            pass
+
+        @hookimpl(hookwrapper=True, tryfirst=True)
+        def x1meth2(self):
+            pass
+
+    class Spec:
+        @hookspec
+        def x1meth(self):
+            pass
+        @hookspec
+        def x1meth2(self):
+            pass
+
+
+    pm = MyPluginManager(hookspec.project_name)
+    pm.register(Plugin())
+    pm.add_hookspecs(Spec)
+    assert not pm.hook.x1meth._nonwrappers[0].hookwrapper
+    assert not pm.hook.x1meth._nonwrappers[0].tryfirst
+    assert not pm.hook.x1meth._nonwrappers[0].trylast
+    assert not pm.hook.x1meth._nonwrappers[0].optionalhook
+
+    assert pm.hook.x1meth2._wrappers[0].tryfirst
+    assert pm.hook.x1meth2._wrappers[0].hookwrapper
+
 
 def test_varnames():
     def f(x):