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
|
"""Test pycode."""
from __future__ import annotations
import sys
from importlib.machinery import SourceFileLoader
from pathlib import Path
import pytest
import sphinx
from sphinx.errors import PycodeError
from sphinx.pycode import ModuleAnalyzer
SPHINX_MODULE_PATH = Path(sphinx.__file__).resolve().with_suffix('.py')
def test_ModuleAnalyzer_get_module_source() -> None:
assert isinstance(sphinx.__spec__.loader, SourceFileLoader) # type checking
assert ModuleAnalyzer.get_module_source('sphinx') == (
Path(sphinx.__file__),
sphinx.__spec__.loader.get_source('sphinx'),
)
# failed to obtain source information from builtin modules
with pytest.raises(PycodeError):
ModuleAnalyzer.get_module_source('builtins')
with pytest.raises(PycodeError):
ModuleAnalyzer.get_module_source('itertools')
def test_ModuleAnalyzer_for_string() -> None:
analyzer = ModuleAnalyzer.for_string('print("Hello world")', 'module_name')
assert analyzer.modname == 'module_name'
assert analyzer.srcname == '<string>'
def test_ModuleAnalyzer_for_file() -> None:
analyzer = ModuleAnalyzer.for_file(SPHINX_MODULE_PATH, 'sphinx')
assert analyzer.modname == 'sphinx'
assert analyzer.srcname == str(SPHINX_MODULE_PATH)
def test_ModuleAnalyzer_for_module(rootdir):
analyzer = ModuleAnalyzer.for_module('sphinx')
assert analyzer.modname == 'sphinx'
assert analyzer.srcname == str(SPHINX_MODULE_PATH)
saved_path = sys.path.copy()
sys.path.insert(0, str(rootdir / 'test-pycode'))
try:
analyzer = ModuleAnalyzer.for_module('cp_1251_coded')
docs = analyzer.find_attr_docs()
assert docs == {('', 'X'): ['It MUST look like X="\u0425"', '']}
finally:
sys.path[:] = saved_path
def test_ModuleAnalyzer_find_tags() -> None:
code = (
'class Foo(object):\n' # line: 1
' """class Foo!"""\n'
' def __init__(self):\n'
' pass\n'
'\n'
' def bar(self, arg1, arg2=True, *args, **kwargs):\n'
' """method Foo.bar"""\n'
' pass\n'
'\n'
' class Baz(object):\n'
' def __init__(self):\n' # line: 11
' pass\n'
'\n'
'def qux():\n'
' """function baz"""\n'
' pass\n'
'\n'
'@decorator1\n'
'@decorator2\n'
'def quux():\n'
' pass\n' # line: 21
'\n'
'class Corge(object):\n'
' @decorator1\n'
' @decorator2\n'
' def grault(self):\n'
' pass\n'
)
analyzer = ModuleAnalyzer.for_string(code, 'module')
tags = analyzer.find_tags()
assert set(tags.keys()) == {
'Foo',
'Foo.__init__',
'Foo.bar',
'Foo.Baz',
'Foo.Baz.__init__',
'qux',
'quux',
'Corge',
'Corge.grault',
}
assert tags['Foo'] == ('class', 1, 12) # type, start, end
assert tags['Foo.__init__'] == ('def', 3, 4)
assert tags['Foo.bar'] == ('def', 6, 8)
assert tags['Foo.Baz'] == ('class', 10, 12)
assert tags['Foo.Baz.__init__'] == ('def', 11, 12)
assert tags['qux'] == ('def', 14, 16)
assert tags['quux'] == ('def', 18, 21)
assert tags['Corge'] == ('class', 23, 27)
assert tags['Corge.grault'] == ('def', 24, 27)
def test_ModuleAnalyzer_find_attr_docs() -> None:
code = (
'class Foo(object):\n'
' """class Foo!"""\n'
' #: comment before attr1\n'
' attr1 = None\n'
' attr2 = None # attribute comment for attr2 (without colon)\n'
' attr3 = None #: attribute comment for attr3\n'
' attr4 = None #: long attribute comment\n'
' #: for attr4\n'
' #: comment before attr5\n'
' attr5 = None #: attribute comment for attr5\n'
' attr6, attr7 = 1, 2 #: this comment is ignored\n'
'\n'
' def __init__(self):\n'
' self.attr8 = None #: first attribute comment (ignored)\n'
' self.attr8 = None #: attribute comment for attr8\n'
' #: comment before attr9\n'
' self.attr9 = None #: comment after attr9\n'
' "string after attr9"\n'
'\n'
' def bar(self, arg1, arg2=True, *args, **kwargs):\n'
' """method Foo.bar"""\n'
' pass\n'
'\n'
'def baz():\n'
' """function baz"""\n'
' pass\n'
'\n'
'class Qux: attr1 = 1; attr2 = 2'
)
analyzer = ModuleAnalyzer.for_string(code, 'module')
docs = analyzer.find_attr_docs()
assert set(docs) == {
('Foo', 'attr1'),
('Foo', 'attr3'),
('Foo', 'attr4'),
('Foo', 'attr5'),
('Foo', 'attr6'),
('Foo', 'attr7'),
('Foo', 'attr8'),
('Foo', 'attr9'),
}
assert docs['Foo', 'attr1'] == ['comment before attr1', '']
assert docs['Foo', 'attr3'] == ['attribute comment for attr3', '']
assert docs['Foo', 'attr4'] == ['long attribute comment', '']
assert docs['Foo', 'attr4'] == ['long attribute comment', '']
assert docs['Foo', 'attr5'] == ['attribute comment for attr5', '']
assert docs['Foo', 'attr6'] == ['this comment is ignored', '']
assert docs['Foo', 'attr7'] == ['this comment is ignored', '']
assert docs['Foo', 'attr8'] == ['attribute comment for attr8', '']
assert docs['Foo', 'attr9'] == ['string after attr9', '']
assert analyzer.tagorder == {
'Foo': 0,
'Foo.__init__': 8,
'Foo.attr1': 1,
'Foo.attr2': 2,
'Foo.attr3': 3,
'Foo.attr4': 4,
'Foo.attr5': 5,
'Foo.attr6': 6,
'Foo.attr7': 7,
'Foo.attr8': 10,
'Foo.attr9': 12,
'Foo.bar': 13,
'baz': 14,
'Qux': 15,
'Qux.attr1': 16,
'Qux.attr2': 17,
}
def test_ModuleAnalyzer_find_attr_docs_for_posonlyargs_method() -> None:
code = (
'class Foo(object):\n'
' def __init__(self, /):\n'
' self.attr = None #: attribute comment\n'
)
analyzer = ModuleAnalyzer.for_string(code, 'module')
docs = analyzer.find_attr_docs()
assert set(docs) == {('Foo', 'attr')}
assert docs['Foo', 'attr'] == ['attribute comment', '']
assert analyzer.tagorder == {'Foo': 0, 'Foo.__init__': 1, 'Foo.attr': 2}
|
