def render(ign, ored: object) -> Tag:
return tags.p(
"hello, ",
tags.transparent(render="test"),
" - ",
tags.transparent(render="test"),
)
def render(ign, ored):
return tags.p(
"hello, ",
tags.transparent(render="test"),
" - ",
tags.transparent(render="test"),
)
def test_serializeMissingRenderFactory(self) -> None:
"""
Test that flattening a tag with a C{render} attribute when no render
factory is available in the context raises an exception.
"""
self.assertFlatteningRaises(tags.transparent(render="test"),
ValueError)
def _handle_name(self, identifier: str) -> Tag:
url = self.linker.resolve_identifier(identifier)
tag: Tag
if url is None:
tag = tags.transparent(identifier)
else:
tag = tags.a(identifier, href=url, class_='code')
return tag
def format(self) -> Iterator[Tag]:
formatted = self.body or self._UNDOCUMENTED
if self.type is not None:
formatted = tags.transparent(formatted, ' (type: ', self.type, ')')
name = self.name
if name is None:
yield tags.td(formatted, colspan="2")
else:
yield tags.td(name, class_="fieldArg")
yield tags.td(formatted)
def link_to(self, identifier: str, label: str) -> Tag:
fullID = self.obj.expandName(identifier)
target = self.obj.system.objForFullName(fullID)
if target is not None:
return taglink(target, self.obj.page_object.url, label)
url = self.look_for_intersphinx(fullID)
if url is not None:
return tags.a(label, href=url) # type: ignore[no-any-return]
return tags.transparent(label) # type: ignore[no-any-return]
def test_serializedAttributeWithTransparentTagWithRenderer(self):
"""
Like L{test_serializedAttributeWithTransparentTag}, but when the
attribute is rendered by a renderer on an element.
"""
class WithRenderer(Element):
def __init__(self, value, loader):
self.value = value
super(WithRenderer, self).__init__(loader)
@renderer
def stuff(self, request, tag):
return self.value
toss = []
self.checkAttributeSanitization(
lambda value: toss.append(value) or
tags.transparent(render="stuff"),
lambda tag: WithRenderer(toss.pop(), TagLoader(tag))
)
def test_serializedAttributeWithTransparentTagWithRenderer(self):
"""
Like L{test_serializedAttributeWithTransparentTag}, but when the
attribute is rendered by a renderer on an element.
"""
class WithRenderer(Element):
def __init__(self, value, loader):
self.value = value
super(WithRenderer, self).__init__(loader)
@renderer
def stuff(self, request, tag):
return self.value
toss = []
self.checkAttributeSanitization(
lambda value: toss.append(value) or
tags.transparent(render="stuff"),
lambda tag: WithRenderer(toss.pop(), TagLoader(tag))
)
def generic_visit(self, node: ast.AST) -> Tag:
src = astor.to_source(node).strip()
ret: Tag = tags.transparent(src)
return ret
def render(ign, ored):
return tags.p('hello, ', tags.transparent(render='test'),
' - ', tags.transparent(render='test'))
def link_to(self, target: str, label: str) -> Tag:
self.resolve_identifier(target)
return tags.transparent(label) # type: ignore[no-any-return]
def link_to(self, target: str, label: str) -> Tag:
return tags.transparent(label) # type: ignore[no-any-return]
def link_to(self, target: str, label: str) -> Tag:
return tags.transparent(label)
def render(ign, ored):
return tags.p("hello, ", tags.transparent(render="test"), " - ", tags.transparent(render="test"))
def render(self, request: Optional[IRequest]) -> Tag:
return tags.transparent(
super().render(request)).fillSlots(**self.slot_map)
def render(ign,ored):
return tags.p(
'hello, ',
tags.transparent(render='test'), ' - ',
tags.transparent(render='test'))
def format(self) -> Tag:
formatted = self.body or self._UNDOCUMENTED
if self.type is not None:
formatted = tags.transparent(formatted, ' (type: ', self.type, ')')
return formatted
def insertRenderer(value: str) -> Flattenable:
toss.append(value)
return tags.transparent(render="stuff")
def link_to(self, target: str, label: str) -> Tag:
self.resolve_identifier(target)
return tags.transparent(label)
