def pybabel(): # This registers our minimal robot translation extractor import babel.messages.extract babel.messages.extract.DEFAULT_MAPPING.extend( [ ("**.rst", "plone.app.robotframework.pybabel:extract_robot"), ("**.robot", "plone.app.robotframework.pybabel:extract_robot"), ] ) # This code hides warnings for known Sphinx-only-directives when # executing pybot against Sphinx-documentation: from docutils.parsers.rst.directives import register_directive from docutils.parsers.rst.roles import register_local_role dummy_directive = lambda *args: [] options = ("maxdepth", "creates", "numbered", "hidden") setattr(dummy_directive, "content", True) setattr(dummy_directive, "options", dict([(opt, str) for opt in options])) register_directive("toctree", dummy_directive) register_directive("robotframework", dummy_directive) register_local_role("ref", dummy_directive) from babel.messages.frontend import main main()
def setup(app): app.add_config_value('autonumber_by_chapter', True, False) roles.register_local_role('autonumber', autonumber_role) app.add_node(autonumber) app.add_node(autonumber_ref) app.add_role('autonumref', XRefRole(nodeclass=autonumber_ref)) app.connect('doctree-resolved', doctree_resolved)
def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None): additional_xref_types[directivename] = (rolename, indextemplate, None) directives.register_directive(directivename, directive_dwim(Target)) roles.register_local_role(rolename, xfileref_role) if ref_nodeclass is not None: innernodetypes[rolename] = ref_nodeclass
def add_role(self, name, role): self.debug('[app] adding role: %r', (name, role)) if name in roles._roles: self.warn('while setting up extension %s: role %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], name)) roles.register_local_role(name, role)
def _override_command_role(): from docutils.parsers.rst import roles from docutils import nodes rolename = 'cmd' generic = roles.GenericRole(rolename, nodes.literal) role = roles.CustomRole(rolename, generic, {'classes': [rolename]}) roles.register_local_role(rolename, role)
def setup(app): roles.register_local_role('xml', xml_role) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }
def add_literal_role(rolename): from docutils.parsers.rst import roles from docutils import nodes nodeclass = nodes.literal generic = roles.GenericRole(rolename, nodeclass) role = roles.CustomRole(rolename, generic, {'classes': [rolename]}) roles.register_local_role(rolename, role)
def set_site(self, site): """Set Nikola site.""" self.site = site roles.register_local_role('issue', IssueRole) global ISSUE_URL IssueRole.site = site return super(Plugin, self).set_site(site)
def format(self, decl): def ref(name, rawtext, text, lineno, inliner, options={}, content=[]): name = utils.unescape(text) uri = self.lookup_symbol(name, decl.name[:-1]) if uri: node = reference(rawtext, name, refid=uri, **options) else: node = emphasis(rawtext, name) return [node], [] roles.register_local_role('', ref) errstream = StringIO.StringIO() settings = {} settings['halt_level'] = 2 settings['warning_stream'] = errstream settings['traceback'] = True doc = decl.annotations.get('doc') if doc: try: doctree = publish_doctree(doc.text, settings_overrides=settings) # Extract the summary. extractor = SummaryExtractor(doctree) doctree.walk(extractor) reader = docutils.readers.doctree.Reader(parser_name='null') # Publish the summary. if extractor.summary: pub = Publisher(reader, None, None, source=io.DocTreeInput(extractor.summary), destination_class=io.StringOutput) pub.writer = Writer() pub.process_programmatic_settings(None, None, None) dummy = pub.publish(enable_exit_status=None) summary = pub.writer.output else: summary = '' # Publish the details. pub = Publisher(reader, None, None, source=io.DocTreeInput(doctree), destination_class=io.StringOutput) pub.writer = Writer() pub.process_programmatic_settings(None, None, None) dummy = pub.publish(enable_exit_status=None) details = pub.writer.output return Struct(summary, details) except docutils.utils.SystemMessage, error: xx, line, message = str(error).split(':', 2) print 'In DocString attached to declaration at %s:%d:'%(decl.file.name, decl.line) print ' line %s:%s'%(line, message)
def setup(app): from docutils.parsers.rst import roles roles.register_local_role('eval', eval_role) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }
def register_role(name, role): # type: (str, RoleFunction) -> None """Register a role to docutils. This modifies global state of docutils. So it is better to use this inside ``docutils_namespace()`` to prevent side-effects. """ roles.register_local_role(name, role)
def setup(app): # register our handler to overrride sphinx.roles.emph_literal_role from docutils.parsers.rst import roles import sphinx.roles as mod names = [key for key, value in mod.specific_docroles.items() if value is mod.emph_literal_role] for name in names: roles.register_local_role(name, emph_literal_role)
def setup(app): app.add_node(IconNode, html=(IconNode.visit_icon, IconNode.depart_icon)) roles.register_local_role('icon', icon_role) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }
def add_role(self, name, role): self.debug("[app] adding role: %r", (name, role)) if name in roles._roles: self.warn( "while setting up extension %s: role %r is " "already registered, it will be overridden" % (self._setting_up_extension, name) ) roles.register_local_role(name, role)
def setup(app): roles.register_local_role( 'symbol', SymbolRole(warn_dangling=True, innernodeclass=literal)) return { 'version': '1.0', 'parallel_read_safe': True, 'parallel_write_safe': True, }
def setup(_): from docutils.parsers.rst import roles roles.register_local_role('djangosetting', django_setting_role) return { 'version': 'builtin', 'parallel_read_safe': True, 'parallel_write_safe': True, }
def add_description_unit(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None): additional_xref_types[directivename] = (rolename, indextemplate, parse_node) directives.register_directive(directivename, directive_dwim(GenericDesc)) roles.register_local_role(rolename, xfileref_role) if ref_nodeclass is not None: innernodetypes[rolename] = ref_nodeclass
def _define_role(name): base_role = roles.generic_custom_role role = roles.CustomRole(name, base_role, {'class': [name]}, []) roles.register_local_role(name, role)
def add_role(self, name, role): # type: (unicode, Any) -> None logger.debug('[app] adding role: %r', (name, role)) if name in roles._roles: logger.warning(__('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_role') roles.register_local_role(name, role)
def setup(app): from docutils.parsers.rst import roles for rolename, nodeclass in iteritems(generic_docroles): generic = roles.GenericRole(rolename, nodeclass) role = roles.CustomRole(rolename, generic, {'classes': [rolename]}) roles.register_local_role(rolename, role) for rolename, func in iteritems(specific_docroles): roles.register_local_role(rolename, func)
def add_generic_role(self, name, nodeclass): # don't use roles.register_generic_role because it uses # register_canonical_role self.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: self.warn('while setting up extension %s: role %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], name)) role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role)
def setup(app): from docutils.parsers.rst import roles setup_man_pages(app) app.add_builder(EPUBHelpBuilder) app.add_builder(LaTeXHelpBuilder) app.connect('source-read', source_read_handler) app.connect('doctree-read', substitute) app.connect('builder-inited', generate_docs) app.connect('html-page-context', add_html_context) app.connect('build-finished', finished) roles.register_local_role('guilabel', guilabel_role)
def add_generic_role(self, name, nodeclass): # type: (unicode, Any) -> None # don't use roles.register_generic_role because it uses # register_canonical_role logger.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: logger.warning(__('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role)
def setup(app): # ============================================================================== app.add_directive("flat-table", FlatTable) roles.register_local_role('cspan', c_span) roles.register_local_role('rspan', r_span) return dict( version = __version__, parallel_read_safe = True, parallel_write_safe = True )
def run(self): """Dynamically create and register a custom interpreted text role.""" if self.content_offset > self.lineno or not self.content: raise self.error('"%s" directive requires arguments on the first ' 'line.' % self.name) args = self.content[0] match = self.argument_pattern.match(args) if not match: raise self.error('"%s" directive arguments not valid role names: ' '"%s".' % (self.name, args)) new_role_name = match.group(1) base_role_name = match.group(3) messages = [] if base_role_name: base_role, messages = roles.role( base_role_name, self.state_machine.language, self.lineno, self.state.reporter) if base_role is None: error = self.state.reporter.error( 'Unknown interpreted text role "%s".' % base_role_name, nodes.literal_block(self.block_text, self.block_text), line=self.lineno) return messages + [error] else: base_role = roles.generic_custom_role assert not hasattr(base_role, 'arguments'), ( 'Supplemental directive arguments for "%s" directive not ' 'supported (specified by "%r" role).' % (self.name, base_role)) try: converted_role = convert_directive_function(base_role) (arguments, options, content, content_offset) = ( self.state.parse_directive_block( self.content[1:], self.content_offset, converted_role, option_presets={})) except states.MarkupError as detail: error = self.state_machine.reporter.error( 'Error in "%s" directive:\n%s.' % (self.name, detail), nodes.literal_block(self.block_text, self.block_text), line=self.lineno) return messages + [error] if 'class' not in options: try: options['class'] = directives.class_option(new_role_name) except ValueError as detail: error = self.state_machine.reporter.error( 'Invalid argument for "%s" directive:\n%s.' % (self.name, SafeString(detail)), nodes.literal_block( self.block_text, self.block_text), line=self.lineno) return messages + [error] role = roles.CustomRole(new_role_name, base_role, options, content) roles.register_local_role(new_role_name, role) return messages
def gammapy_sphinx_ext_activate(): if HAS_GP_EXTRA: log.info('*** Found GAMMAPY_EXTRA = {}'.format(gammapy_extra_path)) log.info('*** Nice!') else: log.info('*** gammapy-extra *not* found.') log.info('*** Set the GAMMAPY_EXTRA environment variable!') log.info('*** Docs build will be incomplete.') log.info('*** Notebook links will not be verified.') # Register our directives and roles with Sphinx register_directive('gp-extra-image', ExtraImage) roles.register_local_role('gp-extra-notebook', notebook_role)
def setup(app): app.add_node(eqt, html = (visit_eqt_node, depart_eqt_node)) app.add_directive("eqt", Equestion) app.add_directive("eqt-fib", Equestion) app.add_directive("eqt-mc", Equestion) roles.register_local_role('eqt', eqt_answer) app.add_node(eqt_answer_type, html = (visit_eqt_answer_type_node, depart_eqt_answer_type_node))
def gen_man_page(self, name, rst): from docutils.writers import manpage from docutils.core import publish_string from docutils.nodes import inline from docutils.parsers.rst import roles def issue(name, rawtext, text, lineno, inliner, options={}, content=[]): return [inline(rawtext, '#' + text)], [] roles.register_local_role('issue', issue) # We give the source_path so that docutils can find relative includes # as-if the document where located in the docs/ directory. man_page = publish_string(source=rst, source_path='docs/%s.rst' % name, writer=manpage.Writer()) with open('docs/man/%s.1' % name, 'wb') as fd: fd.write(man_page)
def pybot(): # This code hides warnings for known Sphinx-only-directives when # executing pybot against Sphinx-documentation: from docutils.parsers.rst.directives import register_directive from docutils.parsers.rst.roles import register_local_role dummy_directive = lambda *args: [] options = ('maxdepth', 'creates', 'numbered', 'hidden') setattr(dummy_directive, 'content', True) setattr(dummy_directive, 'options', dict([(opt, str) for opt in options])) register_directive('toctree', dummy_directive) register_directive('robotframework', dummy_directive) register_local_role('ref', dummy_directive) # Run pybot run_cli(sys.argv[1:])
def pybot(): # This code hides warnings for known Sphinx-only-directives when # executing pybot against Sphinx-documentation: from docutils.parsers.rst.directives import register_directive from docutils.parsers.rst.roles import register_local_role dummy_directive = lambda *args: [] options = ("maxdepth", "creates", "numbered", "hidden") setattr(dummy_directive, "content", True) setattr(dummy_directive, "options", dict([(opt, str) for opt in options])) register_directive("toctree", dummy_directive) register_directive("robotframework", dummy_directive) register_local_role("ref", dummy_directive) # Run pybot run_cli(sys.argv[1:])
def add_role(self, name, role): self.debug('adding role: %r', (name, role)) roles.register_local_role(name, role)
# Get the resolver from the register and create an url from it. try: url = api_register[name].get_url(text) except IndexError, exc: msg = inliner.reporter.warning(str(exc), line=lineno) if problematic: prb = inliner.problematic(rawtext, text, msg) return [prb], [msg] else: return [node], [] if url is not None: node = nodes.reference(rawtext, '', node, refuri=url, **options) return [node], [] roles.register_local_role(name, resolve_api_name) # { Command line parsing # -------------------- def split_name(value): """ Split an option in form ``NAME:VALUE`` and check if ``NAME`` exists. """ parts = value.split(':', 1) if len(parts) != 2: raise OptionValueError( "option value must be specified as NAME:VALUE; got '%s' instead" % value)
def register(): roles.register_local_role('fa', fa)
def set_site(self, site): self.site = site roles.register_local_role('pep', pep_role) roles.register_local_role('rfc', rfc_role) roles.register_local_role('term', term_role) roles.register_local_role('option', option_role) roles.register_local_role('ref', ref_role) roles.register_local_role('eq', eq_role) # This is copied almost verbatim from Sphinx generic_docroles = { 'command': nodes.strong, 'dfn': nodes.emphasis, 'envvar': nodes.literal, 'kbd': nodes.literal, 'mailheader': nodes.emphasis, 'makevar': nodes.strong, 'manpage': nodes.emphasis, 'mimetype': nodes.emphasis, 'newsgroup': nodes.emphasis, 'program': nodes.strong, 'regexp': nodes.literal, } for rolename, nodeclass in generic_docroles.items(): generic = roles.GenericRole(rolename, nodeclass) role = roles.CustomRole(rolename, generic, {'classes': [rolename]}) roles.register_local_role(rolename, role) specific_docroles = { 'guilabel': menusel_role, 'menuselection': menusel_role, 'file': emph_literal_role, 'samp': emph_literal_role, 'abbr': abbr_role, } for rolename, func in specific_docroles.items(): roles.register_local_role(rolename, func) # Handle abbr title add_node(abbreviation, visit_abbreviation, depart_abbreviation) for name, (base_url, prefix) in self.site.config.get('EXTLINKS', {}).items(): roles.register_local_role(name, make_link_role(base_url, prefix)) directives.register_directive('deprecated', VersionChange) directives.register_directive('versionadded', VersionChange) directives.register_directive('versionchanged', VersionChange) directives.register_directive('centered', Centered) directives.register_directive('hlist', HList) directives.register_directive('seealso', SeeAlso) directives.register_directive('glossary', Glossary) directives.register_directive('option', Option) directives.register_directive('math', Math) site.rst_transforms.append(Today) return super(Plugin, self).set_site(site)
A Docutils Publisher script for the Legal Resource Registry """ import re, os, os.path, sys try: import locale locale.setlocale(locale.LC_ALL, '') except: pass pth = os.path.split(sys.argv[0])[0] pth = os.path.join(pth, "..") pth = os.path.abspath(pth) from docutils.core import publish_cmdline, default_description from docutils.parsers.rst import directives, roles, states from docutils import nodes, statemachine from LRR import * directives.register_directive("bubble", BubbleDirective) directives.register_directive("variation", VariationDirective) directives.register_directive("reporter", ReporterDirective) directives.register_directive("fields", FieldsDirective) directives.register_directive("jurisdiction", JurisdictionDirective) directives.register_directive("court", CourtDirective) directives.register_directive("breadcrumb", BreadcrumbDirective) directives.register_directive("tab", TabDirective) directives.register_directive("floater", FloaterDirective) roles.register_local_role("trans", role_trans)
def visit_literal_block(self, node): "No classes please" self.body.append(self.starttag(node, 'pre', '')) def visit_literal(self, node): self.body.append(self.starttag(node, 'code', '')) def depart_literal(self, node): self.body.append('</code>') def inline_roles(role, raw, text, *args): if role == 'kbd': return [nodes.literal('kbd', text)], [] elif role == 'var': return [nodes.literal('var', text)], [] elif role == 'abbr': return [nodes.literal('abbr', text)], [] roles.register_local_role('kbd', inline_roles) roles.register_local_role('var', inline_roles) roles.register_local_role('abbr', inline_roles) if __name__ == '__main__': import sys parts = publish_parts(writer=MyHTMLWriter(), source=open(sys.argv[1]).read()) print parts['html_body']
def register(): roles.register_local_role('shields-full', shields_full) roles.register_local_role('shields-python', shields_python) roles.register_local_role('shields-jenkins', shields_jenkins)
def setup(app): # ============================================================================== app.add_directive("flat-table", FlatTable) roles.register_local_role('cspan', c_span) roles.register_local_role('rspan', r_span)
try: rfcnum = int(text) except ValueError: msg = inliner.reporter.error('invalid RFC number %s' % text, line=lineno) prb = inliner.problematic(rawtext, rawtext, msg) return [prb], [msg] ref = inliner.document.settings.rfc_base_url + inliner.rfc_url % rfcnum sn = nodes.strong('RFC ' + text, 'RFC ' + text) rn = nodes.reference('', '', refuri=ref) rn += sn return [targetnode, rn], [] roles.register_canonical_role('envvar', indexmarkup_role) roles.register_local_role('pep', indexmarkup_role) roles.register_local_role('rfc', indexmarkup_role) # default is `literal` innernodetypes = { 'ref': nodes.emphasis, 'token': nodes.strong, } def xfileref_role(typ, rawtext, text, lineno, inliner, options={}, content=[]): env = inliner.document.settings.env text = utils.unescape(text) # 'token' is the default role inside 'productionlist' directives if typ == '': typ = 'token'
author, 'RTIRoutingServiceTransformField', 'An basic transformation that simplifies implementation of transformations for RTI Routing Service in C.', 'Routing'), ] # -- Custom roles from docutils import nodes def role_litrep(name, rawtext, text, lineno, inliner, options={}, content=[]): node = nodes.Text(text) node.source, node.line = inliner.reporter.get_source_and_line(lineno) return [node],[] from docutils.parsers.rst import roles roles.register_local_role('litrep', role_litrep) rst_epilog = """ .. |version| replace:: {0} .. |project| replace:: {1} """.format(version, project) # -- links extlinks = {'link_cmocka': (LINK_CMOCKA + '%s', 'link_cmocka'), 'link_xml_spec': (LINK_XML_SPEC + '%s', 'link_xml_spec_text'), 'link_udpv4_properties': (LINK_UDPV4_PROPERTIES + '%s', 'link_udpv4_config '),
link = nodes.reference(rawtext, '#' + issue_no, refuri=ref, **options) ret = [link] # Additional 'new-style changelog' stuff if name in issue_types: which = '[<span class="changelog-%s">%s</span>]' % (name, name.capitalize()) ret = [ nodes.raw(text=which, format='html'), nodes.inline(text=" "), link, nodes.inline(text=":") ] return ret, [] for x in issue_types + ('issue', ): roles.register_local_role(x, issues_role) # Also ripped from Fabric, but we need to nail down the versioning and release process for Trigger before we start to use this. ''' year_arg_re = re.compile(r'^(.+?)\s*(?<!\x00)<(.*?)>$', re.DOTALL) def release_role(name, rawtext, text, lineno, inliner, options={}, content=[]): """ Invoked as :release:`N.N.N <YYYY-MM-DD>`. Turns into: <b>YYYY-MM-DD</b>: released <b><a>Trigger N.N.N</a></b>, with the link going to the Github source page for the tag. """ # Make sure year has been specified match = year_arg_re.match(text) if not match: msg = inliner.reporter.error("Must specify release date!")
class math_node(General, Inline, Element): children = () def __init__(self, rawsource='', label=None, *children, **attributes): self.rawsource = rawsource self.math_data = attributes['latex'] self.label = label Element.__init__(self, rawsource, *children, **attributes) def math_role(name, rawtext, text, lineno, inliner, options={}, content=[]): latex = utils.unescape(text, restore_backslashes=True) return [math_node(latex, latex=latex)], [] roles.register_local_role('math', math_role) class eq_node(Inline, Element): def __init__(self, rawsource='', label=None, *children, **attributes): self.label=label Element.__init__(self, rawsource, *children, **attributes) def eq_role(name, rawtext, text, lineno, inliner, options={}, content=[]): return [eq_node(label=text)],[] roles.register_local_role('eq', eq_role) class HandleMath(basenodehandler.NodeHandler, math_node): def gather_elements(self, client, node, style): return [math_flowable.Math(node.math_data,node.label)]
default_settings = docutils.frontend.OptionParser( components=(docutils.parsers.rst.Parser, )).get_default_values() parser = docutils.parsers.rst.Parser() def reet_role(role, rawtext, text, lineno, inliner, options={}, content=[]): """""" # Once nested inline markup is implemented, this and other methods should # recursively call inliner.nested_parse(). options["classes"] = "reet" return [nodes.inline(rawtext, docutils.utils.unescape(text), **options)], [] # register_generic_role('reet', nodes.literal) roles.register_local_role("reet", reet_role) document = docutils.utils.new_document("katse", default_settings) src = """ .. note:: This is a ``note`` admonition. This is the second line of the first paragraph. - The note contains all indented body elements following. - It includes this bullet list. """ parser.parse(src, document) print(document)
else : text = uri = text.strip () scheme = options.pop ("uri_scheme", None) if scheme : ref = "%s:%s" % (scheme, uri) else : ref = uri text = text.replace (" ", "\u202F") ### narrow non breaking space node = nodes.reference (rawtext, text, refuri = ref, ** options) return [node], [] # end def _uri_role _email_role = CustomRole ("email", _uri_role, dict (uri_scheme = "mailto")) _tel_role = CustomRole ("tel", _uri_role, dict (uri_scheme = "tel")) register_local_role (_email_role.name, _email_role) register_local_role ("tel", _tel_role) def _added_role (role, rawtext, text, lineno, inliner, options={}, content=[]) : cssc = "added" if len (rawtext) > 60 else "added-inline" node = nodes.inline (rawtext, text, classes = [cssc], ** options) return [node], [] # end def _added_role register_local_role ("added", _added_role) def _deleted_role (role, rawtext, text, lineno, inliner, options={}, content=[]) : cssc = "deleted" if len (rawtext) > 60 else "deleted-inline" node = nodes.inline (rawtext, text, classes = [cssc], ** options) return [node], [] # end def _deleted_role
else: print "Unhandled literal '%s' for %s" % (t, highlight_language) sys.exit(1) return [nodes.literal(text=t)], [] else: print "Unhandled highlight_language '%s'" % highlight_language sys.exit(1) # Usage: # # The previous example was :xapian-code-example:`^`. # # The foo example is in :xapian-code-example:`foo`. roles.register_local_role('xapian-code-example', xapian_code_example_role) roles.register_local_role('xapian-basename-code-example', xapian_code_example_short_role) roles.register_local_role('xapian-basename-example', xapian_example_short_role) roles.register_local_role('xapian-example', xapian_example_role) # e.g. :xapian-class:`Database` roles.register_local_role('xapian-class', xapian_class_role) # e.g. :xapian-just-method:`add_matchspy(spy)` roles.register_local_role('xapian-just-method', xapian_just_method_role) # e.g. :xapian-method:`Database::reopen()` roles.register_local_role('xapian-method', xapian_method_role) # e.g. :xapian-variable:`spy` roles.register_local_role('xapian-variable', xapian_variable_role) # e.g. :xapian-just-constant:`OP_OR` # (Currently this just does the same as the method version, but when more # languages are added this may change).
def setup(builder): directives.register_directive('math', MathDirective) roles.register_local_role('math', math_role)
def set_site(self, site): self.site = site roles.register_local_role('emoji', emoji_role)
'Error in "%s" directive:\n%s.' % (self.name, detail), nodes.literal_block(self.block_text, self.block_text), line=self.lineno) return messages + [error] if 'class' not in options: try: options['class'] = directives.class_option(new_role_name) except ValueError, detail: error = self.state_machine.reporter.error( u'Invalid argument for "%s" directive:\n%s.' % (self.name, SafeString(detail)), nodes.literal_block(self.block_text, self.block_text), line=self.lineno) return messages + [error] role = roles.CustomRole(new_role_name, base_role, options, content) roles.register_local_role(new_role_name, role) return messages class DefaultRole(Directive): """Set the default interpreted text role.""" optional_arguments = 1 final_argument_whitespace = False def run(self): if not self.arguments: if '' in roles._roles: # restore the "default" default role del roles._roles[''] return []
def register(): roles.register_local_role('html_entity', entity_role)
def add_role(self, name, role): roles.register_local_role(name, role)
def setup(app): roles.register_local_role("sql", sql_role)
def set_site(self, site): self.site = site roles.register_local_role('emoji', emoji_role) site.rst_transforms.append(Emojis)
model, id, label, _, _ = m.groups() ctx = get_ctx() assert ctx pad = get_ctx().pad assert pad entry = pad.query(model).get(id) if entry is None: msg = inliner.reporter.error( "object with model=%s id=%s not found" % (model, id) ) prb = inliner.problematic(rawtext, rawtext, msg) return [prb], [msg] if not label: label = entry["title"] url = entry.parent.path + "/" + entry["_slug"] + "/" roles.set_classes(options) node = nodes.reference(rawtext, label, refuri=url, **options) return [node], [] roles.register_local_role('ref', ref_role) class RefRolePlugin(Plugin): name = 'ref-role' description = "Add a 'ref' role to reST markup."
def add_generic_role(self, name, nodeclass): # don't use roles.register_generic_role because it uses # register_canonical_role self.debug('adding generic role: %r', (name, nodeclass)) role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role)
node += textnode continue accel_node = nodes.inline() letter_node = nodes.Text(span[0]) accel_node += letter_node accel_node['classes'].append('accelerator') node += accel_node textnode = nodes.Text(span[1:]) node += textnode node['classes'].append(typ) return [node], [] # Use 'patched_menusel_role' function for processing the 'menuselection' role roles.register_local_role("menuselection", patched_menusel_role) # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'trueos_style' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = ['themes']
def setup(app): app.add_config_value("libpq_docs_version", "13", "html") roles.register_local_role("pq", pq_role) get_reader().app = app
lineno, inliner, options={}, content=[]): label = text settings = inliner.document.settings ref = "%s/%s/%s/" % (settings.sumatra_record_store, settings.sumatra_project, label) set_classes(options) node = nodes.reference(rawtext, '', refuri=ref, **options) node += nodes.image(uri=settings.sumatra_link_icon, alt='smt:' + utils.unescape(text)) return [node], [] roles.register_local_role('smtlink', smt_link_role) def build_options(global_settings, local_options): if hasattr(global_settings, 'env'): # using sphinx config = global_settings.env.config else: config = global_settings # using plain docutils # convert config into dict, and strip "sumatra_" prefix combined_options = {} for name in ("record_store", "project", "link_icon"): full_name = "sumatra_" + name if hasattr(config, full_name): combined_options[name] = getattr(config, full_name) combined_options.update(local_options) return combined_options
final_argument_whitespace = True option_spec = {'width': directives.nonnegative_int, 'height': directives.nonnegative_int} def run(self): set_classes(self.options) node = role_video(source=self.arguments[0], **self.options) return [node] generic_docroles = { 'doc': role_doc} for rolename, nodeclass in generic_docroles.items(): generic = roles.GenericRole(rolename, nodeclass) role = roles.CustomRole(rolename, generic, {'classes': [rolename]}) roles.register_local_role(rolename, role) directives.register_directive('video', VideoDirective) Builder.load_string(''' #:import parse_color kivy.parser.parse_color <RstDocument>: content: content scatter: scatter do_scroll_x: False canvas.before: Color: rgba: parse_color(root.colors['background'])
if flag in self.options: self.options[flag] = True # noclasses should already default to False, but just in case... formatter = HtmlFormatter(noclasses=False, **self.options) parsed = highlight('\n'.join(self.content), lexer, formatter) return [nodes.raw('', parsed, format='html')] directives.register_directive('code-block', Pygments) directives.register_directive('sourcecode', Pygments) _abbr_re = re.compile(r'\((.*)\)$', re.DOTALL) class abbreviation(nodes.Inline, nodes.TextElement): pass def abbr_role(typ, rawtext, text, lineno, inliner, options={}, content=[]): text = utils.unescape(text) m = _abbr_re.search(text) if m is None: return [abbreviation(text, text)], [] abbr = text[:m.start()].strip() expl = m.group(1) return [abbreviation(abbr, abbr, explanation=expl)], [] roles.register_local_role('abbr', abbr_role)
try: if int(text) <= 0: raise ValueError except ValueError: return sphinx_err( inliner, lineno, rawtext, 'GitHub pull request or issue number must be a number greater than or equal to 1; "%s" is invalid.' % text) if name == 'pr': ref = gh_pr_uri elif name == 'issue': ref = gh_issue_uri else: return sphinx_err( inliner, lineno, rawtext, 'unknown role name for GitHub reference - "%s"' % name) ref = ref.format(text) text = '#' + utils.unescape(text) return sphinx_ref(options, rawtext, text, ref) roles.register_local_role('pr', role_github_pull_request_or_issue) roles.register_local_role('issue', role_github_pull_request_or_issue) roles.register_local_role('ghuser', role_github_user) def setup(app): app.add_stylesheet('css/style.css')