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
