def test_decorated_member():
from mkapi.core import attribute
from mkapi.core.signature import Signature
node = get_node(attribute)
assert node.members[-1].object.kind == "function"
assert get_node(Signature)["arguments"].object.kind == "readonly property"
def test_get_node_from_module():
_ = get_module("mkapi.core")
x = get_node("mkapi.core.base.Base.__iter__")
y = get_node("mkapi.core.base.Base.__iter__")
assert x is not y
x = get_node_from_module("mkapi.core.base.Base.__iter__")
y = get_node_from_module("mkapi.core.base.Base.__iter__")
assert x is y
def get_bases(node: Node) -> Iterator[Tuple[Node, Iterator[Node]]]:
"""Yields a tuple of (Node instance, iterator of Node).
Args:
node: Node instance.
Examples:
>>> from mkapi.core.object import get_object
>>> node = Node(get_object('mkapi.core.base.Type'))
>>> it = get_bases(node)
>>> n, gen = next(it)
>>> n is node
True
>>> [x.object.name for x in gen]
['Inline', 'Base']
>>> for n, gen in it:
... if n.object.name == 'set_html':
... break
>>> [x.object.name for x in gen]
['set_html', 'set_html']
"""
bases = node.obj.mro()[1:-1]
yield node, (get_node(base) for base in bases)
for member in node.members:
name = member.object.name
def gen(name=name):
for base in bases:
if hasattr(base, name):
obj = getattr(base, name)
if hasattr(obj, "__module__"):
yield get_node(getattr(base, name))
yield member, gen()
def test_abc():
node = get_node(C)
assert len(node.members) == 8
node.object.kind == "abstract class"
for member in node.members:
obj = member.object
assert obj.kind.replace(" ", "") == obj.name.replace("_", "")
def split(self, source: str) -> Iterator[str]:
cursor = 0
callback = self.resolve_link_from_base
for index, match in enumerate(MKAPI_PATTERN.finditer(source)):
start, end = match.start(), match.end()
if cursor < start:
markdown = source[cursor:start].strip()
if markdown:
yield self.resolve_link(markdown)
heading, name = match.groups()
level = len(heading)
name, filters = utils.split_filters(name)
if "code" in filters:
code = get_code(name)
self.nodes.append(code)
markdown = code.get_markdown(level)
else:
node = get_node(name)
inherit(node)
postprocess.transform(node, filters)
self.nodes.append(node)
markdown = node.get_markdown(level, callback=callback)
yield node_markdown(index, markdown, filters)
cursor = end
if cursor < len(source):
markdown = source[cursor:].strip()
if markdown:
yield self.resolve_link(markdown)
def test_class():
node = get_node("google_style.ExampleClass")
assert node.object.prefix == "google_style"
assert node.object.name == "ExampleClass"
assert node.object.kind == "class"
assert len(node) == 3
p = node.members[-1]
assert p.object.type.name == "list of int"
assert p.docstring.sections[0].markdown.startswith("Read-write property")
def get_html(node):
from mkapi.core.node import Node, get_node
if not isinstance(node, Node):
node = get_node(node)
markdown = node.get_markdown()
html = converter.convert(markdown)
node.set_html(html)
return node.get_html()
def test_set_html_and_render_bases():
node = get_node("examples.appendix.inherit.Sub")
markdown = node.get_markdown()
sep = "<!-- mkapi:sep -->"
n = len(markdown.split(sep))
html = sep.join(str(x) for x in range(n))
node.set_html(html)
html = node.get_html()
assert "mkapi-section-bases"
def test_short_filter():
node = get_node("mkapi.core.base.Base")
markdown = node.get_markdown()
sep = "<!-- mkapi:sep -->"
n = len(markdown.split(sep))
html = sep.join(str(x) for x in range(n))
node.set_html(html)
h = node.get_html(filters=["short"])
assert '"mkapi-object-body dataclass top"><code class="mkapi-object-name">Base' in h
assert "prefix" not in h
def test_colon_in_docstring():
"""Issue#17"""
class A:
def func(self):
"""this: is not type."""
@property
def prop(self):
"""this: is type."""
def func(self):
"""this: is not type."""
node = get_node(A)
assert node["func"].docstring[""].markdown == "this: is not type."
assert node["prop"].docstring[""].markdown == "is type."
assert node["prop"].object.type.name == "this"
assert not node["prop"].docstring.type.name
node = get_node(func)
assert node.docstring[""].markdown == "this: is not type."
assert not node.object.type
def test_get_markdown():
node = get_node("mkapi.core.base.Base")
markdown = node.get_markdown()
parts = [x.strip() for x in markdown.split("<!-- mkapi:sep -->")]
x = "[mkapi.core.base](!mkapi.core.base).[Base](!mkapi.core.base.Base)"
assert parts[0] == x
assert parts[1] == "Base class."
markdown = node.get_markdown(level=2)
parts = [x.strip() for x in markdown.split("<!-- mkapi:sep -->")]
x = "[mkapi.core.base](!mkapi.core.base).[Base](!mkapi.core.base.Base)"
assert parts[0] == "## " + x
def callback(base):
return "123"
markdown = node.get_markdown(callback=callback)
parts = [x.strip() for x in markdown.split("<!-- mkapi:sep -->")]
assert all(x == "123" for x in parts)
def split(self, source: str) -> Iterator[str]:
cursor = 0
callback = self.resolve_link_from_base
index = 0
for match in MKAPI_PATTERN.finditer(source):
start, end = match.start(), match.end()
if cursor < start:
markdown = source[cursor:start].strip()
if markdown:
yield self.resolve_link(markdown)
cursor = end
heading, name = match.groups()
level = len(heading)
name, filters = utils.split_filters(name)
if not name:
self.filters = filters
continue
filters = utils.update_filters(self.filters, filters)
if "code" in filters:
code = get_code(name)
self.nodes.append(code)
markdown = code.get_markdown(level)
else:
node = get_node(name)
inherit(node)
postprocess.transform(node, filters)
self.nodes.append(node)
markdown = node.get_markdown(level, callback=callback)
if level:
self.headings.append((level, node.object.id))
yield node_markdown(index, markdown, filters)
index += 1
if cursor < len(source):
markdown = source[cursor:].strip()
if markdown:
yield self.resolve_link(markdown)
def test_set_html_and_render():
node = get_node("mkapi.core.base.Base")
markdown = node.get_markdown()
sep = "<!-- mkapi:sep -->"
n = len(markdown.split(sep))
html = sep.join(str(x) for x in range(n))
node.set_html(html)
for k, x in enumerate(node):
assert x.html == str(k)
html = node.get_html()
assert html.startswith('<div class="mkapi-node" id="mkapi.core.base.Base">')
assert 'mkapi-object-kind dataclass top">dataclass</div>' in html
assert '<div class="mkapi-object-body dataclass top">' in html
assert '<code class="mkapi-object-prefix">mkapi.core.base.</code>' in html
assert '<code class="mkapi-object-name">Base</code>' in html
assert '<code class="mkapi-object-parenthesis">(</code>' in html
assert '<code class="mkapi-object-signature">name=''</code>, ' in html
assert '<code class="mkapi-object-signature">markdown=''</code>' in html
assert '<div class="mkapi-section-body">1</div>' in html
assert '<span class="mkapi-item-description">2</span></li>' in html
assert '<code class="mkapi-object-name">set_html</code>' in html
assert '<li><code class="mkapi-item-name">html</code>' in html
def __post_init__(self):
super().__post_init__()
self.node = get_node(self.obj)
def gen(name=name):
for base in bases:
if hasattr(base, name):
obj = getattr(base, name)
if hasattr(obj, "__module__"):
yield get_node(getattr(base, name))
def test_init_docstring():
node = get_node(B)
assert node.docstring.sections[0].markdown == "Init docstring."
assert len(node.members) == 1
def test_class_and_init_docstring():
node = get_node(C)
assert node.docstring.sections[0].markdown == "Class docstring."
assert len(node.members) == 1
def test_package():
node = get_node("mkapi.core")
assert node.object.kind == "package"
def test_without_docstring():
node = get_node(D)
assert not node.docstring
assert len(node.members) == 1
def test_is_member_source_file_index():
node = get_node("mkapi.core.node.Node")
assert node["__getitem__"].sourcefile_index == 1
node = get_node("mkapi.core.base")
assert node["Inline"].sourcefile_index == 0
def test_without_init():
node = get_node(E)
assert node.docstring.sections[0].markdown == "Class docstring."
assert len(node.members) == 1
def test_generator():
node = get_node("google_style.gen")
assert node.object.kind == "generator"
def test_dataclass():
node = get_node("google_style.ExampleDataClass")
assert node.object.prefix == "google_style"
assert node.object.name == "ExampleDataClass"
assert node.object.kind == "dataclass"
def test_repr():
node = get_node("mkapi.core.base")
assert repr(node) == "Node('mkapi.core.base', num_sections=2, num_members=6)"
def test_abc():
node = get_node(C)
node.object.kind == "abstract class"
for member in node.members:
member.object.kind.replace(" ", "_") == member.object.name
def test_get_markdown_bases():
node = get_node("examples.appendix.inherit.Sub")
markdown = node.get_markdown()
parts = [x.strip() for x in markdown.split("<!-- mkapi:sep -->")]
x = "[examples.appendix.inherit.Base]"
assert parts[1].startswith(x)
