Merge lp:~richardw/pydoctor/moduleprovides-1132527 into lp:~mwhudson/pydoctor/dev

[Richard Wall]

Hi Michael,

I copied the existing code for handling implements and @implementer and adapted it to handle moduleProvides.

Added a new test case which I think demonstrates the new feature.

Tested on the twisted.names.client.lookup functions in the following Twisted branch:
 * https://twistedmatrix.com/trac/log/branches/moduleprovides-iresolver-6328

Seems to work and even handles documentation from Interface subclasses since your recent change.

Let me know what you think.

-RichardW.

[Michael Hudson-Doyle (mwhudson)]

Looks good to me, thanks! addInterfaceInfoToModule and addInterfaceInfoToClass seem a bit similar, but I'd forgotten how gross the data model there was so that can probably be fixed as some part of a general clean up. I'll merge now.

review: Approve

=== modified file 'pydoctor/test/test_zopeinterface.py'
--- pydoctor/test/test_zopeinterface.py	2013-02-24 22:40:48 +0000
+++ pydoctor/test/test_zopeinterface.py	2013-02-27 22:40:26 +0000
@@ -64,7 +64,6 @@
     '''
     implements_test(src)
 
-
 def implements_test(src):
     mod = fromText(src, 'zi', systemcls=ZopeInterfaceSystem)
     ifoo = mod.contents['IFoo']
@@ -222,3 +221,20 @@
     method = mod.contents['Implementation'].contents['method']
     assert imethod in method.docsources(), list(method.docsources())
 
+def test_docsources_from_moduleprovides():
+    src = '''
+    from zope import interface
+
+    class IBase(interface.Interface):
+        def bar():
+            """documentation"""
+
+    interface.moduleProvides(IBase)
+
+    def bar():
+        pass
+    '''
+    mod = fromText(src, systemcls=ZopeInterfaceSystem)
+    imethod = mod.contents['IBase'].contents['bar']
+    function = mod.contents['bar']
+    assert imethod in function.docsources(), list(function.docsources())
 
=== modified file 'pydoctor/zopeinterface.py'
--- pydoctor/zopeinterface.py	2013-02-24 22:40:48 +0000
+++ pydoctor/zopeinterface.py	2013-02-27 22:40:26 +0000
@@ -4,6 +4,19 @@
 from compiler import ast
 import re
 
+
+class ZopeInterfaceModule(model.Module):
+    def setup(self):
+        super(ZopeInterfaceModule, self).setup()
+        self.implements_directly = [] # [name of interface]
+
+    @property
+    def allImplementedInterfaces(self):
+        """Return all the interfaces provided by this module
+        """
+        return list(self.implements_directly)
+
+
 class ZopeInterfaceClass(model.Class):
     isinterface = False
     isschemafield = False
@@ -50,7 +63,7 @@
     def docsources(self):
         for source in super(ZopeInterfaceFunction, self).docsources():
             yield source
-        if not isinstance(self.parent, model.Class):
+        if not isinstance(self.parent, (model.Class, model.Module)):
             return
         for interface in self.parent.allImplementedInterfaces:
             io = self.system.objForFullName(interface)
@@ -59,6 +72,24 @@
                     if self.name in io2.contents:
                         yield io2.contents[self.name]
 
+def addInterfaceInfoToModule(module, interfaceargs):
+    for arg in interfaceargs:
+        if not isinstance(arg, tuple):
+            fullName = module.expandName(ast_pp.pp(arg))
+        else:
+            fullName = arg[1]
+        module.implements_directly.append(fullName)
+        obj = module.system.objForFullName(fullName)
+        if obj is not None:
+            if not obj.isinterface:
+                obj.system.msg(
+                    'zopeinterface',
+                    'probable interface %r not marked as such'%obj,
+                    thresh=1)
+                obj.isinterface = True
+                obj.kind = "Interface"
+                obj.implementedby_directly = []
+            obj.implementedby_directly.append(module.fullName())
 
 def addInterfaceInfoToClass(cls, interfaceargs, implementsOnly):
     cls.implementsOnly = implementsOnly
@@ -193,6 +224,13 @@
         if meth is not None:
             meth(base, node)
 
+    def visitCallFunc_zope_interface_moduleProvides(self, funcName, node):
+        if not isinstance(self.builder.current, model.Module):
+            self.default(node)
+            return
+
+        addInterfaceInfoToModule(self.builder.current, node.args)
+
     def visitCallFunc_zope_interface_implements(self, funcName, node):
         if not isinstance(self.builder.current, model.Class):
             self.default(node)
@@ -237,7 +275,7 @@
 
 
 class ZopeInterfaceSystem(model.System):
+    Module = ZopeInterfaceModule
     Class = ZopeInterfaceClass
     Function = ZopeInterfaceFunction
     defaultBuilder = ZopeInterfaceASTBuilder
-