1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
|
# Copyright (c) 2000-2008 LOGILAB S.A. (Paris, FRANCE).
# http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
import sys
from logilab.common.configuration import OptionsProviderMixIn
from logilab import astng
from logilab.astng.utils import LocalsVisitor
from pyreverse.extensions.xmlconf import DictSaxHandlerMixIn, PrefReader
from pyreverse.extensions.diagrams import PackageDiagram, ClassDiagram
# diadefs xml files utilities #################################################
class DiaDefsSaxHandler(DictSaxHandlerMixIn):
"""
definition of the structure of the diadef file, which will enable the MI
to fill the DiaDefs dictionary
"""
_MASTER = {}
_S_LIST = ('class-diagram', 'package-diagram', 'state-diagram',
'class', 'package')
_LIST = ()
_KEY = ('owner', 'name', 'include')
_CB = {}
def read_diadefs_file(filename):
"""read a diadef file and return the DiaDef dictionnary"""
diadefs = {}
reader = PrefReader(DiaDefsSaxHandler, diadefs)
try:
reader.fromFile(filename)
except:
import traceback
traceback.print_exc()
print >> sys.stderr, 'error while reading file %s' % filename
return diadefs
class DiadefsResolverHelper:
"""fetch objects in the project according to the diagram definition
from a XML file
"""
def __init__(self, project, linker):
self._p = project
self.linker = linker
def resolve_packages(self, diadef, diagram=None):
"""take a package diagram definition dictionnary and return matching
objects
"""
if diagram is None:
diagram = PackageDiagram(diadef.get('name',
'No name packages diagram'))
for package in diadef['package']:
name = package['name']
module = self.get_module(name)
if module is None:
continue
self.linker.visit(module)
diagram.add_object(name, module)
if package.get('include', 'no') != 'no':
for node, title in self.get_classes(module):
self.linker.visit(node)
diagram.add_object(title, node)
self.resolve_classes(diadef, diagram)
return diagram
def resolve_classes(self, diadef, diagram=None):
"""take a class diagram definition dictionnary and return a Diagram
instance (given in paramaters or created)
"""
class_defs = diadef.get('class', [])
if diagram is None:
diagram = ClassDiagram(diadef.get('name', 'No name classes diagram'))
for klass in class_defs:
name, module = klass['name'], klass.get('owner', '')
c = self.get_class(module, name)
if c is None:
continue
self.linker.visit(c)
diagram.add_object(name, c)
return diagram
def get_classes(self, module):
"""return all class defined in the given astng module
"""
classes = []
for object in module.values():
if isinstance(object, astng.Class):
classes.append((object, object.name))
return classes
def get_module(self, name):
"""return the astng module corresponding to name if it exists in the
current project
"""
try:
return self._p.get_module(name)
except KeyError:
print >> sys.stderr, 'Warning: no module named %s' % name
def get_class(self, module, name):
"""return the astng class corresponding to module.name if it exists in
the current project
"""
try:
module = self._p.get_module(module)
except KeyError:
print >> sys.stderr, 'Warning: no module named %s' % module
else:
try:
return module[name]
except KeyError:
print >> sys.stderr, 'Warning: no module class %s in %s' % (
name, module)
# diagram generators ##########################################################
class DefaultDiadefGenerator(LocalsVisitor):
"""generate minimum diagram definition for the project :
* a package diagram including project's modules
* a class diagram including project's classes
"""
def __init__(self, linker):
LocalsVisitor.__init__(self)
self.linker = linker
def visit_project(self, node):
"""visit an astng.Project node
create a diagram definition for packages
"""
if len(node.modules) > 1:
self.pkgdiagram = PackageDiagram('packages %s' % node.name)
else:
self.pkgdiagram = None
self.classdiagram = ClassDiagram('classes %s' % node.name)
def leave_project(self, node):
"""leave the astng.Project node
return the generated diagram definition
"""
if self.pkgdiagram:
return self.pkgdiagram, self.classdiagram
return self.classdiagram,
def visit_module(self, node):
"""visit an astng.Module node
add this class to the package diagram definition
"""
# cleanup locals inserted by the astng builder to mimick python
# interpretor behaviour
try:
del node.locals['__name__']
del node.locals['__file__']
del node.locals['__dict__']
del node.locals['__doc__']
except KeyError:
pass
if self.pkgdiagram:
self.linker.visit(node)
self.pkgdiagram.add_object(node=node, title=node.name)
def visit_class(self, node):
"""visit an astng.Class node
add this class to the class diagram definition
"""
# XXX display of __builtin__.object in the diagram should be configurable
if node.name in ('object', 'type') and node.root().name == '__builtin__':
return
# cleanup locals inserted by the astng builder to mimick python
# interpretor behaviour
try:
del node.locals['__name__']
del node.locals['__dict__']
del node.locals['__doc__']
except KeyError:
pass
self.linker.visit(node)
self.classdiagram.add_object(node=node, title=node.name)
class ClassDiadefGenerator:
"""generate a class diagram definition including all classes related to a
given class
"""
def class_diagram(self, project, klass, linker,
include_level=-1, include_module_name=1):
"""return a class diagram definition for the given klass and its related
klasses. Search deep depends on the include_level parameter (=1 will
take all classes directly related, while =2 will also take all classes
related to the one fecthed by=1)
"""
diagram = ClassDiagram(klass)
if len(project.modules) > 1:
last_dot = klass.rfind('.')
module = project.get_module(klass[:last_dot])
klass = klass[last_dot+1:]
else:
module = project.modules[0]
klass = klass.split('.')[-1]
klass = module.ilookup(klass).next()
self.extract_classes(diagram, klass, linker,
include_level, include_module_name)
return diagram
def extract_classes(self, diagram, klass_node, linker,
include_level, include_module_name):
"""extract classes related to klass_node until include_level is not 0
"""
if include_level == 0 or diagram.has_node(klass_node):
return
self.add_class_def(diagram, klass_node, linker, include_module_name)
# add all ancestors whatever the include_level ?
for ancestor in klass_node.ancestors():
# XXX display of __builtin__.object in the diagram should be configurable
if ancestor.name == 'object' and ancestor.root().name == '__builtin__':
continue
self.extract_classes(diagram, ancestor, linker,
include_level, include_module_name)
include_level -= 1
# association
for name, ass_nodes in klass_node.instance_attrs_type.items():
for ass_node in ass_nodes:
# XXX could find here class attributes and their type
if isinstance(ass_node, astng.Instance):
ass_node = ass_node._proxied
if not isinstance(ass_node, astng.Class) \
or ass_node.root().name == '__builtin__':
continue
self.extract_classes(diagram, ass_node, linker,
include_level, include_module_name)
def add_class_def(self, diagram, klass_node, linker, include_module_name):
"""add a class definition to the class diagram
"""
if include_module_name:
module_name = klass_node.root().name
title = '%s.%s' % (module_name, klass_node.name)
else:
title = klass_node.name
linker.visit(klass_node)
diagram.add_object(node=klass_node, title=title)
# diagram handler #############################################################
class DiadefsHandler(OptionsProviderMixIn):
"""handle diagram definitions :
get it from user (i.e. xml files) or generate them
"""
name = 'Diagram definition'
options = (
("diadefs",
{'action':"store", 'type':'string', 'metavar': "<file>",
'short' : 'd',
'dest':"diadefs_file", 'default':None,
'help':"create diagram according to the diagrams definitions in \
<file>"}),
("class",
{'action':"append", 'type':'string', 'metavar': "<class>",
'dest':"classes", 'default':(),
'help':"create a class diagram with all classes related to <class> "}),
)
def get_diadefs(self, project, linker):
"""get the diagrams configuration data, either from a specified file or
generated
"""
# read and interpret diagram definitions
diagrams = []
if self.config.diadefs_file is not None:
diadefs = read_diadefs_file(self.config.diadefs_file)
resolver = DiadefsResolverHelper(project, linker)
for class_diagram in diadefs.get('class-diagram', ()):
resolver.resolve_classes(class_diagram)
for package_diagram in diadefs.get('package-diagram', ()):
resolver.resolve_packages(package_diagram)
generator = ClassDiadefGenerator()
for klass in self.config.classes:
diagrams.append(generator.class_diagram(project, klass, linker))
# FIXME: generate only if no option provided
# or generate one
if not diagrams:
diagrams += DefaultDiadefGenerator(linker).visit(project)
for diagram in diagrams:
diagram.extract_relationships()
return diagrams
|