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 | PARENTHESES = dict((
('(', ')'),
('[', ']'),
('{', '}'),
('<', '>'),
('<<', '>>'),
('|', '|'),
(' ', ' '),
('"', '"'),
("'", "'"),
))
__all__.append('enclose')
def enclose(elt, open=None, close=None, sep=None, forced=None): # ||:fnc:||
r"""enclose string in parenthesis.
:returns: enclosed string
:param elt: element to be enclosed
:param open: opening parenthesis (default: `(`)
:param close: closing parenthesis (default: :data:`PARENTHESIS`.get(open, '')
:param sep: separator after open and before close, (default: '')
:param forced: add parentheses, even if they already exist.
>>> printf(enclose('abc'))
(abc)
>>> printf(enclose('(abc'))
(abc)
>>> printf(enclose('abc)'))
(abc)
>>> printf(enclose('(abc)'))
(abc)
>>> printf(enclose('(abc)', forced=True))
((abc))
>>> printf(enclose('abc', '<<'))
<<abc>>
>>> printf(enclose(enclose('abc', ' '), '<<'))
<< abc >>
>>> printf(enclose('abc', '-| '))
-| abc
"""
if open is None:
open = '('
if close is None:
close = PARENTHESES.get(open, '')
if sep is None:
sep = ''
enclosed = []
if forced or (open and not re.match('\\s*' + re.escape(open), elt)):
enclosed.append(open)
if open:
enclosed.append(sep)
enclosed.append(elt)
if forced or (close and not re.search(re.escape(close) + '\\s*$', elt)):
if close:
enclosed.append(sep)
enclosed.append(close)
return ''.join(enclosed)
__all__.append('join_lists_flatten')
def join_lists_flatten(lists, sep): # ||:fnc:||
r"""Insert separator between elements of a list.
:returns: list where each group of elements is separated from the next
group of element with `sep`.
:param lists: a list of element groups (lists). All elements of
group are appended as single elements to the result list.
:param sep: separater inserted betwwen two groups of elements.
"""
result = []
if lists:
result.extend(lists[0])
for _list in lists[1:]:
result.append(sep)
result.extend(_list)
return result
__all__.append('plantuml_format_class')
def plantuml_format_class(name, sections=None, circle=None, stereotype=None, alias=None, sep=None): # ||:fnc:||
r"""
:returns: class formatted for a `PlantUML`_ class diagram.
:param name: class name
:param sections: list of class sections, each section is a list of attribute/operation lines.
:param circle:
:param stereotype:
:param alias: class alias
.. _`PlantUML`: http://plantuml.com
"""
if sections is None:
sections = []
formatted = []
_class_param = []
if circle and circle.strip():
_class_param.append(enclose(circle, '('))
if stereotype and stereotype.strip():
_class_param.append(stereotype)
class_param = ' '.join(_class_param)
if class_param:
class_param = enclose(class_param, '<<', sep=' ')
if alias:
name = enclose(name, '"')
class_alias = 'as ' + alias
else:
class_alias = ''
if sep is None:
sep = ''
formatted.append(sformat('class {0} {{', ' '.join((_s for _s in (name, class_alias, class_param) if _s))))
_first = True
for _list in sections:
if _list:
if _first:
_first = False
else:
formatted.append(' ' + sep)
formatted.extend((' ' + _e for _e in _list))
formatted.append('}')
return '\n'.join(formatted)
class_name = 'global'
func_type = type(run)
func_type_builtin = type(issequence)
module_type = type(os)
globals_ = globals()
public = globals_.get('__all__', [])
if not public:
public = list(dkeys(globals_))
items = []
items.extend(((_sym, _val, '-') for _sym, _val in sorted(ditems(globals_)) if _sym not in public))
items.extend(((_sym, globals_[_sym], '+') for _sym in public))
opt_all_syms = None
import pyjsmo
classes = []
variables = pyjsmo.OrderedDict((
('-', []),
('+', []),
))
functions = pyjsmo.OrderedDict((
('-', []),
('+', []),
))
for _sym, _val, _visibility in items:
if not opt_all_syms:
if _sym.startswith('_'):
continue
if _sym.startswith('__') and _sym.endswith('__'):
continue
if isinstance(_val, module_type):
continue
if isinstance(_val, type):
classes.append((_sym, _val, _visibility))
continue
if isinstance(_val, (func_type, func_type_builtin)):
_list = functions[_visibility]
_sfx = '()'
else:
_list = variables[_visibility]
_sfx = ''
_list.append(sformat('{0}{1}{2}', _visibility, _sym, _sfx))
variables = join_lists_flatten([_v for _v in dvalues(variables) if _v], '..')
functions = join_lists_flatten([_v for _v in dvalues(functions) if _v], '..')
printf(plantuml_format_class(class_name, (variables, functions), circle='G, #FFCCCC', sep='--', alias='G'))
|
![[Customer]->[Orders] nofunky](_images/yuml-class-nofunky.png)
![[Customer]->[Orders] plain](_images/yuml-class-plain.png)
![[Customer]->[Orders] scruffy](_images/yuml-class-scruffy-td.png)
![[Customer]-(Buy Products)](_images/yuml-usecase-plain.png)
