def run(self) -> List[Node]:
name = self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimeError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
finder_filter = self.filter_factory.create_compound_finder_filter(name, self.kind)
# TODO: find a more specific type for the Doxygen nodes
matches = [] # type: List[Any]
finder.filter_(finder_filter, matches)
if len(matches) == 0:
warning = create_warning(project_info, self.state, self.lineno, name=name,
kind=self.kind)
return warning.warn('doxygen{kind}: Cannot find class "{name}" {tail}')
target_handler = create_target_handler(self.options, project_info, self.state.document)
filter_ = self.filter_factory.create_class_filter(name, self.options)
mask_factory = NullMaskFactory()
return self.render(matches[0], project_info, filter_, target_handler, mask_factory,
self.directive_args)
def run(self) -> List[Node]:
try:
namespace, name = self.arguments[0].rsplit("::", 1)
except ValueError:
namespace, name = "", self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(
self.options)
except ProjectError as e:
warning = create_warning(None,
self.state,
self.lineno,
kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimeError as e:
warning = create_warning(None,
self.state,
self.lineno,
kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
finder_filter = self.create_finder_filter(namespace, name)
# TODO: find a more specific type for the Doxygen nodes
matches = [] # type: List[Any]
finder.filter_(finder_filter, matches)
if len(matches) == 0:
display_name = "%s::%s" % (namespace, name) if namespace else name
warning = create_warning(project_info,
self.state,
self.lineno,
kind=self.kind,
display_name=display_name)
return warning.warn(
'doxygen{kind}: Cannot find {kind} "{display_name}" {tail}')
target_handler = create_target_handler(self.options, project_info,
self.state.document)
filter_ = self.filter_factory.create_outline_filter(self.options)
node_stack = matches[0]
mask_factory = NullMaskFactory()
return self.render(node_stack, project_info, filter_, target_handler,
mask_factory, self.directive_args)
def run(self):
try:
namespace, name = self.arguments[0].rsplit("::", 1)
except ValueError:
namespace, name = "", self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimerError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
matcher_stack = self.create_matcher_stack(namespace, name)
try:
data_object = finder.find_one(matcher_stack)
except NoMatchesError as e:
display_name = "%s::%s" % (namespace, name) if namespace else name
warning = create_warning(project_info, self.state, self.lineno, kind=self.kind,
name=display_name)
return warning.warn('doxygen{kind}: Cannot find {kind} "{display_name}" {tail}')
target_handler = self.target_handler_factory.create_target_handler(
self.options, project_info, self.state.document
)
filter_ = self.filter_factory.create_outline_filter(self.options)
return self.render(data_object, project_info, filter_, target_handler)
def run(self):
name = self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimerError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
matcher_stack = self.matcher_factory.create_matcher_stack(
{
"compound": self.matcher_factory.create_name_type_matcher(name, self.kind)
},
"compound"
)
try:
data_object = finder.find_one(matcher_stack)
except NoMatchesError as e:
warning = create_warning(project_info, self.state, self.lineno, name=name,
kind=self.kind)
return warning.warn('doxygen{kind}: Cannot find class "{name}" {tail}')
target_handler = self.target_handler_factory.create_target_handler(
self.options, project_info, self.state.document
)
filter_ = self.filter_factory.create_class_filter(name, self.options)
return self.render(data_object, project_info, filter_, target_handler)
def run(self) -> List[Node]:
# Separate possible arguments (delimited by a "(") from the namespace::name
match = re.match(r"([^(]*)(.*)", self.arguments[0])
assert match is not None # TODO: this is probably not appropriate, for now it fixes typing
namespaced_function, args = match.group(1), match.group(2)
# Split the namespace and the function name
try:
(namespace, function_name) = namespaced_function.rsplit("::", 1)
except ValueError:
(namespace, function_name) = "", namespaced_function
try:
project_info = self.project_info_factory.create_project_info(
self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimeError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
# Extract arguments from the function name.
args = self.parse_args(args)
finder_filter = self.filter_factory.create_function_finder_filter(
namespace, function_name)
# TODO: find a more specific type for the Doxygen nodes
matches = [] # type: List[Any]
finder.filter_(finder_filter, matches)
# Create it ahead of time as it is cheap and it is ugly to declare it for both exception
# clauses below
warning = create_warning(project_info,
self.state,
self.lineno,
namespace='%s::' %
namespace if namespace else '',
function=function_name,
args=', '.join(args))
try:
node_stack = self.resolve_function(matches, args, project_info)
except NoMatchingFunctionError:
return warning.warn(
'doxygenfunction: Cannot find function "{namespace}{function}" '
'{tail}')
except UnableToResolveFunctionError as error:
message = 'doxygenfunction: Unable to resolve multiple matches for function ' \
'"{namespace}{function}" with arguments ({args}) {tail}.\n' \
'Potential matches:\n'
# We want to create a string for the console output and a set of docutils nodes
# for rendering into the final output. We handle the final output as a literal string
# with a txt based list of the options.
literal_text = ''
# TODO: We're cheating here with the set() as signatures has repeating entries for some
# reason (failures in the matcher_stack code) so we consolidate them by shoving them in
# a set to remove duplicates. Should be fixed!
signatures = ''
for i, entry in enumerate(sorted(set(error.signatures))):
if i:
literal_text += '\n'
# Replace new lines with a new line & enough spacing to reach the appropriate
# alignment for our simple plain text list
literal_text += '- %s' % entry.replace('\n', '\n ')
signatures += ' - %s\n' % entry.replace('\n', '\n ')
block = nodes.literal_block('', '', nodes.Text(literal_text))
formatted_message = warning.format(message)
warning_nodes = [
nodes.paragraph("", "", nodes.Text(formatted_message)), block
]
result = warning.warn(message,
rendered_nodes=warning_nodes,
unformatted_suffix=signatures)
return result
target_handler = create_target_handler(self.options, project_info,
self.state.document)
filter_ = self.filter_factory.create_outline_filter(self.options)
return self.render(node_stack, project_info, filter_, target_handler,
NullMaskFactory(), self.directive_args)
def run(self) -> List[Node]:
name = self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(
self.options)
except ProjectError as e:
warning = create_warning(None,
self.state,
self.lineno,
kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimeError as e:
warning = create_warning(None,
self.state,
self.lineno,
kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
finder_filter = self.filter_factory.create_finder_filter(
self.kind, name)
# TODO: find a more specific type for the Doxygen nodes
matches = [] # type: List[Any]
finder.filter_(finder_filter, matches)
# It shouldn't be possible to have too many matches as namespaces & groups in their nature
# are merged together if there are multiple declarations, so we only check for no matches
if not matches:
warning = create_warning(project_info,
self.state,
self.lineno,
name=name,
kind=self.kind)
return warning.warn(
'doxygen{kind}: Cannot find namespace "{name}" {tail}')
if 'content-only' in self.options:
# Unpack the single entry in the matches list
(node_stack, ) = matches
filter_ = self.filter_factory.create_content_filter(
self.kind, self.options)
# Having found the compound node for the namespace or group in the index we want to grab
# the contents of it which match the filter
contents_finder = self.finder_factory.create_finder_from_root(
node_stack[0], project_info)
# TODO: find a more specific type for the Doxygen nodes
contents = [] # type: List[Any]
contents_finder.filter_(filter_, contents)
# Replaces matches with our new starting points
matches = contents
target_handler = create_target_handler(self.options, project_info,
self.state.document)
filter_ = self.filter_factory.create_render_filter(
self.kind, self.options)
node_list = []
for node_stack in matches:
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_)
mask_factory = NullMaskFactory()
context = RenderContext(node_stack, mask_factory,
self.directive_args)
node_list.extend(
object_renderer.render(context.node_stack[0], context))
return node_list
def run(self) -> List[Node]:
# Separate possible arguments (delimited by a "(") from the namespace::name
match = re.match(r"([^(]*)(.*)", self.arguments[0])
assert match is not None # TODO: this is probably not appropriate, for now it fixes typing
namespaced_function, args = match.group(1), match.group(2)
# Split the namespace and the function name
try:
(namespace, function_name) = namespaced_function.rsplit("::", 1)
except ValueError:
(namespace, function_name) = "", namespaced_function
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimeError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
# Extract arguments from the function name.
args = self._parse_args(args)
finder_filter = self.filter_factory.create_function_and_all_friend_finder_filter(
namespace, function_name)
# TODO: find a more specific type for the Doxygen nodes
matchesAll = [] # type: List[Any]
finder.filter_(finder_filter, matchesAll)
matches = []
for m in matchesAll:
# only take functions and friend functions
# ignore friend classes
node = m[0]
if node.kind == 'friend' and not node.argsstring:
continue
matches.append(m)
# Create it ahead of time as it is cheap and it is ugly to declare it for both exception
# clauses below
warning = create_warning(
project_info,
self.state,
self.lineno,
namespace='%s::' % namespace if namespace else '',
function=function_name,
args=str(args)
)
try:
node_stack = self._resolve_function(matches, args, project_info)
except NoMatchingFunctionError:
return warning.warn('doxygenfunction: Cannot find function "{namespace}{function}" '
'{tail}')
except UnableToResolveFunctionError as error:
message = 'doxygenfunction: Unable to resolve function ' \
'"{namespace}{function}" with arguments {args} {tail}.\n' \
'Potential matches:\n'
text = ''
for i, entry in enumerate(sorted(error.signatures)):
text += '- %s\n' % entry
block = nodes.literal_block('', '', nodes.Text(text))
formatted_message = warning.format(message)
warning_nodes = [
nodes.paragraph("", "", nodes.Text(formatted_message)),
block
]
result = warning.warn(message, rendered_nodes=warning_nodes,
unformatted_suffix=text)
return result
target_handler = create_target_handler(self.options, project_info, self.state.document)
filter_ = self.filter_factory.create_outline_filter(self.options)
return self.render(node_stack, project_info, filter_, target_handler, NullMaskFactory(),
self.directive_args)
def run(self):
# Separate possible arguments (delimited by a "(") from the namespace::name
match = re.match(r"([^(]*)(.*)", self.arguments[0])
namespaced_function, args = match.group(1), match.group(2)
# Split the namespace and the function name
try:
(namespace, function_name) = namespaced_function.rsplit("::", 1)
except ValueError:
(namespace, function_name) = "", namespaced_function
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimerError as e:
warning = create_warning(None, self.state, self.lineno)
return warning.warn('doxygenfunction: %s' % e)
# Extract arguments from the function name.
args = self.parse_args(args)
matcher_stack = self.matcher_factory.create_matcher_stack(
{
"compound": self.matcher_factory.create_name_matcher(namespace),
"member": self.matcher_factory.create_name_type_matcher(function_name, "function")
},
"member"
)
results = finder.find(matcher_stack)
# Create it ahead of time as it is cheap and it is ugly to declare it for both exception
# clauses below
warning = create_warning(
project_info,
self.state,
self.lineno,
namespace='%s::' % namespace if namespace else '',
function=function_name,
args=', '.join(args)
)
try:
data_object = self.resolve_function(results, args)
except NoMatchingFunctionError:
return warning.warn('doxygenfunction: Cannot find function "{namespace}{function}" '
'{tail}')
except UnableToResolveFunctionError:
return warning.warn('doxygenfunction: Unable to resolve multiple matches for function '
'"{namespace}{function}" with arguments ({args}) {tail}')
target_handler = self.target_handler_factory.create_target_handler(
self.options, project_info, self.state.document
)
filter_ = self.filter_factory.create_outline_filter(self.options)
return self.render(data_object, project_info, filter_, target_handler)
def run(self):
name = self.arguments[0]
try:
project_info = self.project_info_factory.create_project_info(self.options)
except ProjectError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
try:
finder = self.finder_factory.create_finder(project_info)
except MTimerError as e:
warning = create_warning(None, self.state, self.lineno, kind=self.kind)
return warning.warn('doxygen{kind}: %s' % e)
finder_filter = self.filter_factory.create_finder_filter(self.kind, name)
matches = []
finder.filter_(finder_filter, matches)
# It shouldn't be possible to have too many matches as namespaces & groups in their nature
# are merged together if there are multiple declarations, so we only check for no matches
if not matches:
warning = create_warning(project_info, self.state, self.lineno, name=name,
kind=self.kind)
return warning.warn('doxygen{kind}: Cannot find namespace "{name}" {tail}')
if 'content-only' in self.options:
# Unpack the single entry in the matches list
(data_object,) = matches
filter_ = self.filter_factory.create_content_filter(self.kind, self.options)
# Having found the compound node for the namespace or group in the index we want to grab
# the contents of it which match the filter
contents_finder = self.finder_factory.create_finder_from_root(data_object, project_info)
contents = []
contents_finder.filter_(filter_, contents)
# Replaces matches with our new starting points
matches = contents
target_handler = self.target_handler_factory.create_target_handler(
self.options, project_info, self.state.document
)
filter_ = self.filter_factory.create_render_filter(self.kind, self.options)
renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator(
project_info,
self.state.document,
self.options,
target_handler
)
node_list = []
for data_object in matches:
renderer_factory = renderer_factory_creator.create_factory(
data_object,
self.state,
self.state.document,
filter_,
target_handler,
)
context = RenderContext([data_object, self.root_data_object])
object_renderer = renderer_factory.create_renderer(context)
node_list.extend(object_renderer.render())
return node_list
