mirror of
https://github.com/sphinx-doc/sphinx.git
synced 2025-02-25 18:55:22 -06:00
1062 lines
44 KiB
Python
1062 lines
44 KiB
Python
"""Tests the Python Domain"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
from unittest.mock import Mock
|
||
|
||
import docutils.utils
|
||
import pytest
|
||
from docutils import nodes
|
||
|
||
from sphinx import addnodes
|
||
from sphinx.addnodes import (
|
||
desc,
|
||
desc_annotation,
|
||
desc_content,
|
||
desc_name,
|
||
desc_parameter,
|
||
desc_parameterlist,
|
||
desc_returns,
|
||
desc_sig_keyword,
|
||
desc_sig_literal_number,
|
||
desc_sig_literal_string,
|
||
desc_sig_name,
|
||
desc_sig_operator,
|
||
desc_sig_punctuation,
|
||
desc_sig_space,
|
||
desc_signature,
|
||
desc_type_parameter,
|
||
desc_type_parameter_list,
|
||
pending_xref,
|
||
)
|
||
from sphinx.domains import IndexEntry
|
||
from sphinx.domains.python import PythonDomain, PythonModuleIndex
|
||
from sphinx.domains.python._annotations import _parse_annotation, _pseudo_parse_arglist
|
||
from sphinx.domains.python._object import py_sig_re
|
||
from sphinx.testing import restructuredtext
|
||
from sphinx.testing.util import assert_node
|
||
from sphinx.writers.text import STDINDENT
|
||
|
||
|
||
def parse(sig):
|
||
m = py_sig_re.match(sig)
|
||
if m is None:
|
||
raise ValueError
|
||
name_prefix, tp_list, name, arglist, retann = m.groups()
|
||
signode = addnodes.desc_signature(sig, '')
|
||
_pseudo_parse_arglist(signode, arglist)
|
||
return signode.astext()
|
||
|
||
|
||
def test_function_signatures():
|
||
rv = parse('func(a=1) -> int object')
|
||
assert rv == '(a=1)'
|
||
|
||
rv = parse('func(a=1, [b=None])')
|
||
assert rv == '(a=1, [b=None])'
|
||
|
||
rv = parse('func(a=1[, b=None])')
|
||
assert rv == '(a=1, [b=None])'
|
||
|
||
rv = parse("compile(source : string, filename, symbol='file')")
|
||
assert rv == "(source : string, filename, symbol='file')"
|
||
|
||
rv = parse('func(a=[], [b=None])')
|
||
assert rv == '(a=[], [b=None])'
|
||
|
||
rv = parse('func(a=[][, b=None])')
|
||
assert rv == '(a=[], [b=None])'
|
||
|
||
|
||
@pytest.mark.sphinx('dummy', testroot='domain-py')
|
||
def test_domain_py_xrefs(app):
|
||
"""Domain objects have correct prefixes when looking up xrefs"""
|
||
app.build(force_all=True)
|
||
|
||
def assert_refnode(node, module_name, class_name, target, reftype=None,
|
||
domain='py'):
|
||
attributes = {
|
||
'refdomain': domain,
|
||
'reftarget': target,
|
||
}
|
||
if reftype is not None:
|
||
attributes['reftype'] = reftype
|
||
if module_name is not False:
|
||
attributes['py:module'] = module_name
|
||
if class_name is not False:
|
||
attributes['py:class'] = class_name
|
||
assert_node(node, **attributes)
|
||
|
||
doctree = app.env.get_doctree('roles')
|
||
refnodes = list(doctree.findall(pending_xref))
|
||
assert_refnode(refnodes[0], None, None, 'TopLevel', 'class')
|
||
assert_refnode(refnodes[1], None, None, 'top_level', 'meth')
|
||
assert_refnode(refnodes[2], None, None, 'TopLevelType', 'type')
|
||
assert_refnode(refnodes[3], None, 'NestedParentA', 'child_1', 'meth')
|
||
assert_refnode(refnodes[4], None, 'NestedParentA', 'NestedChildA.subchild_2', 'meth')
|
||
assert_refnode(refnodes[5], None, 'NestedParentA', 'child_2', 'meth')
|
||
assert_refnode(refnodes[6], False, 'NestedParentA', 'any_child', domain='')
|
||
assert_refnode(refnodes[7], None, 'NestedParentA', 'NestedChildA', 'class')
|
||
assert_refnode(refnodes[8], None, 'NestedParentA.NestedChildA', 'subchild_2', 'meth')
|
||
assert_refnode(refnodes[9], None, 'NestedParentA.NestedChildA',
|
||
'NestedParentA.child_1', 'meth')
|
||
assert_refnode(refnodes[10], None, 'NestedParentA', 'NestedChildA.subchild_1', 'meth')
|
||
assert_refnode(refnodes[11], None, 'NestedParentB', 'child_1', 'meth')
|
||
assert_refnode(refnodes[12], None, 'NestedParentB', 'NestedParentB', 'class')
|
||
assert_refnode(refnodes[13], None, None, 'NestedParentA.NestedChildA', 'class')
|
||
assert_refnode(refnodes[14], None, None, 'NestedParentA.NestedTypeA', 'type')
|
||
assert len(refnodes) == 15
|
||
|
||
doctree = app.env.get_doctree('module')
|
||
refnodes = list(doctree.findall(pending_xref))
|
||
assert_refnode(refnodes[0], 'module_a.submodule', None,
|
||
'ModTopLevel', 'class')
|
||
assert_refnode(refnodes[1], 'module_a.submodule', 'ModTopLevel',
|
||
'mod_child_1', 'meth')
|
||
assert_refnode(refnodes[2], 'module_a.submodule', 'ModTopLevel',
|
||
'ModTopLevel.mod_child_1', 'meth')
|
||
assert_refnode(refnodes[3], 'module_a.submodule', 'ModTopLevel',
|
||
'mod_child_2', 'meth')
|
||
assert_refnode(refnodes[4], 'module_a.submodule', 'ModTopLevel',
|
||
'module_a.submodule.ModTopLevel.mod_child_1', 'meth')
|
||
assert_refnode(refnodes[5], 'module_a.submodule', 'ModTopLevel',
|
||
'prop', 'attr')
|
||
assert_refnode(refnodes[6], 'module_a.submodule', 'ModTopLevel',
|
||
'prop', 'meth')
|
||
assert_refnode(refnodes[7], 'module_b.submodule', None,
|
||
'ModTopLevel', 'class')
|
||
assert_refnode(refnodes[8], 'module_b.submodule', 'ModTopLevel',
|
||
'ModNoModule', 'class')
|
||
assert_refnode(refnodes[9], False, False, 'int', 'class')
|
||
assert_refnode(refnodes[10], False, False, 'tuple', 'class')
|
||
assert_refnode(refnodes[11], False, False, 'str', 'class')
|
||
assert_refnode(refnodes[12], False, False, 'float', 'class')
|
||
assert_refnode(refnodes[13], False, False, 'list', 'class')
|
||
assert_refnode(refnodes[14], False, False, 'ModTopLevel', 'class')
|
||
assert_refnode(refnodes[15], False, False, 'index', 'doc', domain='std')
|
||
assert_refnode(refnodes[16], False, False, 'typing.Literal', 'obj', domain='py')
|
||
assert_refnode(refnodes[17], False, False, 'typing.Literal', 'obj', domain='py')
|
||
assert_refnode(refnodes[18], False, False, 'list', 'class', domain='py')
|
||
assert_refnode(refnodes[19], False, False, 'int', 'class', domain='py')
|
||
assert_refnode(refnodes[20], False, False, 'str', 'class', domain='py')
|
||
assert len(refnodes) == 21
|
||
|
||
doctree = app.env.get_doctree('module_option')
|
||
refnodes = list(doctree.findall(pending_xref))
|
||
print(refnodes)
|
||
print(refnodes[0])
|
||
print(refnodes[1])
|
||
assert_refnode(refnodes[0], 'test.extra', 'B', 'foo', 'meth')
|
||
assert_refnode(refnodes[1], 'test.extra', 'B', 'foo', 'meth')
|
||
assert len(refnodes) == 2
|
||
|
||
|
||
@pytest.mark.sphinx('html', testroot='domain-py')
|
||
def test_domain_py_xrefs_abbreviations(app):
|
||
app.build(force_all=True)
|
||
|
||
content = (app.outdir / 'abbr.html').read_text(encoding='utf8')
|
||
assert re.search(r'normal: <a .* href="module.html#module_a.submodule.ModTopLevel.'
|
||
r'mod_child_1" .*><.*>module_a.submodule.ModTopLevel.mod_child_1\(\)'
|
||
r'<.*></a>',
|
||
content)
|
||
assert re.search(r'relative: <a .* href="module.html#module_a.submodule.ModTopLevel.'
|
||
r'mod_child_1" .*><.*>ModTopLevel.mod_child_1\(\)<.*></a>',
|
||
content)
|
||
assert re.search(r'short name: <a .* href="module.html#module_a.submodule.ModTopLevel.'
|
||
r'mod_child_1" .*><.*>mod_child_1\(\)<.*></a>',
|
||
content)
|
||
assert re.search(r'relative \+ short name: <a .* href="module.html#module_a.submodule.'
|
||
r'ModTopLevel.mod_child_1" .*><.*>mod_child_1\(\)<.*></a>',
|
||
content)
|
||
assert re.search(r'short name \+ relative: <a .* href="module.html#module_a.submodule.'
|
||
r'ModTopLevel.mod_child_1" .*><.*>mod_child_1\(\)<.*></a>',
|
||
content)
|
||
|
||
|
||
@pytest.mark.sphinx('dummy', testroot='domain-py')
|
||
def test_domain_py_objects(app):
|
||
app.build(force_all=True)
|
||
|
||
modules = app.env.domains['py'].data['modules']
|
||
objects = app.env.domains['py'].data['objects']
|
||
|
||
assert 'module_a.submodule' in modules
|
||
assert 'module_a.submodule' in objects
|
||
assert 'module_b.submodule' in modules
|
||
assert 'module_b.submodule' in objects
|
||
|
||
assert objects['module_a.submodule.ModTopLevel'][2] == 'class'
|
||
assert objects['module_a.submodule.ModTopLevel.mod_child_1'][2] == 'method'
|
||
assert objects['module_a.submodule.ModTopLevel.mod_child_2'][2] == 'method'
|
||
assert 'ModTopLevel.ModNoModule' not in objects
|
||
assert objects['ModNoModule'][2] == 'class'
|
||
assert objects['module_b.submodule.ModTopLevel'][2] == 'class'
|
||
|
||
assert objects['TopLevel'][2] == 'class'
|
||
assert objects['top_level'][2] == 'method'
|
||
assert objects['TopLevelType'][2] == 'type'
|
||
assert objects['NestedParentA'][2] == 'class'
|
||
assert objects['NestedParentA.NestedTypeA'][2] == 'type'
|
||
assert objects['NestedParentA.child_1'][2] == 'method'
|
||
assert objects['NestedParentA.any_child'][2] == 'method'
|
||
assert objects['NestedParentA.NestedChildA'][2] == 'class'
|
||
assert objects['NestedParentA.NestedChildA.subchild_1'][2] == 'method'
|
||
assert objects['NestedParentA.NestedChildA.subchild_2'][2] == 'method'
|
||
assert objects['NestedParentA.child_2'][2] == 'method'
|
||
assert objects['NestedParentB'][2] == 'class'
|
||
assert objects['NestedParentB.child_1'][2] == 'method'
|
||
|
||
|
||
@pytest.mark.sphinx('html', testroot='domain-py')
|
||
def test_resolve_xref_for_properties(app):
|
||
app.build(force_all=True)
|
||
|
||
content = (app.outdir / 'module.html').read_text(encoding='utf8')
|
||
assert ('Link to <a class="reference internal" href="#module_a.submodule.ModTopLevel.prop"'
|
||
' title="module_a.submodule.ModTopLevel.prop">'
|
||
'<code class="xref py py-attr docutils literal notranslate"><span class="pre">'
|
||
'prop</span> <span class="pre">attribute</span></code></a>' in content)
|
||
assert ('Link to <a class="reference internal" href="#module_a.submodule.ModTopLevel.prop"'
|
||
' title="module_a.submodule.ModTopLevel.prop">'
|
||
'<code class="xref py py-meth docutils literal notranslate"><span class="pre">'
|
||
'prop</span> <span class="pre">method</span></code></a>' in content)
|
||
assert ('Link to <a class="reference internal" href="#module_a.submodule.ModTopLevel.prop"'
|
||
' title="module_a.submodule.ModTopLevel.prop">'
|
||
'<code class="xref py py-attr docutils literal notranslate"><span class="pre">'
|
||
'prop</span> <span class="pre">attribute</span></code></a>' in content)
|
||
|
||
|
||
@pytest.mark.sphinx('dummy', testroot='domain-py')
|
||
def test_domain_py_find_obj(app):
|
||
|
||
def find_obj(modname, prefix, obj_name, obj_type, searchmode=0):
|
||
return app.env.domains['py'].find_obj(
|
||
app.env, modname, prefix, obj_name, obj_type, searchmode)
|
||
|
||
app.build(force_all=True)
|
||
|
||
assert (find_obj(None, None, 'NONEXISTANT', 'class') == [])
|
||
assert (find_obj(None, None, 'NestedParentA', 'class') ==
|
||
[('NestedParentA', ('roles', 'NestedParentA', 'class', False))])
|
||
assert (find_obj(None, None, 'NestedParentA.NestedTypeA', 'type') ==
|
||
[('NestedParentA.NestedTypeA',
|
||
('roles', 'NestedParentA.NestedTypeA', 'type', False))])
|
||
assert (find_obj(None, None, 'NestedParentA.NestedChildA', 'class') ==
|
||
[('NestedParentA.NestedChildA',
|
||
('roles', 'NestedParentA.NestedChildA', 'class', False))])
|
||
assert (find_obj(None, 'NestedParentA', 'NestedChildA', 'class') ==
|
||
[('NestedParentA.NestedChildA',
|
||
('roles', 'NestedParentA.NestedChildA', 'class', False))])
|
||
assert (find_obj(None, None, 'NestedParentA.NestedChildA.subchild_1', 'meth') ==
|
||
[('NestedParentA.NestedChildA.subchild_1',
|
||
('roles', 'NestedParentA.NestedChildA.subchild_1', 'method', False))])
|
||
assert (find_obj(None, 'NestedParentA', 'NestedChildA.subchild_1', 'meth') ==
|
||
[('NestedParentA.NestedChildA.subchild_1',
|
||
('roles', 'NestedParentA.NestedChildA.subchild_1', 'method', False))])
|
||
assert (find_obj(None, 'NestedParentA.NestedChildA', 'subchild_1', 'meth') ==
|
||
[('NestedParentA.NestedChildA.subchild_1',
|
||
('roles', 'NestedParentA.NestedChildA.subchild_1', 'method', False))])
|
||
|
||
|
||
def test_get_full_qualified_name():
|
||
env = Mock(domaindata={})
|
||
domain = PythonDomain(env)
|
||
|
||
# non-python references
|
||
node = nodes.reference()
|
||
assert domain.get_full_qualified_name(node) is None
|
||
|
||
# simple reference
|
||
node = nodes.reference(reftarget='func')
|
||
assert domain.get_full_qualified_name(node) == 'func'
|
||
|
||
# with py:module context
|
||
kwargs = {'py:module': 'module1'}
|
||
node = nodes.reference(reftarget='func', **kwargs)
|
||
assert domain.get_full_qualified_name(node) == 'module1.func'
|
||
|
||
# with py:class context
|
||
kwargs = {'py:class': 'Class'}
|
||
node = nodes.reference(reftarget='func', **kwargs)
|
||
assert domain.get_full_qualified_name(node) == 'Class.func'
|
||
|
||
# with both py:module and py:class context
|
||
kwargs = {'py:module': 'module1', 'py:class': 'Class'}
|
||
node = nodes.reference(reftarget='func', **kwargs)
|
||
assert domain.get_full_qualified_name(node) == 'module1.Class.func'
|
||
|
||
|
||
def test_parse_annotation(app):
|
||
doctree = _parse_annotation("int", app.env)
|
||
assert_node(doctree, ([pending_xref, "int"],))
|
||
assert_node(doctree[0], pending_xref, refdomain="py", reftype="class", reftarget="int")
|
||
|
||
doctree = _parse_annotation("List[int]", app.env)
|
||
assert_node(doctree, ([pending_xref, "List"],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("Tuple[int, int]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Tuple"],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("Tuple[()]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Tuple"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_punctuation, "("],
|
||
[desc_sig_punctuation, ")"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("Tuple[int, ...]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Tuple"],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, "..."],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("Callable[[int, int], int]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Callable"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, "]"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("Callable[[], int]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Callable"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_punctuation, "]"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[pending_xref, "int"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("List[None]", app.env)
|
||
assert_node(doctree, ([pending_xref, "List"],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "None"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
# None type makes an object-reference (not a class reference)
|
||
doctree = _parse_annotation("None", app.env)
|
||
assert_node(doctree, ([pending_xref, "None"],))
|
||
assert_node(doctree[0], pending_xref, refdomain="py", reftype="obj", reftarget="None")
|
||
|
||
# Literal type makes an object-reference (not a class reference)
|
||
doctree = _parse_annotation("typing.Literal['a', 'b']", app.env)
|
||
assert_node(doctree, ([pending_xref, "Literal"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_literal_string, "'a'"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[desc_sig_literal_string, "'b'"],
|
||
[desc_sig_punctuation, "]"]))
|
||
assert_node(doctree[0], pending_xref, refdomain="py", reftype="obj", reftarget="typing.Literal")
|
||
|
||
# Annotated type with callable gets parsed
|
||
doctree = _parse_annotation("Annotated[Optional[str], annotated_types.MaxLen(max_length=10)]", app.env)
|
||
assert_node(doctree, (
|
||
[pending_xref, 'Annotated'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'str'],
|
||
[desc_sig_space, ' '],
|
||
[desc_sig_punctuation, '|'],
|
||
[desc_sig_space, ' '],
|
||
[pending_xref, 'None'],
|
||
[desc_sig_punctuation, ','],
|
||
[desc_sig_space, ' '],
|
||
[pending_xref, 'annotated_types.MaxLen'],
|
||
[desc_sig_punctuation, '('],
|
||
[desc_sig_name, 'max_length'],
|
||
[desc_sig_operator, '='],
|
||
[desc_sig_literal_number, '10'],
|
||
[desc_sig_punctuation, ')'],
|
||
[desc_sig_punctuation, ']'],
|
||
))
|
||
|
||
|
||
def test_parse_annotation_suppress(app):
|
||
doctree = _parse_annotation("~typing.Dict[str, str]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Dict"],
|
||
[desc_sig_punctuation, "["],
|
||
[pending_xref, "str"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[pending_xref, "str"],
|
||
[desc_sig_punctuation, "]"]))
|
||
assert_node(doctree[0], pending_xref, refdomain="py", reftype="obj", reftarget="typing.Dict")
|
||
|
||
|
||
def test_parse_annotation_Literal(app):
|
||
doctree = _parse_annotation("Literal[True, False]", app.env)
|
||
assert_node(doctree, ([pending_xref, "Literal"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_keyword, "True"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[desc_sig_keyword, "False"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
doctree = _parse_annotation("typing.Literal[0, 1, 'abc']", app.env)
|
||
assert_node(doctree, ([pending_xref, "Literal"],
|
||
[desc_sig_punctuation, "["],
|
||
[desc_sig_literal_number, "0"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[desc_sig_literal_number, "1"],
|
||
[desc_sig_punctuation, ","],
|
||
desc_sig_space,
|
||
[desc_sig_literal_string, "'abc'"],
|
||
[desc_sig_punctuation, "]"]))
|
||
|
||
|
||
@pytest.mark.sphinx(freshenv=True)
|
||
def test_module_index(app):
|
||
text = (".. py:module:: docutils\n"
|
||
".. py:module:: sphinx\n"
|
||
".. py:module:: sphinx.config\n"
|
||
".. py:module:: sphinx.builders\n"
|
||
".. py:module:: sphinx.builders.html\n"
|
||
".. py:module:: sphinx_intl\n")
|
||
restructuredtext.parse(app, text)
|
||
index = PythonModuleIndex(app.env.get_domain('py'))
|
||
assert index.generate() == (
|
||
[('d', [IndexEntry('docutils', 0, 'index', 'module-docutils', '', '', '')]),
|
||
('s', [IndexEntry('sphinx', 1, 'index', 'module-sphinx', '', '', ''),
|
||
IndexEntry('sphinx.builders', 2, 'index', 'module-sphinx.builders', '', '', ''),
|
||
IndexEntry('sphinx.builders.html', 2, 'index', 'module-sphinx.builders.html', '', '', ''),
|
||
IndexEntry('sphinx.config', 2, 'index', 'module-sphinx.config', '', '', ''),
|
||
IndexEntry('sphinx_intl', 0, 'index', 'module-sphinx_intl', '', '', '')])],
|
||
False,
|
||
)
|
||
|
||
|
||
@pytest.mark.sphinx(freshenv=True)
|
||
def test_module_index_submodule(app):
|
||
text = ".. py:module:: sphinx.config\n"
|
||
restructuredtext.parse(app, text)
|
||
index = PythonModuleIndex(app.env.get_domain('py'))
|
||
assert index.generate() == (
|
||
[('s', [IndexEntry('sphinx', 1, '', '', '', '', ''),
|
||
IndexEntry('sphinx.config', 2, 'index', 'module-sphinx.config', '', '', '')])],
|
||
False,
|
||
)
|
||
|
||
|
||
@pytest.mark.sphinx(freshenv=True)
|
||
def test_module_index_not_collapsed(app):
|
||
text = (".. py:module:: docutils\n"
|
||
".. py:module:: sphinx\n")
|
||
restructuredtext.parse(app, text)
|
||
index = PythonModuleIndex(app.env.get_domain('py'))
|
||
assert index.generate() == (
|
||
[('d', [IndexEntry('docutils', 0, 'index', 'module-docutils', '', '', '')]),
|
||
('s', [IndexEntry('sphinx', 0, 'index', 'module-sphinx', '', '', '')])],
|
||
True,
|
||
)
|
||
|
||
|
||
@pytest.mark.sphinx(freshenv=True, confoverrides={'modindex_common_prefix': ['sphinx.']})
|
||
def test_modindex_common_prefix(app):
|
||
text = (".. py:module:: docutils\n"
|
||
".. py:module:: sphinx\n"
|
||
".. py:module:: sphinx.config\n"
|
||
".. py:module:: sphinx.builders\n"
|
||
".. py:module:: sphinx.builders.html\n"
|
||
".. py:module:: sphinx_intl\n")
|
||
restructuredtext.parse(app, text)
|
||
index = PythonModuleIndex(app.env.get_domain('py'))
|
||
assert index.generate() == (
|
||
[('b', [IndexEntry('sphinx.builders', 1, 'index', 'module-sphinx.builders', '', '', ''),
|
||
IndexEntry('sphinx.builders.html', 2, 'index', 'module-sphinx.builders.html', '', '', '')]),
|
||
('c', [IndexEntry('sphinx.config', 0, 'index', 'module-sphinx.config', '', '', '')]),
|
||
('d', [IndexEntry('docutils', 0, 'index', 'module-docutils', '', '', '')]),
|
||
('s', [IndexEntry('sphinx', 0, 'index', 'module-sphinx', '', '', ''),
|
||
IndexEntry('sphinx_intl', 0, 'index', 'module-sphinx_intl', '', '', '')])],
|
||
True,
|
||
)
|
||
|
||
|
||
def test_no_index_entry(app):
|
||
text = (".. py:function:: f()\n"
|
||
".. py:function:: g()\n"
|
||
" :no-index-entry:\n")
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (addnodes.index, desc, addnodes.index, desc))
|
||
assert_node(doctree[0], addnodes.index, entries=[('pair', 'built-in function; f()', 'f', '', None)])
|
||
assert_node(doctree[2], addnodes.index, entries=[])
|
||
|
||
text = (".. py:class:: f\n"
|
||
".. py:class:: g\n"
|
||
" :no-index-entry:\n")
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (addnodes.index, desc, addnodes.index, desc))
|
||
assert_node(doctree[0], addnodes.index, entries=[('single', 'f (built-in class)', 'f', '', None)])
|
||
assert_node(doctree[2], addnodes.index, entries=[])
|
||
|
||
|
||
@pytest.mark.sphinx('html', testroot='domain-py-python_use_unqualified_type_names')
|
||
def test_python_python_use_unqualified_type_names(app):
|
||
app.build()
|
||
content = (app.outdir / 'index.html').read_text(encoding='utf8')
|
||
assert ('<span class="n"><a class="reference internal" href="#foo.Name" title="foo.Name">'
|
||
'<span class="pre">Name</span></a></span>' in content)
|
||
assert '<span class="n"><span class="pre">foo.Age</span></span>' in content
|
||
assert ('<p><strong>name</strong> (<a class="reference internal" href="#foo.Name" '
|
||
'title="foo.Name"><em>Name</em></a>) – blah blah</p>' in content)
|
||
assert '<p><strong>age</strong> (<em>foo.Age</em>) – blah blah</p>' in content
|
||
|
||
|
||
@pytest.mark.sphinx('html', testroot='domain-py-python_use_unqualified_type_names',
|
||
confoverrides={'python_use_unqualified_type_names': False})
|
||
def test_python_python_use_unqualified_type_names_disabled(app):
|
||
app.build()
|
||
content = (app.outdir / 'index.html').read_text(encoding='utf8')
|
||
assert ('<span class="n"><a class="reference internal" href="#foo.Name" title="foo.Name">'
|
||
'<span class="pre">foo.Name</span></a></span>' in content)
|
||
assert '<span class="n"><span class="pre">foo.Age</span></span>' in content
|
||
assert ('<p><strong>name</strong> (<a class="reference internal" href="#foo.Name" '
|
||
'title="foo.Name"><em>foo.Name</em></a>) – blah blah</p>' in content)
|
||
assert '<p><strong>age</strong> (<em>foo.Age</em>) – blah blah</p>' in content
|
||
|
||
|
||
@pytest.mark.sphinx('dummy', testroot='domain-py-xref-warning')
|
||
def test_warn_missing_reference(app):
|
||
app.build()
|
||
assert "index.rst:6: WARNING: undefined label: 'no-label'" in app.warning.getvalue()
|
||
assert ("index.rst:6: WARNING: Failed to create a cross reference. "
|
||
"A title or caption not found: 'existing-label'") in app.warning.getvalue()
|
||
|
||
|
||
@pytest.mark.sphinx(confoverrides={'nitpicky': True})
|
||
@pytest.mark.parametrize('include_options', [True, False])
|
||
def test_signature_line_number(app, include_options):
|
||
text = (".. py:function:: foo(bar : string)\n" +
|
||
(" :no-index-entry:\n" if include_options else ""))
|
||
doc = restructuredtext.parse(app, text)
|
||
xrefs = list(doc.findall(condition=addnodes.pending_xref))
|
||
assert len(xrefs) == 1
|
||
source, line = docutils.utils.get_source_line(xrefs[0])
|
||
assert 'index.rst' in source
|
||
assert line == 1
|
||
|
||
|
||
@pytest.mark.sphinx(
|
||
'html',
|
||
confoverrides={
|
||
'python_maximum_signature_line_length': len("hello(name: str) -> str"),
|
||
'maximum_signature_line_length': 1,
|
||
},
|
||
)
|
||
def test_python_maximum_signature_line_length_overrides_global(app):
|
||
text = ".. py:function:: hello(name: str) -> str"
|
||
doctree = restructuredtext.parse(app, text)
|
||
expected_doctree = (addnodes.index,
|
||
[desc, ([desc_signature, ([desc_name, "hello"],
|
||
desc_parameterlist,
|
||
[desc_returns, pending_xref, "str"])],
|
||
desc_content)])
|
||
assert_node(doctree, expected_doctree)
|
||
assert_node(doctree[1], addnodes.desc, desctype="function",
|
||
domain="py", objtype="function", no_index=False)
|
||
signame_node = [desc_sig_name, "name"]
|
||
expected_sig = [desc_parameterlist, desc_parameter, (signame_node,
|
||
[desc_sig_punctuation, ":"],
|
||
desc_sig_space,
|
||
[nodes.inline, pending_xref, "str"])]
|
||
assert_node(doctree[1][0][1], expected_sig)
|
||
assert_node(doctree[1][0][1], desc_parameterlist, multi_line_parameter_list=False)
|
||
|
||
|
||
@pytest.mark.sphinx(
|
||
'html', testroot='domain-py-python_maximum_signature_line_length',
|
||
)
|
||
def test_domain_py_python_maximum_signature_line_length_in_html(app):
|
||
app.build()
|
||
content = (app.outdir / 'index.html').read_text(encoding='utf8')
|
||
expected_parameter_list_hello = """\
|
||
|
||
<dl>
|
||
<dd>\
|
||
<em class="sig-param">\
|
||
<span class="n"><span class="pre">name</span></span>\
|
||
<span class="p"><span class="pre">:</span></span>\
|
||
<span class="w"> </span>\
|
||
<span class="n"><span class="pre">str</span></span>\
|
||
</em>,\
|
||
</dd>
|
||
</dl>
|
||
|
||
<span class="sig-paren">)</span> \
|
||
<span class="sig-return">\
|
||
<span class="sig-return-icon">→</span> \
|
||
<span class="sig-return-typehint"><span class="pre">str</span></span>\
|
||
</span>\
|
||
<a class="headerlink" href="#hello" title="Link to this definition">¶</a>\
|
||
</dt>\
|
||
"""
|
||
assert expected_parameter_list_hello in content
|
||
|
||
param_line_fmt = '<dd>{}</dd>\n'
|
||
param_name_fmt = (
|
||
'<em class="sig-param"><span class="n"><span class="pre">{}</span></span></em>'
|
||
)
|
||
optional_fmt = '<span class="optional">{}</span>'
|
||
|
||
expected_a = param_line_fmt.format(
|
||
optional_fmt.format("[") + param_name_fmt.format("a") + "," + optional_fmt.format("["),
|
||
)
|
||
assert expected_a in content
|
||
|
||
expected_b = param_line_fmt.format(
|
||
param_name_fmt.format("b") + "," + optional_fmt.format("]") + optional_fmt.format("]"),
|
||
)
|
||
assert expected_b in content
|
||
|
||
expected_c = param_line_fmt.format(param_name_fmt.format("c") + ",")
|
||
assert expected_c in content
|
||
|
||
expected_d = param_line_fmt.format(param_name_fmt.format("d") + optional_fmt.format("[") + ",")
|
||
assert expected_d in content
|
||
|
||
expected_e = param_line_fmt.format(param_name_fmt.format("e") + ",")
|
||
assert expected_e in content
|
||
|
||
expected_f = param_line_fmt.format(param_name_fmt.format("f") + "," + optional_fmt.format("]"))
|
||
assert expected_f in content
|
||
|
||
expected_parameter_list_foo = """\
|
||
|
||
<dl>
|
||
{}{}{}{}{}{}</dl>
|
||
|
||
<span class="sig-paren">)</span>\
|
||
<a class="headerlink" href="#foo" title="Link to this definition">¶</a>\
|
||
</dt>\
|
||
""".format(expected_a, expected_b, expected_c, expected_d, expected_e, expected_f)
|
||
assert expected_parameter_list_foo in content
|
||
|
||
|
||
@pytest.mark.sphinx(
|
||
'text', testroot='domain-py-python_maximum_signature_line_length',
|
||
)
|
||
def test_domain_py_python_maximum_signature_line_length_in_text(app):
|
||
app.build()
|
||
content = (app.outdir / 'index.txt').read_text(encoding='utf8')
|
||
param_line_fmt = STDINDENT * " " + "{}\n"
|
||
|
||
expected_parameter_list_hello = "(\n{}) -> str".format(param_line_fmt.format("name: str,"))
|
||
|
||
assert expected_parameter_list_hello in content
|
||
|
||
expected_a = param_line_fmt.format("[a,[")
|
||
assert expected_a in content
|
||
|
||
expected_b = param_line_fmt.format("b,]]")
|
||
assert expected_b in content
|
||
|
||
expected_c = param_line_fmt.format("c,")
|
||
assert expected_c in content
|
||
|
||
expected_d = param_line_fmt.format("d[,")
|
||
assert expected_d in content
|
||
|
||
expected_e = param_line_fmt.format("e,")
|
||
assert expected_e in content
|
||
|
||
expected_f = param_line_fmt.format("f,]")
|
||
assert expected_f in content
|
||
|
||
expected_parameter_list_foo = "(\n{}{}{}{}{}{})".format(
|
||
expected_a, expected_b, expected_c, expected_d, expected_e, expected_f,
|
||
)
|
||
assert expected_parameter_list_foo in content
|
||
|
||
|
||
def test_module_content_line_number(app):
|
||
text = (".. py:module:: foo\n" +
|
||
"\n" +
|
||
" Some link here: :ref:`abc`\n")
|
||
doc = restructuredtext.parse(app, text)
|
||
xrefs = list(doc.findall(condition=addnodes.pending_xref))
|
||
assert len(xrefs) == 1
|
||
source, line = docutils.utils.get_source_line(xrefs[0])
|
||
assert 'index.rst' in source
|
||
assert line == 3
|
||
|
||
|
||
@pytest.mark.sphinx(freshenv=True, confoverrides={'python_display_short_literal_types': True})
|
||
def test_short_literal_types(app):
|
||
text = """\
|
||
.. py:function:: literal_ints(x: Literal[1, 2, 3] = 1) -> None
|
||
.. py:function:: literal_union(x: Union[Literal["a"], Literal["b"], Literal["c"]]) -> None
|
||
"""
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (
|
||
addnodes.index,
|
||
[desc, (
|
||
[desc_signature, (
|
||
[desc_name, 'literal_ints'],
|
||
[desc_parameterlist, (
|
||
[desc_parameter, (
|
||
[desc_sig_name, 'x'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[desc_sig_literal_number, '1'],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '|'],
|
||
desc_sig_space,
|
||
[desc_sig_literal_number, '2'],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '|'],
|
||
desc_sig_space,
|
||
[desc_sig_literal_number, '3'],
|
||
)],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, '1'],
|
||
)],
|
||
)],
|
||
[desc_returns, pending_xref, 'None'],
|
||
)],
|
||
[desc_content, ()],
|
||
)],
|
||
addnodes.index,
|
||
[desc, (
|
||
[desc_signature, (
|
||
[desc_name, 'literal_union'],
|
||
[desc_parameterlist, (
|
||
[desc_parameter, (
|
||
[desc_sig_name, 'x'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[desc_sig_literal_string, "'a'"],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '|'],
|
||
desc_sig_space,
|
||
[desc_sig_literal_string, "'b'"],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '|'],
|
||
desc_sig_space,
|
||
[desc_sig_literal_string, "'c'"],
|
||
)],
|
||
)],
|
||
)],
|
||
[desc_returns, pending_xref, 'None'],
|
||
)],
|
||
[desc_content, ()],
|
||
)],
|
||
))
|
||
|
||
|
||
def test_function_pep_695(app):
|
||
text = """.. py:function:: func[\
|
||
S,\
|
||
T: int,\
|
||
U: (int, str),\
|
||
R: int | str,\
|
||
A: int | Annotated[int, ctype("char")],\
|
||
*V,\
|
||
**P\
|
||
]
|
||
"""
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (
|
||
addnodes.index,
|
||
[desc, (
|
||
[desc_signature, (
|
||
[desc_name, 'func'],
|
||
[desc_type_parameter_list, (
|
||
[desc_type_parameter, ([desc_sig_name, 'S'])],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'T'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, ([pending_xref, 'int'])],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'U'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '('],
|
||
[desc_sig_name, (
|
||
[pending_xref, 'int'],
|
||
[desc_sig_punctuation, ','],
|
||
desc_sig_space,
|
||
[pending_xref, 'str'],
|
||
)],
|
||
[desc_sig_punctuation, ')'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'R'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[pending_xref, 'int'],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '|'],
|
||
desc_sig_space,
|
||
[pending_xref, 'str'],
|
||
)],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'A'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[pending_xref, 'int'],
|
||
[desc_sig_space, ' '],
|
||
[desc_sig_punctuation, '|'],
|
||
[desc_sig_space, ' '],
|
||
[pending_xref, 'Annotated'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'int'],
|
||
[desc_sig_punctuation, ','],
|
||
[desc_sig_space, ' '],
|
||
[pending_xref, 'ctype'],
|
||
[desc_sig_punctuation, '('],
|
||
[desc_sig_literal_string, "'char'"],
|
||
[desc_sig_punctuation, ')'],
|
||
[desc_sig_punctuation, ']'],
|
||
)],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_operator, '*'],
|
||
[desc_sig_name, 'V'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_operator, '**'],
|
||
[desc_sig_name, 'P'],
|
||
)],
|
||
)],
|
||
[desc_parameterlist, ()],
|
||
)],
|
||
[desc_content, ()],
|
||
)],
|
||
))
|
||
|
||
|
||
def test_class_def_pep_695(app):
|
||
# Non-concrete unbound generics are allowed at runtime but type checkers
|
||
# should fail (https://peps.python.org/pep-0695/#type-parameter-scopes)
|
||
text = """.. py:class:: Class[S: Sequence[T], T, KT, VT](Dict[KT, VT])"""
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (
|
||
addnodes.index,
|
||
[desc, (
|
||
[desc_signature, (
|
||
[desc_annotation, ('class', desc_sig_space)],
|
||
[desc_name, 'Class'],
|
||
[desc_type_parameter_list, (
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'S'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[pending_xref, 'Sequence'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'T'],
|
||
[desc_sig_punctuation, ']'],
|
||
)],
|
||
)],
|
||
[desc_type_parameter, ([desc_sig_name, 'T'])],
|
||
[desc_type_parameter, ([desc_sig_name, 'KT'])],
|
||
[desc_type_parameter, ([desc_sig_name, 'VT'])],
|
||
)],
|
||
[desc_parameterlist, ([desc_parameter, 'Dict[KT, VT]'])],
|
||
)],
|
||
[desc_content, ()],
|
||
)],
|
||
))
|
||
|
||
|
||
def test_class_def_pep_696(app):
|
||
# test default values for type variables without using PEP 696 AST parser
|
||
text = """.. py:class:: Class[\
|
||
T, KT, VT,\
|
||
J: int,\
|
||
K = list,\
|
||
S: str = str,\
|
||
L: (T, tuple[T, ...], collections.abc.Iterable[T]) = set[T],\
|
||
Q: collections.abc.Mapping[KT, VT] = dict[KT, VT],\
|
||
*V = *tuple[*Ts, bool],\
|
||
**P = [int, Annotated[int, ValueRange(3, 10), ctype("char")]]\
|
||
](Other[T, KT, VT, J, S, L, Q, *V, **P])
|
||
"""
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert_node(doctree, (
|
||
addnodes.index,
|
||
[desc, (
|
||
[desc_signature, (
|
||
[desc_annotation, ('class', desc_sig_space)],
|
||
[desc_name, 'Class'],
|
||
[desc_type_parameter_list, (
|
||
[desc_type_parameter, ([desc_sig_name, 'T'])],
|
||
[desc_type_parameter, ([desc_sig_name, 'KT'])],
|
||
[desc_type_parameter, ([desc_sig_name, 'VT'])],
|
||
# J: int
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'J'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, ([pending_xref, 'int'])],
|
||
)],
|
||
# K = list
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'K'],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, 'list'],
|
||
)],
|
||
# S: str = str
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'S'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, ([pending_xref, 'str'])],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, 'str'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'L'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '('],
|
||
[desc_sig_name, (
|
||
# T
|
||
[pending_xref, 'T'],
|
||
[desc_sig_punctuation, ','],
|
||
desc_sig_space,
|
||
# tuple[T, ...]
|
||
[pending_xref, 'tuple'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'T'],
|
||
[desc_sig_punctuation, ','],
|
||
desc_sig_space,
|
||
[desc_sig_punctuation, '...'],
|
||
[desc_sig_punctuation, ']'],
|
||
[desc_sig_punctuation, ','],
|
||
desc_sig_space,
|
||
# collections.abc.Iterable[T]
|
||
[pending_xref, 'collections.abc.Iterable'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'T'],
|
||
[desc_sig_punctuation, ']'],
|
||
)],
|
||
[desc_sig_punctuation, ')'],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, 'set[T]'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_name, 'Q'],
|
||
[desc_sig_punctuation, ':'],
|
||
desc_sig_space,
|
||
[desc_sig_name, (
|
||
[pending_xref, 'collections.abc.Mapping'],
|
||
[desc_sig_punctuation, '['],
|
||
[pending_xref, 'KT'],
|
||
[desc_sig_punctuation, ','],
|
||
desc_sig_space,
|
||
[pending_xref, 'VT'],
|
||
[desc_sig_punctuation, ']'],
|
||
)],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, 'dict[KT, VT]'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_operator, '*'],
|
||
[desc_sig_name, 'V'],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, '*tuple[*Ts, bool]'],
|
||
)],
|
||
[desc_type_parameter, (
|
||
[desc_sig_operator, '**'],
|
||
[desc_sig_name, 'P'],
|
||
desc_sig_space,
|
||
[desc_sig_operator, '='],
|
||
desc_sig_space,
|
||
[nodes.inline, '[int, Annotated[int, ValueRange(3, 10), ctype("char")]]'],
|
||
)],
|
||
)],
|
||
[desc_parameterlist, (
|
||
[desc_parameter, 'Other[T, KT, VT, J, S, L, Q, *V, **P]'],
|
||
)],
|
||
)],
|
||
[desc_content, ()],
|
||
)],
|
||
))
|
||
|
||
|
||
@pytest.mark.parametrize(('tp_list', 'tptext'), [
|
||
('[T:int]', '[T: int]'),
|
||
('[T:*Ts]', '[T: *Ts]'),
|
||
('[T:int|(*Ts)]', '[T: int | (*Ts)]'),
|
||
('[T:(*Ts)|int]', '[T: (*Ts) | int]'),
|
||
('[T:(int|(*Ts))]', '[T: (int | (*Ts))]'),
|
||
('[T:((*Ts)|int)]', '[T: ((*Ts) | int)]'),
|
||
("[T:Annotated[int,ctype('char')]]", "[T: Annotated[int, ctype('char')]]"),
|
||
])
|
||
def test_pep_695_and_pep_696_whitespaces_in_bound(app, tp_list, tptext):
|
||
text = f'.. py:function:: f{tp_list}()'
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert doctree.astext() == f'\n\nf{tptext}()\n\n'
|
||
|
||
|
||
@pytest.mark.parametrize(('tp_list', 'tptext'), [
|
||
('[T:(int,str)]', '[T: (int, str)]'),
|
||
('[T:(int|str,*Ts)]', '[T: (int | str, *Ts)]'),
|
||
])
|
||
def test_pep_695_and_pep_696_whitespaces_in_constraints(app, tp_list, tptext):
|
||
text = f'.. py:function:: f{tp_list}()'
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert doctree.astext() == f'\n\nf{tptext}()\n\n'
|
||
|
||
|
||
@pytest.mark.parametrize(('tp_list', 'tptext'), [
|
||
('[T=int]', '[T = int]'),
|
||
('[T:int=int]', '[T: int = int]'),
|
||
('[*V=*Ts]', '[*V = *Ts]'),
|
||
('[*V=(*Ts)]', '[*V = (*Ts)]'),
|
||
('[*V=*tuple[str,...]]', '[*V = *tuple[str, ...]]'),
|
||
('[*V=*tuple[*Ts,...]]', '[*V = *tuple[*Ts, ...]]'),
|
||
('[*V=*tuple[int,*Ts]]', '[*V = *tuple[int, *Ts]]'),
|
||
('[*V=*tuple[*Ts,int]]', '[*V = *tuple[*Ts, int]]'),
|
||
('[**P=[int,*Ts]]', '[**P = [int, *Ts]]'),
|
||
('[**P=[int, int*3]]', '[**P = [int, int * 3]]'),
|
||
('[**P=[int, *Ts*3]]', '[**P = [int, *Ts * 3]]'),
|
||
('[**P=[int,A[int,ctype("char")]]]', '[**P = [int, A[int, ctype("char")]]]'),
|
||
])
|
||
def test_pep_695_and_pep_696_whitespaces_in_default(app, tp_list, tptext):
|
||
text = f'.. py:function:: f{tp_list}()'
|
||
doctree = restructuredtext.parse(app, text)
|
||
assert doctree.astext() == f'\n\nf{tptext}()\n\n'
|