You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
121 lines
3.9 KiB
121 lines
3.9 KiB
from breathe.finder.factory import FinderFactory
|
|
from breathe.parser import DoxygenParserFactory
|
|
from breathe.parser import FileIOError, ParserError
|
|
from breathe.project import ProjectInfoFactory, ProjectInfo
|
|
from breathe.renderer import format_parser_error, RenderContext
|
|
from breathe.renderer.filter import Filter, FilterFactory
|
|
from breathe.renderer.mask import MaskFactoryBase
|
|
from breathe.renderer.sphinxrenderer import SphinxRenderer
|
|
from breathe.renderer.target import TargetHandler
|
|
|
|
from sphinx.directives import SphinxDirective
|
|
|
|
from docutils import nodes
|
|
|
|
from typing import Any, Dict, List, Optional, Sequence
|
|
|
|
|
|
class _WarningHandler:
|
|
def __init__(self, state, context: Dict[str, Any]) -> None:
|
|
self.state = state
|
|
self.context = context
|
|
|
|
def warn(
|
|
self,
|
|
raw_text: str,
|
|
*,
|
|
rendered_nodes: Optional[Sequence[nodes.Node]] = None,
|
|
unformatted_suffix: str = ""
|
|
) -> List[nodes.Node]:
|
|
raw_text = self.format(raw_text) + unformatted_suffix
|
|
if rendered_nodes is None:
|
|
rendered_nodes = [nodes.paragraph("", "", nodes.Text(raw_text))]
|
|
return [
|
|
nodes.warning("", *rendered_nodes),
|
|
self.state.document.reporter.warning(raw_text, line=self.context["lineno"]),
|
|
]
|
|
|
|
def format(self, text: str) -> str:
|
|
return text.format(**self.context)
|
|
|
|
|
|
class BaseDirective(SphinxDirective):
|
|
@property
|
|
def directive_args(self) -> list:
|
|
# the order must be the same as in docutils.parsers.rst.Directive.__init__
|
|
return [
|
|
self.name,
|
|
self.arguments,
|
|
self.options,
|
|
self.content,
|
|
self.lineno,
|
|
self.content_offset,
|
|
self.block_text,
|
|
self.state,
|
|
self.state_machine,
|
|
]
|
|
|
|
@property
|
|
def project_info_factory(self) -> ProjectInfoFactory:
|
|
return self.env.temp_data["breathe_project_info_factory"]
|
|
|
|
@property
|
|
def parser_factory(self) -> DoxygenParserFactory:
|
|
return self.env.temp_data["breathe_parser_factory"]
|
|
|
|
@property
|
|
def finder_factory(self) -> FinderFactory:
|
|
return FinderFactory(self.env.app, self.parser_factory)
|
|
|
|
@property
|
|
def filter_factory(self) -> FilterFactory:
|
|
return FilterFactory(self.env.app)
|
|
|
|
@property
|
|
def kind(self) -> str:
|
|
raise NotImplementedError
|
|
|
|
def create_warning(self, project_info: Optional[ProjectInfo], **kwargs) -> _WarningHandler:
|
|
if project_info:
|
|
tail = 'in doxygen xml output for project "{project}" from directory: {path}'.format(
|
|
project=project_info.name(), path=project_info.project_path()
|
|
)
|
|
else:
|
|
tail = ""
|
|
|
|
context = dict(lineno=self.lineno, tail=tail, **kwargs)
|
|
return _WarningHandler(self.state, context)
|
|
|
|
def render(
|
|
self,
|
|
node_stack,
|
|
project_info: ProjectInfo,
|
|
filter_: Filter,
|
|
target_handler: TargetHandler,
|
|
mask_factory: MaskFactoryBase,
|
|
directive_args,
|
|
) -> List[nodes.Node]:
|
|
"Standard render process used by subclasses"
|
|
|
|
try:
|
|
object_renderer = SphinxRenderer(
|
|
self.parser_factory.app,
|
|
project_info,
|
|
node_stack,
|
|
self.state,
|
|
self.state.document,
|
|
target_handler,
|
|
self.parser_factory.create_compound_parser(project_info),
|
|
filter_,
|
|
)
|
|
except ParserError as e:
|
|
return format_parser_error(
|
|
"doxygenclass", e.error, e.filename, self.state, self.lineno, True
|
|
)
|
|
except FileIOError as e:
|
|
return format_parser_error(
|
|
"doxygenclass", e.error, e.filename, self.state, self.lineno, True
|
|
)
|
|
|
|
context = RenderContext(node_stack, mask_factory, directive_args)
|
|
return object_renderer.render(node_stack[0], context)
|
|
|