]> git.saurik.com Git - wxWidgets.git/blob - wxPython/docs/bin/simplify.py
added missing comma
[wxWidgets.git] / wxPython / docs / bin / simplify.py
1 #!/usr/bin/python
2 #---------------------------------------------------------------------------
3 #
4 # Like simplify.xsl but using Python so a few non-standard conversions can
5 # also be done. (Currently it is still about the same as simplify.xsl...)
6 #
7 #---------------------------------------------------------------------------
8
9 import sys
10 import os
11 import libxml2
12
13
14 DEST="docs/xml/wxPython-metadata.xml"
15 SRC="docs/xml-raw"
16
17
18 classMap = {
19 'wxString' : 'String',
20 'void' : '',
21 }
22
23
24 def getModuleNames():
25 """
26 Get the list of extension modules from setup.py
27 """
28 import setup
29 names = [e.name[1:] for e in setup.wxpExtensions]
30 return names
31
32
33
34 def getAttr(node, name):
35 """
36 Get a value by name from the <attribute> elements in the SWIG XML output
37 """
38 path = "./attributelist/attribute[@name='%s']/@value" % name
39 n = node.xpathEval2(path)
40 if len(n):
41 return n[0].content
42 else:
43 return None
44
45
46 def fixType(typeStr):
47 """
48 Fixup type string, dropping the swig pointer and other flags
49 """
50 pos = typeStr.rfind('.')
51 if pos != -1:
52 typeStr = typeStr[pos+1:]
53 return classMap.get(typeStr, typeStr)
54
55
56 def processModule(newDocNode, modulename):
57 """
58 Start processing a new XML file, create a module element and then
59 find the include elements
60 """
61 filename = os.path.join(SRC, "%s_swig.xml" % modulename)
62 print filename
63
64 doc = libxml2.parseFile(filename)
65 topNode = doc.getRootElement()
66
67 # make a module element
68 name = getAttr(topNode, "module")
69 assert name == modulename # sanity check
70
71 moduleNode = libxml2.newNode("module")
72 moduleNode.setProp("name", name)
73 newDocNode.addChild(moduleNode)
74
75 node = topNode.children
76 while node is not None:
77 if node.name == "include":
78 processInclude(moduleNode, node)
79 node = node.next
80
81 doc.freeDoc()
82
83
84
85 def processInclude(moduleNode, includeNode):
86 """
87 Almost everything we are interested in is inside an <include>,
88 which may also be nested.
89 """
90
91 # check first for imports
92 for node in includeNode.xpathEval2("import"):
93 try:
94 modNode = node.xpathEval2("module")[0]
95 name = getAttr(modNode, "name")
96 impNode = libxml2.newNode("import")
97 impNode.setProp("name", name)
98 moduleNode.addChild(impNode)
99 except IndexError:
100 pass
101
102 # then look through the child nodes for other things we need
103 node = includeNode.children
104 while node is not None:
105 if node.name == "insert":
106 processInsert(moduleNode, node)
107
108 elif node.name == "class":
109 processClass(moduleNode, node)
110
111 elif node.name == "cdecl" and getAttr(node, "view") == "globalfunctionHandler":
112 func = libxml2.newNode("method")
113 func.setProp("name", getAttr(node, "sym_name"))
114 func.setProp("oldname", getAttr(node, "name"))
115 func.setProp("type", fixType(getAttr(node, "type")))
116 doCheckOverloaded(func, node)
117 doDocStrings(func, node)
118 doParamList(func, node)
119 moduleNode.addChild(func)
120
121
122 elif node.name == "include":
123 processInclude(moduleNode, node)
124
125 node = node.next
126
127
128
129 def processInsert(parentNode, insertNode):
130 """
131 Check for pythoncode
132 """
133 if getAttr(insertNode, "section") == "python":
134 code = getAttr(insertNode, "code")
135 node = libxml2.newNode("pythoncode")
136 node.addChild(libxml2.newText(code))
137 parentNode.addChild(node)
138
139
140
141 def processClass(parentNode, classNode):
142 """
143 Handle classes, constructors, methods, etc.
144 """
145 # make class element
146 klass = libxml2.newNode("class")
147 name = getAttr(classNode, "sym_name")
148 oldname = getAttr(classNode, "name")
149 classMap[oldname] = name
150 klass.setProp("name", name)
151 klass.setProp("oldname", oldname)
152 klass.setProp("module", getAttr(classNode, "module"))
153 doDocStrings(klass, classNode)
154 parentNode.addChild(klass)
155
156 # check for baseclass(es)
157 for node in classNode.xpathEval2("attributelist/baselist/base"):
158 baseclass = libxml2.newNode("baseclass")
159 basename = node.prop("name")
160 baseclass.setProp("name", classMap.get(basename, basename))
161 klass.addChild(baseclass)
162
163 # check for constructors/destructors
164 for type in ["constructor", "destructor"]:
165 for node in classNode.xpathEval2("%s | extend/%s" % (type, type)):
166 func = libxml2.newNode(type)
167 func.setProp("name", getAttr(node, "sym_name"))
168 if parentNode.name != "destructor":
169 doCheckOverloaded(func, node)
170 doDocStrings(func, node)
171 doParamList(func, node)
172 klass.addChild(func)
173
174 # check for cdecl's. In class scope we are interested in methods,
175 # static methods, or properties
176 for node in classNode.xpathEval2("cdecl | extend/cdecl"):
177 view = getAttr(node, "view")
178 if view == "memberfunctionHandler":
179 func = libxml2.newNode("method")
180 func.setProp("name", getAttr(node, "sym_name"))
181 func.setProp("type", fixType(getAttr(node, "type")))
182 doCheckOverloaded(func, node)
183 doDocStrings(func, node)
184 doParamList(func, node)
185 klass.addChild(func)
186
187 elif view == "staticmemberfunctionHandler":
188 func = libxml2.newNode("staticmethod")
189 func.setProp("name", getAttr(node, "sym_name"))
190 func.setProp("type", fixType(getAttr(node, "type")))
191 doCheckOverloaded(func, node)
192 doDocStrings(func, node)
193 doParamList(func, node)
194 klass.addChild(func)
195
196 elif view == "variableHandler":
197 prop = libxml2.newNode("property")
198 prop.setProp("name", getAttr(node, "sym_name"))
199 prop.setProp("type", fixType(getAttr(node, "type")))
200 if getAttr(node, "feature_immutable"):
201 prop.setProp("readonly", "yes")
202 else:
203 prop.setProp("readonly", "no")
204 doDocStrings(prop, node)
205 klass.addChild(prop)
206
207
208
209 def doParamList(parentNode, srcNode):
210 """
211 Convert the parameter list
212 """
213 params = srcNode.xpathEval2("attributelist/parmlist/parm")
214 if params:
215 plist = libxml2.newNode("paramlist")
216 for p in params:
217 pnode = libxml2.newNode("param")
218 pnode.setProp("name", getAttr(p, "name"))
219 pnode.setProp("type", fixType(getAttr(p, "type")))
220 pnode.setProp("default", getAttr(p, "value"))
221 plist.addChild(pnode)
222 parentNode.addChild(plist)
223
224
225
226 def doCheckOverloaded(parentNode, srcNode):
227 """
228 Set an attribute indicating if the srcNode is tagged as being overloaded
229 """
230 if srcNode.xpathEval2("./attributelist/attribute[@name='sym_overloaded']"):
231 parentNode.setProp("overloaded", "yes")
232 else:
233 parentNode.setProp("overloaded", "no")
234
235
236
237 def doDocStrings(parentNode, srcNode):
238 """
239 Check for the various possible docstring attributes, and attach
240 coresponding child nodes if found.
241 """
242 def makeDocElement(name, content):
243 node = libxml2.newNode(name)
244 node.addChild(libxml2.newText(content))
245 return node
246
247 autodoc = getAttr(srcNode, "python_autodoc")
248 docstr = getAttr(srcNode, "feature_docstring")
249 refdoc = getAttr(srcNode, "feature_refdoc")
250 if autodoc:
251 parentNode.addChild(makeDocElement("autodoc", autodoc))
252 if docstr:
253 parentNode.addChild(makeDocElement("docstring", docstr))
254 if refdoc:
255 parentNode.addChild(makeDocElement("refdoc", refdoc))
256
257
258
259
260
261 def main():
262 if not os.path.exists(SRC):
263 print "Unable to find %s, please run this script from the root wxPython directory." % SRC
264 sys.exit(1)
265
266 newDoc = libxml2.newDoc("1.0")
267 newTopNode = libxml2.newNode("wxPython-metadata")
268 newDoc.addChild(newTopNode)
269
270 for m in getModuleNames():
271 processModule(newTopNode, m)
272
273 newDoc.saveFormatFile(DEST, True)
274 print "Wrote simplified metadata to", DEST
275
276 #---------------------------------------------------------------------------
277
278 if __name__ == "__main__":
279 main()