def render(self, context, mimetype, content, filename=None, rev=None): # Minimize visual impact of errors from docutils.writers import html4css1 class TracHTMLTranslator(html4css1.HTMLTranslator): """Specialized translator with unobtrusive error reporting""" def visit_system_message(self, node): paragraph = node.children.pop(0) message = escape(paragraph.astext()) if paragraph else '' backrefs = node['backrefs'] if backrefs: span = ('<span class="system-message">%s</span>' % (''.join('<a href="#%s" title="%s">?</a>' % (backref, message) for backref in backrefs))) else: span = ('<span class="system-message" title="%s">?</span>' % message) self.body.append(span) def depart_system_message(self, node): pass writer = html4css1.Writer() writer.translator_class = TracHTMLTranslator inliner = rst.states.Inliner() inliner.trac = (self.env, context) parser = rst.Parser(inliner=inliner) content = content_to_unicode(self.env, content, mimetype) parts = publish_parts(content, writer=writer, parser=parser, settings_overrides={'halt_level': 6, 'warning_stream': False, 'file_insertion_enabled': 0, 'raw_enabled': 0, 'warning_stream': False}) return parts['html_body']
def parse_text(text): parser = rst.Parser() settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() document = utils.new_document(text, settings) parser.parse(text, document) return document.children
def get_releases(self): full_path = os.path.join(ROOT_DIR, "CHANGELOG.rst") with open(full_path) as f: changelog = f.read() with mock.patch.object(sys, "stderr"): parser = rst.Parser() settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() document = utils.new_document(changelog, settings) parser.parse(changelog, document) changelog = document.children if len(changelog) != 1: self.fail("'%s' file should contain one global section " "with subsections for each release." % full_path) releases = [] for node in changelog[0].children: if not isinstance(node, nodes.section): continue title = node.astext().split("\n", 1)[0] result = self.RE_RELEASE.match(title) if result: releases.append(result.groupdict()["version"]) if not releases: self.fail("'%s' doesn't mention any releases..." % full_path) return releases
class ParserTestCase(CustomTestCase): """ Output checker for the parser. Should probably be called ParserOutputChecker, but I can deal with that later when/if someone comes up with a category of parser test cases that have nothing to do with the input and output of the parser. """ parser = rst.Parser() """Parser shared by all ParserTestCases.""" option_parser = frontend.OptionParser(components=(parser, )) settings = option_parser.get_default_values() settings.report_level = 5 settings.halt_level = 5 settings.debug = package_unittest.debug def test_parser(self): if self.run_in_debugger: pdb.set_trace() document = utils.new_document('test data', self.settings) self.parser.parse(self.input, document) output = document.pformat() self.compare_output(self.input, output, self.expected)
def _extract_toctree(cell): """Extract links from Markdown cell and create toctree.""" lines = ['.. toctree::'] options = cell.metadata['nbsphinx-toctree'] try: for option, value in options.items(): if value is True: lines.append(':{}:'.format(option)) elif value is False: pass else: lines.append(':{}: {}'.format(option, value)) except AttributeError: raise ValueError( 'invalid nbsphinx-toctree option: {!r}'.format(options)) text = nbconvert.filters.markdown2rst(cell.source) settings = docutils.frontend.OptionParser( components=(rst.Parser, )).get_default_values() toctree_node = docutils.utils.new_document('extract_toctree', settings) parser = rst.Parser() parser.parse(text, toctree_node) if 'caption' not in options: for sec in toctree_node.traverse(docutils.nodes.section): assert sec.children assert isinstance(sec.children[0], docutils.nodes.title) title = sec.children[0].astext() lines.append(':caption: ' + title) break lines.append('') # empty line for ref in toctree_node.traverse(docutils.nodes.reference): lines.append(ref.astext().replace('\n', '') + ' <' + unquote(ref.get('refuri')) + '>') return '\n '.join(lines)
def render(self, context, mimetype, content, filename=None, rev=None): # Minimize visual impact of errors class TracHTMLTranslator(html4css1.HTMLTranslator): """Specialized translator with unobtrusive error reporting and some extra security features""" def __init__(self, *args, **kwargs): self._render_unsafe_content = wikisys.render_unsafe_content self._safe_schemes = set(wikisys.safe_schemes) html4css1.HTMLTranslator.__init__(self, *args, **kwargs) def visit_system_message(self, node): paragraph = node.children.pop(0) message = escape(paragraph.astext()) if paragraph else '' backrefs = node['backrefs'] if backrefs: span = ('<span class="system-message">%s</span>' % (''.join('<a href="#%s" title="%s">?</a>' % (backref, message) for backref in backrefs))) else: span = ('<span class="system-message" title="%s">?</span>' % message) self.body.append(span) def depart_system_message(self, node): pass def visit_image(self, node): html4css1.HTMLTranslator.visit_image(self, node) uri = node.attributes.get('uri') if not wikisys.is_safe_origin(uri, context.req): self.body[-1] = self.body[-1].replace( '<img ', '<img crossorigin="anonymous" ') def visit_reference(self, node): if self._is_safe_uri(node.get('refuri')): html4css1.HTMLTranslator.visit_reference(self, node) def depart_reference(self, node): if self._is_safe_uri(node.get('refuri')): html4css1.HTMLTranslator.depart_reference(self, node) def _is_safe_uri(self, uri): if self._render_unsafe_content or not uri: return True else: pos = uri.find(':') return pos < 0 or uri[0:pos] in self._safe_schemes wikisys = WikiSystem(self.env) writer = html4css1.Writer() writer.translator_class = TracHTMLTranslator inliner = rst.states.Inliner() inliner.trac = (self.env, context) parser = rst.Parser(inliner=inliner) content = content_to_unicode(self.env, content, mimetype) # The default Reader is explicitly passed as a workaround for #11248 parts = publish_parts(content, writer=writer, parser=parser, reader=standalone.Reader(parser), settings_overrides={'halt_level': 6, 'file_insertion_enabled': 0, 'raw_enabled': 0, 'warning_stream': False}) return parts['html_body']
def setup_module(): global app, settings, parser app = TestApp(cleanenv=True) optparser = frontend.OptionParser(components=(rst.Parser, HTMLWriter, LaTeXWriter)) settings = optparser.get_default_values() settings.env = app.builder.env parser = rst.Parser()
def setup_module(): global settings, parser with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) # DeprecationWarning: The frontend.OptionParser class will be replaced # by a subclass of argparse.ArgumentParser in Docutils 0.21 or later. optparser = frontend.OptionParser(components=(rst.Parser, )) settings = optparser.get_default_values() parser = rst.Parser()
def parse_string(self, file_name: str, text: str) -> docutils.nodes.document: self.current_file = file_name doc = new_document(str(self.current_file), self.settings) parser = rst.Parser() parser.parse(text, doc) doc.reporter = IgnoreMessagesReporter("", self.settings.report_level, self.settings.halt_level) self._pre_process(doc, text) return doc
def load_params(name): p = rst.Parser() doc = new_document( name ) doc.settings.tab_width=4 doc.settings.pep_references =1 doc.settings.rfc_references =1 p.parse( open(name +'.rst').read(),doc ) params = [ {'name': i[0].rawsource, 'note':[ j.rawsource for j in i[1][0]] } for i in doc[0] ] return params
def from_rst(cls, text): self = cls() parser = rst.Parser() settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() document = utils.new_document(text, settings) parser.parse(text, document) self._children.extend(self._parse_elements(document.children)) return self
def setup_module(): global app, settings, parser texescape.init() # otherwise done by the latex builder app = TestApp() optparser = frontend.OptionParser(components=(rst.Parser, HTMLWriter, LaTeXWriter)) settings = optparser.get_default_values() settings.env = app.builder.env settings.env.patch_lookup_functions() settings.env.temp_data['docname'] = 'dummy' parser = rst.Parser()
class PEPParserTestCase(ParserTestCase): """PEP-specific parser test case.""" parser = rst.Parser(rfc2822=1, inliner=pep.Inliner()) """Parser shared by all PEPParserTestCases.""" option_parser = frontend.OptionParser(components=(parser, pep.Reader)) settings = option_parser.get_default_values() settings.report_level = 5 settings.halt_level = 5 settings.debug = package_unittest.debug
def parse_text(text): parser = rst.Parser() settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() document = utils.new_document(text, settings) try: parser.parse(text, document) except Exception as e: print(f"WARNING: {e}") return [] return document.children
def validate_rest(text): components = (docutils.parsers.rst.Parser, ) settings = docutils.frontend.OptionParser(components).get_default_values() document = docutils.utils.new_document('', settings) rst.Parser().parse(text, document) try: document.walk(ReSTValidatorVisitor(document)) return False, None except InvalidReSTError as e: return e.args[0], e.args[1]
def setup_parse(self, input_string): super().setup_parse(input_string) self.rst_parser = rst.Parser() defaults = { 'file_insertion_enabled': False, 'debug': False, 'report_level': 4, } settings = OptionParser(components=(self.rst_parser, SettingsSpec()), defaults=defaults).get_default_values() self.rst_document = utils.new_document('<.rst>', settings)
def render(self, context, mimetype, content, filename=None, rev=None): inliner = rst.states.Inliner() inliner.trac = (self.env, context) parser = rst.Parser(inliner=inliner) content = content_to_unicode(self.env, content, mimetype) parts = publish_parts(content, writer_name='html', parser=parser, settings_overrides={ 'halt_level': 6, 'file_insertion_enabled': 0, 'raw_enabled': 0 }) return parts['html_body']
def parse_restructuredtext(self, filename): self.firsttitle = "" self.current_tags = "" self.command_tags_ref = {} self.filevars = {} self.titles = [] self.cheatlist = [] self.new_cheat() parser = rst.Parser() with open(filename, "r") as fd: text = fd.read() settings = OptionParser( components=(rst.Parser, )).get_default_values() document = new_document(filename + ".tmp", settings) parser.parse(text, document) visitor = ArsenalRstVisitor(document, self) document.walk(visitor) # add the last command if done if self.current_cheat.is_done(): self.end_cheat() elif self.current_cheat.command == "" and self.current_cheat.description != "": self.current_cheat.command = self.current_cheat.description.replace( '\n', ';\\\n') self.current_cheat.description = "" self.end_cheat() # File parsing done # set constants variables for varname, varval in self.filevars.items(): for cheat in self.cheatlist: cheat.variables[varname] = varval # add all file's cheats for cheat in self.cheatlist: cheat.filename = filename cheat.printable_command = cheat.command.replace('\\\n', '') self.cheatsheets[cheat.str_title + cheat.name] = cheat
def parse_restructured(name, sdoc): """Convert from the cleaned-up docstring to docutils. Parameters ---------- name : str The symbol name. sdoc : The docstring in restructured text. Returns ------- retval The document in restructured text format. """ set_parent(name) default_settings = OptionParser( components=(rst.Parser, )).get_default_values() document = new_document(name, default_settings) parser = rst.Parser() parser.parse(str(sdoc), document) return document
def _get_doctree(text): document = create_new_document() rst.Parser().parse(text, document) _transform(document) return document
def __init__(self, parser=None, parser_name=None): """`parser` should be ``None``.""" if parser is None: parser = rst.Parser(rfc2822=1, inliner=self.inliner_class()) standalone.Reader.__init__(self, parser, '')
def setup_module(): global settings, parser optparser = frontend.OptionParser(components=(rst.Parser, )) settings = optparser.get_default_values() parser = rst.Parser()
def __init__(self, **kwargs): self._trigger_load = Clock.create_trigger(self._load_from_text, -1) self._parser = rst.Parser() self._settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() super(RstDocument, self).__init__(**kwargs)
def __init__(self): self.rst_parser = rst.Parser()
def render(app, doctree, fromdocname): for node in doctree.traverse(YaqlDocNode): new_doc = utils.new_document('YAQL', doctree.settings) content = generate_doc(node.source) rst.Parser().parse(content, new_doc) node.replace_self(new_doc.children)
def execute(hdf, text, env): def do_trac(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): return trac(env, name, arguments, options, content, lineno, content_offset, block_text, state, state_machine) def do_trac_role(name, rawtext, text, lineno, inliner, options={}, content=[]): return trac_role(env, name, rawtext, text, lineno, inliner, options, content) # 1 required arg, 1 optional arg, spaces allowed in last arg do_trac.arguments = (1,1,1) do_trac.options = None do_trac.content = None rst.directives.register_directive('trac', do_trac) rst.roles.register_local_role('trac', do_trac_role) # The code_block could is taken from the leo plugin rst2 def code_block(name,arguments,options,content,lineno,content_offset,block_text,state,state_machine): """Create a code-block directive for docutils. Usage: .. code-block:: language If the language can be syntax highlighted it will be.""" from trac.WikiFormatter import Formatter language = arguments[0] code_processor = None if Formatter.builtin_processors.has_key(language): code_processor = Formatter.builtin_processors[language] else: code_processor = Formatter.builtin_processors['default'] html = code_processor(hdf, '\n'.join(content), env) raw = nodes.raw('',html, format='html') #(self, rawsource='', text='', *children, **attributes): return [raw] # These are documented at http://docutils.sourceforge.net/spec/howto/rst-directives.html. code_block.arguments = ( 1, # Number of required arguments. 0, # Number of optional arguments. 0) # True if final argument may contain whitespace. # A mapping from option name to conversion function. code_block.options = { 'language' : rst.directives.unchanged # Return the text argument, unchanged } code_block.content = 1 # True if content is allowed. # Register the directive with docutils. rst.directives.register_directive('code-block',code_block) _inliner = rst.states.Inliner() _parser = rst.Parser(inliner = _inliner) html = publish_string(text, writer_name = 'html', parser = _parser, settings_overrides = {'halt_level':6}) return html[html.find('<body>')+6:html.find('</body>')].strip()
def parse_rst(text: str) -> nodes.document: settings = frontend.OptionParser((rst.Parser, )).get_default_values() document = utils.new_document('<rst-doc>', settings=settings) rst.Parser().parse(text, document) return document
def parse_rst(full_path: Path) -> nodes.document: text = full_path.read_text(encoding="utf-8") settings = frontend.OptionParser((rst.Parser, )).get_default_values() document = utils.new_document(f'<{full_path}>', settings=settings) rst.Parser(rfc2822=True).parse(text, document) return document
self.current_function = None self.examples = [] def visit_definition_list_item(self, node): if self.current_function: if is_example(node): ev = ExampleVisitor(self.document) node.walkabout(ev) self.examples += ev.examples import sys source = sys.stdin.read() parser = rst.Parser() opts = docutils.frontend.OptionParser( components=(docutils.parsers.rst.Parser, )) settings = opts.get_default_values() warning_stream = io.StringIO("") settings.update({'warning_stream': warning_stream}, opts) document = docutils.utils.new_document(source, settings) res = parser.parse(source, document) warnings = warning_stream.getvalue() """ lines = warnings.split('\n') bads = [l for l in lines if len(l) and l[0]==':'] if bads: print("Warnings:") print('\n'.join(bads)) """
def _get_doctree(text): settings = frontend.OptionParser( components=(rst.Parser, )).get_default_values() document = new_document('dummy.txt', settings) rst.Parser().parse(text, document) return document