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