我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用docutils.nodes.document()。
def _check_rst_data(self, data): """Returns warnings when the provided data doesn't compile.""" source_path = StringIO() parser = Parser() settings = frontend.OptionParser().get_default_values() settings.tab_width = 4 settings.pep_references = None settings.rfc_references = None reporter = SilentReporter(source_path, settings.report_level, settings.halt_level, stream=settings.warning_stream, debug=settings.debug, encoding=settings.error_encoding, error_handler=settings.error_encoding_error_handler) document = nodes.document(settings, reporter, source=source_path) document.note_source(source_path, -1) try: parser.parse(data, document) except AttributeError: reporter.messages.append((-1, 'Could not finish the parsing.', '', {})) return reporter.messages
def expand_show_urls(self): show_urls = self.document.settings.env.config.latex_show_urls if show_urls is False or show_urls == 'no': return for node in self.document.traverse(nodes.reference): uri = node.get('refuri', '') if uri.startswith(URI_SCHEMES): if uri.startswith('mailto:'): uri = uri[7:] if node.astext() != uri: index = node.parent.index(node) if show_urls == 'footnote': if list(traverse_parent(node, nodes.topic)): # should not expand references in topics pass else: footnote_nodes = self.create_footnote(uri) for i, fn in enumerate(footnote_nodes): node.parent.insert(index + i + 1, fn) self.expanded = True else: # all other true values (b/w compat) textnode = nodes.Text(" (%s)" % uri) node.parent.insert(index + 1, textnode)
def apply(self): pending = self.startnode parent = pending.parent child = pending while parent: # Check for appropriate following siblings: for index in range(parent.index(child) + 1, len(parent)): element = parent[index] if (isinstance(element, nodes.Invisible) or isinstance(element, nodes.system_message)): continue element['classes'] += pending.details['class'] pending.parent.remove(pending) return else: # At end of section or container; apply to sibling child = parent parent = parent.parent error = self.document.reporter.error( 'No suitable element following "%s" directive' % pending.details['directive'], nodes.literal_block(pending.rawsource, pending.rawsource), line=pending.line) pending.replace_self(error)
def astext(self): """Return the final formatted document as a string.""" if not self.header_written: # ensure we get a ".TH" as viewers require it. self.append_header() # filter body for i in xrange(len(self.body)-1, 0, -1): # remove superfluous vertical gaps. if self.body[i] == '.sp\n': if self.body[i - 1][:4] in ('.BI ','.IP '): self.body[i] = '.\n' elif (self.body[i - 1][:3] == '.B ' and self.body[i - 2][:4] == '.TP\n'): self.body[i] = '.\n' elif (self.body[i - 1] == '\n' and not self.possibly_a_roff_command.match(self.body[i - 2]) and (self.body[i - 3][:7] == '.TP\n.B ' or self.body[i - 3][:4] == '\n.B ') ): self.body[i] = '.\n' return ''.join(self.head + self.body + self.foot)
def visit_title(self, node): if isinstance(node.parent, nodes.topic): self.body.append(self.defs['topic-title'][0]) elif isinstance(node.parent, nodes.sidebar): self.body.append(self.defs['sidebar-title'][0]) elif isinstance(node.parent, nodes.admonition): self.body.append('.IP "') elif self.section_level == 0: self._docinfo['title'] = node.astext() # document title for .TH self._docinfo['title_upper'] = node.astext().upper() raise nodes.SkipNode elif self.section_level == 1: self.body.append('.SH %s\n' % self.deunicode(node.astext().upper())) raise nodes.SkipNode else: self.body.append('.SS ')
def stylesheet_call(self, path): """Return code to reference or embed stylesheet file `path`""" if self.settings.embed_stylesheet: try: content = io.FileInput(source_path=path, encoding='utf-8').read() self.settings.record_dependencies.add(path) except IOError, err: msg = u"Cannot embed stylesheet '%s': %s." % ( path, SafeString(err.strerror)) self.document.reporter.error(msg) return '<--- %s --->\n' % msg return self.embedded_stylesheet % content # else link to style file: if self.settings.stylesheet_path: # adapt path relative to output (cf. config.html#stylesheet-path) path = utils.relative_path(self.settings._destination, path) return self.stylesheet_link % self.encode(path)
def depart_document(self, node): self.head_prefix.extend([self.doctype, self.head_prefix_template % {'lang': self.settings.language_code}]) self.html_prolog.append(self.doctype) self.meta.insert(0, self.content_type % self.settings.output_encoding) self.head.insert(0, self.content_type % self.settings.output_encoding) if self.math_header: if self.math_output == 'mathjax': self.head.extend(self.math_header) else: self.stylesheet.extend(self.math_header) # skip content-type meta tag with interpolated charset value: self.html_head.extend(self.head[1:]) self.body_prefix.append(self.starttag(node, 'div', CLASS='document')) self.body_suffix.insert(0, '</div>\n') self.fragment.extend(self.body) # self.fragment is the "naked" body self.html_body.extend(self.body_prefix[1:] + self.body_pre_docinfo + self.docinfo + self.body + self.body_suffix[:-1]) assert not self.context, 'len(context) = %s' % len(self.context)
def translate(self): visitor = self.translator_class(self.document) self.document.walkabout(visitor) # copy parts for part in self.visitor_attributes: setattr(self, part, getattr(visitor, part)) # get template string from file try: template_file = open(self.document.settings.template, 'rb') except IOError: template_file = open(os.path.join(self.default_template_path, self.document.settings.template), 'rb') template = string.Template(unicode(template_file.read(), 'utf-8')) template_file.close() # fill template self.assemble_parts() # create dictionary of parts self.output = template.substitute(self.parts)
def visit_citation_reference(self, node): if self._use_latex_citations: if not self.inside_citation_reference_label: self.out.append(r'\cite{') self.inside_citation_reference_label = 1 else: assert self.body[-1] in (' ', '\n'),\ 'unexpected non-whitespace while in reference label' del self.body[-1] else: href = '' if 'refid' in node: href = node['refid'] elif 'refname' in node: href = self.document.nameids[node['refname']] self.out.append('\\hyperlink{%s}{[' % href)
def depart_literal_block(self, node): self.insert_non_breaking_blanks = False self.insert_newline = False self.literal = False self.verbatim = False self.alltt = False self.out.append(self.context.pop()) self.out.append(self.context.pop()) ## def visit_meta(self, node): ## self.out.append('[visit_meta]\n') # TODO: set keywords for pdf? # But: # The reStructuredText "meta" directive creates a "pending" node, # which contains knowledge that the embedded "meta" node can only # be handled by HTML-compatible writers. The "pending" node is # resolved by the docutils.transforms.components.Filter transform, # which checks that the calling writer supports HTML; if it doesn't, # the "pending" node (and enclosed "meta" node) is removed from the # document. # --- docutils/docs/peps/pep-0258.html#transformer ## def depart_meta(self, node): ## self.out.append('[depart_meta]\n')
def new_reporter(source_path, settings): """ Return a new Reporter object. :Parameters: `source` : string The path to or description of the source text of the document. `settings` : optparse.Values object Runtime settings. """ reporter = Reporter( source_path, settings.report_level, settings.halt_level, stream=settings.warning_stream, debug=settings.debug, encoding=settings.error_encoding, error_handler=settings.error_encoding_error_handler) return reporter
def depart_literal_block(self, node): self.insert_non_breaking_blanks = False self.insert_newline = False self.literal = False self.verbatim = False self.alltt = False self.out.append(self.context.pop()) self.out.append(self.context.pop()) self.duclass_close(node) ## def visit_meta(self, node): ## self.out.append('[visit_meta]\n') # TODO: set keywords for pdf? # But: # The reStructuredText "meta" directive creates a "pending" node, # which contains knowledge that the embedded "meta" node can only # be handled by HTML-compatible writers. The "pending" node is # resolved by the docutils.transforms.components.Filter transform, # which checks that the calling writer supports HTML; if it doesn't, # the "pending" node (and enclosed "meta" node) is removed from the # document. # --- docutils/docs/peps/pep-0258.html#transformer ## def depart_meta(self, node): ## self.out.append('[depart_meta]\n')
def _check_rst_data(self, data): """Returns warnings when the provided data doesn't compile.""" source_path = StringIO() parser = Parser() settings = frontend.OptionParser(components=(Parser,)).get_default_values() settings.tab_width = 4 settings.pep_references = None settings.rfc_references = None reporter = SilentReporter(source_path, settings.report_level, settings.halt_level, stream=settings.warning_stream, debug=settings.debug, encoding=settings.error_encoding, error_handler=settings.error_encoding_error_handler) document = nodes.document(settings, reporter, source=source_path) document.note_source(source_path, -1) try: parser.parse(data, document) except AttributeError as e: reporter.messages.append( (-1, 'Could not finish the parsing: %s.' % e, '', {})) return reporter.messages
def collect_node_menus(self): """Collect the menu entries for each "node" section.""" node_menus = self.node_menus for node in ([self.document] + self.document.traverse(nodes.section)): assert 'node_name' in node and node['node_name'] entries = [s['node_name'] for s in find_subsections(node)] node_menus[node['node_name']] = entries # try to find a suitable "Top" node title = self.document.next_node(nodes.title) top = (title and title.parent) or self.document if not isinstance(top, (nodes.document, nodes.section)): top = self.document if top is not self.document: entries = node_menus[top['node_name']] entries += node_menus['Top'][1:] node_menus['Top'] = entries del node_menus[top['node_name']] top['node_name'] = 'Top' # handle the indices for name, content in self.indices: node_menus[name] = () node_menus['Top'].append(name)
def _check_rst_data(self, data): """Return warnings when the provided data has syntax errors.""" source_path = StringIO() parser = Parser() settings = frontend.OptionParser().get_default_values() settings.tab_width = 4 settings.pep_references = None settings.rfc_references = None reporter = SilentReporter(source_path, settings.report_level, settings.halt_level, stream=settings.warning_stream, debug=settings.debug, encoding=settings.error_encoding, error_handler=settings.error_encoding_error_handler) document = nodes.document(settings, reporter, source=source_path) document.note_source(source_path, -1) try: parser.parse(data, document) except AttributeError: reporter.messages.append((-1, 'Could not finish the parsing.', '', {})) return reporter.messages
def astext(self): """Return the final formatted document as a string.""" if not self.header_written: # ensure we get a ".TH" as viewers require it. self.append_header() # filter body for i in range(len(self.body)-1, 0, -1): # remove superfluous vertical gaps. if self.body[i] == '.sp\n': if self.body[i - 1][:4] in ('.BI ','.IP '): self.body[i] = '.\n' elif (self.body[i - 1][:3] == '.B ' and self.body[i - 2][:4] == '.TP\n'): self.body[i] = '.\n' elif (self.body[i - 1] == '\n' and not self.possibly_a_roff_command.match(self.body[i - 2]) and (self.body[i - 3][:7] == '.TP\n.B ' or self.body[i - 3][:4] == '\n.B ') ): self.body[i] = '.\n' return ''.join(self.head + self.body + self.foot)
def stylesheet_call(self, path): """Return code to reference or embed stylesheet file `path`""" if self.settings.embed_stylesheet: try: content = io.FileInput(source_path=path, encoding='utf-8').read() self.settings.record_dependencies.add(path) except IOError as err: msg = "Cannot embed stylesheet '%s': %s." % ( path, SafeString(err.strerror)) self.document.reporter.error(msg) return '<--- %s --->\n' % msg return self.embedded_stylesheet % content # else link to style file: if self.settings.stylesheet_path: # adapt path relative to output (cf. config.html#stylesheet-path) path = utils.relative_path(self.settings._destination, path) return self.stylesheet_link % self.encode(path)
def translate(self): transform = ShowUrlsTransform(self.document) transform.apply() visitor = self.translator_class(self.document, self.builder) self.document.walkabout(visitor) self.output = visitor.astext() # Helper classes
def __init__(self, document): self.document = document
def apply(self): # replace id_prefix temporarily id_prefix = self.document.settings.id_prefix self.document.settings.id_prefix = 'show_urls' self.expand_show_urls() if self.expanded: self.renumber_footnotes() # restore id_prefix self.document.settings.id_prefix = id_prefix
def create_footnote(self, uri): label = nodes.label('', '#') para = nodes.paragraph() para.append(nodes.reference('', nodes.Text(uri), refuri=uri, nolinkurl=True)) footnote = nodes.footnote(uri, label, para, auto=1) footnote['names'].append('#') self.document.note_autofootnote(footnote) label = nodes.Text('#') footnote_ref = nodes.footnote_reference('[#]_', label, auto=1, refid=footnote['ids'][0]) self.document.note_autofootnote_ref(footnote_ref) footnote.add_backref(footnote_ref['ids'][0]) return [footnote, footnote_ref]
def format_docclass(self, docclass): """ prepends prefix to sphinx document classes """ if docclass in self.docclasses: docclass = 'sphinx' + docclass return docclass
def visit_document(self, node): self.footnotestack.append(self.collect_footnotes(node)) self.curfilestack.append(node.get('docname', '')) if self.first_document == 1: # the first document is all the regular content ... self.first_document = 0 elif self.first_document == 0: # ... and all others are the appendices self.first_document = -1 if 'docname' in node: self.body.append(self.hypertarget(':doc')) # "- 1" because the level is increased before the title is visited self.sectionlevel = self.top_sectionlevel - 1
