def pub(s): directives.register_directive('sc', code_block) overrides = {'input_encoding': default_enc , 'output_encoding': default_enc } return publish_parts(s, writer_name='html' , settings_overrides=overrides)
def setup(app): directives.register_directive('cond', Cond) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }
def test_directive_basic(self): # test directive html output with default template # and settings directives.register_directive('unitywebgl', UnityWebgl) config.GAMES_ROOT_DIR = '/test_games_root' config.TEMPLATE_PATH = '/test_template_path/template' config.DEFAULT_WIDTH = 960 config.DEFAULT_HEIGHT = 600 html =['<link rel="stylesheet" href="/test_template_path/template/style.css">', '<script src="/test_template_path/template/UnityProgress.js">', '<script src="/test_games_root/testgame/Build/UnityLoader.js">', '<script>\n var gameInstance = UnityLoader.instantiate("gameContainer", "/test_games_root/testgame/Build/testgame.json", {onProgress: UnityProgress});\n </script>', '<div id="gameContainer" style="width: 960px; height: 600px; left: 50%; transform: translateX(-50%);"></div>'] res = publish_string('.. unitywebgl:: testgame', writer_name='html', settings_overrides={'output_encoding': 'unicode'}) passed = True for line in html: if line not in res: passed = False break assert passed
def rst(cls, source, safe=True): source = safe_unicode(source) try: from docutils.core import publish_parts from docutils.parsers.rst import directives docutils_settings = dict([(alias, None) for alias in cls.RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES]) docutils_settings.update({'input_encoding': 'unicode', 'report_level': 4}) for k, v in docutils_settings.iteritems(): directives.register_directive(k, v) parts = publish_parts(source=source, writer_name="html4css1", settings_overrides=docutils_settings) return parts['html_title'] + parts["fragment"] except ImportError: log.warning('Install docutils to use this function') return cls.plain(source) except Exception: log.error(traceback.format_exc()) if safe: return source else: raise
def setup(): VARIANTS = {} pygments_directive.arguments = (0, 1, False) pygments_directive.content = 1 pygments_directive.options = dict([(key, directives.flag) for key in VARIANTS]) directives.register_directive("sourcecode", pygments_directive) directives.register_directive("code-block", pygments_directive)
def setup(app): app.connect("builder-inited", run_autoapi) app.connect("doctree-read", doctree_read) app.connect("doctree-resolved", add_domain_to_toctree) app.connect("build-finished", build_finished) app.connect("env-updated", clear_env) if sphinx.version_info >= (1, 8): if "viewcode-find-source" in app.events.events: app.connect("viewcode-find-source", viewcode_find) if "viewcode-follow-imported" in app.events.events: app.connect("viewcode-follow-imported", viewcode_follow_imported) app.add_config_value("autoapi_type", "python", "html") app.add_config_value("autoapi_root", API_ROOT, "html") app.add_config_value("autoapi_ignore", [], "html") app.add_config_value("autoapi_options", default_options, "html") app.add_config_value("autoapi_file_patterns", None, "html") app.add_config_value("autoapi_dirs", [], "html") app.add_config_value("autoapi_keep_files", False, "html") app.add_config_value("autoapi_add_toctree_entry", True, "html") app.add_config_value("autoapi_template_dir", None, "html") app.add_config_value("autoapi_include_summaries", False, "html") app.add_config_value("autoapi_python_class_content", "class", "html") app.add_config_value("autoapi_generate_api_docs", True, "html") app.add_autodocumenter(documenters.AutoapiFunctionDocumenter) app.add_autodocumenter(documenters.AutoapiClassDocumenter) app.add_autodocumenter(documenters.AutoapiMethodDocumenter) app.add_autodocumenter(documenters.AutoapiDataDocumenter) app.add_autodocumenter(documenters.AutoapiAttributeDocumenter) app.add_autodocumenter(documenters.AutoapiModuleDocumenter) app.add_autodocumenter(documenters.AutoapiExceptionDocumenter) directives.register_directive("autoapi-nested-parse", NestedParse) directives.register_directive("autoapisummary", AutoapiSummary) app.setup_extension("sphinx.ext.autosummary")
def test_post_parse_sn_youtube(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") directives.register_directive("youtube", YoutubeDirective)
def setup(app): directives.register_directive('openapi', OpenAPIDirective) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }
def set_site(self, site): """Set Nikola site.""" global _site _site = self.site = site directives.register_directive('chart', Chart) self.site.register_shortcode('chart', _gen_chart) return super(Plugin, self).set_site(site)
def test_post_parse(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") directives.register_directive("runpython", RunPythonDirective)
def set_site(self, site): """Set Nikola site.""" self.site = site directives.register_directive('post-list', PostListDirective) directives.register_directive('post_list', PostListDirective) PostListDirective.site = site return super(Plugin, self).set_site(site)
def test_post_list(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") # the test will fail if you add a file in data/blog others # with rst files which is not a blog post directives.register_directive("blogpost", BlogPostDirective) path = os.path.abspath(os.path.split(__file__)[0]) fold = os.path.join(path, "data", "blog") out = get_temp_folder(__file__, "temp_post_list") p = BlogPostList(fold) cats = p.get_categories() fLOG(cats) months = p.get_months() fLOG(months) assert cats == ['documentation', 'example'] assert months == ['2015-04'] res = p.write_aggregated(out) assert len(res) >= 4 for r in res: assert os.path.exists(r)
def register_global_directives(self): if self.registered: return self.registered = True rst_directives.register_directive('write-all', self.write_all_directive())
def setup(app): # type: (Sphinx) -> None directives.register_directive('highlight', Highlight) directives.register_directive('highlightlang', Highlight) # old directives.register_directive('code-block', CodeBlock) directives.register_directive('sourcecode', CodeBlock) directives.register_directive('literalinclude', LiteralInclude)
def test_post_parse_sn(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") directives.register_directive("video", VideoDirective)
def run(self): from wikir import publish_file for ep in pkg_resources.iter_entry_points('wikir.rst_directives'): log.info("registering RST directive: %s", str(ep)) directives.register_directive(ep.name, ep.load()) # from docutils.core import publish_file publish_file(self.input)
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, desc_directive) roles.register_canonical_role(rolename, xfileref_role) if ref_nodeclass is not None: innernodetypes[rolename] = ref_nodeclass
def test_post_list(self): # the test will fail if you add a file in data/blog others # with rst files which is not a blog post directives.register_directive("blogpost", BlogPostDirective) path = os.path.abspath(os.path.split(__file__)[0]) fold = os.path.join(path, "data", "blog") out = get_temp_folder(__file__, "temp_post_list") p = BlogPostList(fold) cats = p.get_categories() months = p.get_months() self.assertEqual(cats, ['documentation', 'example']) self.assertEqual(months, ['2015-04']) res = p.write_aggregated(out) self.assertTrue(len(res) >= 4) for r in res: if r in (None, ''): raise ValueError("An empty value in {0}".format(res)) if not os.path.exists(r): raise FileNotFoundError("Unable to find '{0}'".format(r)) if 'main_0000.rst' in r: with open(r, 'r', encoding='utf-8') as f: content = f.read() self.assertIn('...', content)
def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None): additional_xref_types[directivename] = (rolename, indextemplate, None) directives.register_directive(directivename, target_directive) roles.register_canonical_role(rolename, xfileref_role) if ref_nodeclass is not None: innernodetypes[rolename] = ref_nodeclass
def set_site(self, site): """Set Nikola site.""" self.site = site self.site.register_shortcode('post-list', _do_post_list) directives.register_directive('post-list', PostList) PostList.site = site return super(Plugin, self).set_site(site)
def _register_pygments_rst_directive(): from docutils import nodes from docutils.parsers.rst import directives from pygments import highlight from pygments.lexers import get_lexer_by_name, TextLexer from pygments.formatters import HtmlFormatter DEFAULT = HtmlFormatter() VARIANTS = { 'linenos': HtmlFormatter(linenos=True), } def pygments_directive(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): try: lexer = get_lexer_by_name(arguments[0]) except ValueError: # no lexer found - use the text one instead of an exception lexer = TextLexer() formatter = options and VARIANTS[options.keys()[0]] or DEFAULT parsed = highlight(u'\n'.join(content), lexer, formatter) return [nodes.raw('', parsed, format='html')] pygments_directive.arguments = (1, 0, 1) pygments_directive.content = 1 directives.register_directive('code', pygments_directive)
def __init__(self): # include MoinMoin pages directives.register_directive('include', self.include) # used for MoinMoin macros directives.register_directive('macro', self.macro) # used for MoinMoin tables of content directives.register_directive('contents', self.table_of_content) # used for MoinMoin parsers directives.register_directive('parser', self.parser) # disallow a few directives in order to prevent XSS # for directive in ('meta', 'include', 'raw'): for directive in ('meta', 'raw'): directives.register_directive(directive, None) # disable the raw role roles._roles['raw'] = None # As a quick fix for infinite includes we only allow a fixed number of # includes per page self.num_includes = 0 self.max_includes = 10
def RestReader(): try: from docutils.core import publish_cmdline from docutils.parsers.rst import directives except ImportError: raise DataError("Using reStructuredText test data requires having " "'docutils' module installed.") # Ignore custom sourcecode directives at least we use in reST sources. # See e.g. ug2html.py for an example how custom directives are created. ignorer = lambda *args: [] ignorer.content = 1 directives.register_directive('sourcecode', ignorer) class RestReader(HtmlReader): def read(self, rstfile, rawdata): htmlpath = self._rest_to_html(rstfile.name) htmlfile = None try: htmlfile = open(htmlpath, 'rb') return HtmlReader.read(self, htmlfile, rawdata) finally: if htmlfile: htmlfile.close() os.remove(htmlpath) def _rest_to_html(self, rstpath): filedesc, htmlpath = tempfile.mkstemp('.html') os.close(filedesc) publish_cmdline(writer_name='html', argv=[rstpath, htmlpath]) return htmlpath return RestReader()
def buildTemplates(template="source/ham.tmpl",page_glob="source/*.page"): """Build all of the *.page pages using the ham.tmpl template.""" directives.register_directive('applet', Applet) base_args = { 'metaTags':meta, 'stylesheetTags':style, 'javascriptTags':javascript, 'currentYr':'2005, 2009', 'siteCopyrightName':'Steven F. Lott', 'siteDomainName':'http://www.me.com/s_lott', 'siteCredits':'Designed by Steven F. Lott, Powered by Python', } load_from, template_name = os.path.split( template ) env= jinja.Environment() env.loader= jinja.FileSystemLoader(load_from) template= env.get_template(template_name) for page in glob.glob(page_glob): print "render", page source= open(page,"r").read() args = base_args.copy() parts= publish_parts( source=source, writer_name='html' ) args['name']= parts['title'] args['text']= parts['html_body'] args['now']= str(datetime.datetime.now()) args['source']= page html= template.render( args ) #print html # write page to build directory page_name, _ = os.path.splitext(os.path.basename(page)) dest= open(os.path.join("build",page_name+".html"),"w") dest.write( html ) dest.write( '\n' ) dest.close()
def register_directives(): """ To use directives in your rst system, you should register your custom directives. """ directives.register_directive('sourcecode', Pygments) directives.register_directive('more', More)
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 get_items_from_api_doc(): from sphinx.ext.autosummary import Autosummary from docutils.core import publish_doctree from docutils.parsers.rst import directives import docutils.nodes def add_item(item, api_doc_items): item = item.astext().strip().split() if len(item) > 0: # if item comes from a hand written table (like the Exploring section of Axis in api.rst) # we select the text from the left column if isinstance(item, list): item = item[0] api_doc_items.append(item) api_doc_items = [] directives.register_directive('autosummary', Autosummary) cleanup_line = lambda line: line.replace(':attr:', ' ').replace('`', ' ') check_line = lambda line: len(line) and not (line.startswith('..') or ':' in line) with open('./api.rst', mode='r') as f: content = [cleanup_line(line) for line in f.readlines()] content = '\n'.join([line for line in content if check_line(line)]) document = publish_doctree(content) nodes = list(document) for node in nodes: if isinstance(node, docutils.nodes.block_quote): for item in node.children: add_item(item, api_doc_items) if isinstance(node, docutils.nodes.table): for item in node[0][2].children: add_item(item, api_doc_items) return api_doc_items
def test_post_parse_sn(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") directives.register_directive("sharenet", ShareNetDirective)
def cb_start(args): """Register a break directive if docutils is installed.""" try: from docutils import nodes from docutils.parsers.rst import directives, Directive except ImportError: return request = args['request'] config = request.get_configuration() breakpoint = config.get("readmore_breakpoint", READMORE_BREAKPOINT) class Break(Directive): """ Transform a break directive (".. break::") into the text that the douglas readmore plugin looks for. This allows blog entries written in reST to use this plugin. """ required_arguments = 0 optional_arguments = 0 final_argument_whitespace = True has_content = False def run(self): return [nodes.raw("", breakpoint + "\n", format="html")] directives.register_directive("break", Break)
def test_post_parse_blocref(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == "__main__") directives.register_directive("blocref", BlocRef) directives.register_directive("blocreflist", BlocRefList)
# Contact: [email protected] # Revision: $Revision$ # Date: $Date$ # Copyright: This module has been placed in the public domain. """ A minimal front end to the Docutils Publisher, producing DocBook XML. """ import locale try: locale.setlocale(locale.LC_ALL, '') except: pass from docutils.core import publish_cmdline, default_description # cerebrum-changes starts: from docutils.parsers.rst import directives from rst_extensions import sysinclude, namespace, known_vars directives.register_directive('sysinclude', sysinclude) directives.register_directive('namespace', namespace) # cerebrum-changes ends description = ( 'Generates DocBook XML documents from standalone reStructuredText ' 'sources. ' + default_description) publish_cmdline(writer_name='docbook', description=description) # :indentSize=4:lineSeparator=\n:noTabs=true:tabSize=4:
def pdf(files, project, output): pdf = project['pdf'] if 'pdf' in project else None # Stylesheet processing stylesheets = [] try: if pdf and ('stylesheet' in pdf): tmp_json = fileutils.stylesheet_to_tmp_json(pdf['stylesheet']) stylesheets.append(tmp_json) if pdf and ('stylesheets' in pdf): for stylesheet_file in pdf['stylesheets']: tmp_json = fileutils.stylesheet_to_tmp_json(stylesheet_file) stylesheets.append(tmp_json) except Exception: raise # Revisions if 'revisions' in project: revisions_text = '.. _unnumbered_revisions:\n' revisions_text += '.. list-table:: Revision History\n' revisions_text += ' :class: revisions-table\n' revisions_text += ' :header-rows: 1\n' revisions_text += '\n' revisions_text += ' * - Revision\n' revisions_text += ' - Date\n' revisions_text += ' - Description\n' last_revision = None last_date = None revisions = project['revisions'] for revision in revisions: if isinstance(revision, dict): key = list(revision.keys())[0] rev = key date = '--' m = re.search( r'([\w\d.-:]+)\s+(?:\(|\[)([0-9\w\s./:]+)(?:\)|\])', key) if m: rev = m.group(1) date = m.group(2) if not last_revision: last_revision = rev if not last_date: last_date = date revisions_text += ' * - **' + str(rev) + '**\n' revisions_text += ' - ' + date + '\n' revisions_text += ' - .. class:: revision-list\n' revisions_text += '\n' changes = revision[key] for change in changes: revisions_text += ' + ' + change + '\n' revisions_text += '\n' if not 'fields' in project: project['fields'] = {} project['fields']['revisions'] = revisions_text if (not 'revision' in project['fields']) and last_revision: project['fields']['revision'] = last_revision if (not 'version' in project['fields']) and last_revision: project['fields']['version'] = last_revision if (not 'date' in project['fields']) and last_date: project['fields']['date'] = last_date # Text processing text = '' # Cover page if pdf and ('cover' in pdf): cover_file = pdf['cover'] if not os.path.isfile(cover_file): log.error("Unable to open cover file: '%s'", cover_file) raise IOError('Cover file error') text += preprocess.pdf(fileutils.readfile(cover_file), os.path.dirname(cover_file), project) # Main contents processing for file in files: text += preprocess.pdf(fileutils.readfile(file['src']), os.path.dirname(file['src']), project) # Output file name processing if pdf and 'output' in pdf: output = os.path.join(pdf['output'], output) if os.path.isdir( pdf['output']) else pdf['output'] if not output.endswith('.pdf'): output += '.pdf' # Generating PDF options = namedtuple('Namespace', 'extensions') options.extensions = ['inkscape', 'vectorpdf'] if pdf and ('toc' in pdf): if pdf['toc'] == 'dotted': options.extensions.append('dotted_toc') add_extensions(options) directives.register_directive( 'code-block', pygments_code_block_directive.code_block_directive) directives.register_directive( 'code', pygments_code_block_directive.code_block_directive) doctree = docutils.core.publish_doctree(text) doctree = preprocess.doctree(doctree, project) if pdf: doctree = preprocess.doctree_pdf(doctree, pdf) log.info("Generating '%s'", os.path.basename(output)) try: stylesheet_names = [] for stylesheet in stylesheets: stylesheet_names.append(stylesheet.name) RstToPdf( background_fit_mode='scale', breaklevel=pdf['break-level'] if pdf and ('break-level' in pdf) else 1, breakside=pdf['break-side'] if pdf and ('break-side' in pdf) else 'any', repeat_table_rows=pdf['repeate-table-rows'] if pdf and ('repeate-table-rows' in pdf) else True, smarty=str(pdf['smartquotes'] if pdf and ( 'smartquotes' in pdf) else 1), stylesheets=stylesheet_names, ).createPdf(doctree=doctree, output=output) except Exception as err: log.error("PDF generating failed: %s", err) raise log.info("Post-processing '%s'", os.path.basename(output)) try: import pkg_resources __version__ = pkg_resources.get_distribution('doker').version except Exception: __version__ = None creator = 'Doker' if __version__: creator += ' v' + __version__ creator += ' \\(doker.org\\)' with open(output, 'rb') as f: text = f.read() with open(output, 'wb') as f: f.write( re.sub(r'/Creator \(\\\(unspecified\\\)\)', '/Creator (' + creator + ')', text))
def register(): ''' ''' directives.register_directive('avembed', avembed) directives.register_directive('avmetadata', avmetadata) directives.register_directive('extrtoolembed', extrtoolembed) directives.register_directive('inlineav', inlineav) directives.register_directive('odsalink', odsalink) directives.register_directive('odsascript', odsascript) directives.register_directive('index', index) directives.register_directive('codeinclude', codeinclude) directives.register_directive('todo', todo) directives.register_directive('only', only) directives.register_directive('glossary', glossary) directives.register_directive('odsafig', odsafig)
def setup(builder): directives.register_directive('line-break', LineBreak)
error = state_machine.reporter.error( 'The "%s" block is empty; content required.' % (name), nodes.literal_block(block_text, block_text), line=lineno) return [error] include_text = highlighter("\n".join(content)) html = '<div class="codeblock %s">\n%s\n</div>\n' % (language, include_text) raw = nodes.raw('',html, format='html') return [raw] code.content = 1 code.options = {'language' : parsers.rst.directives.unchanged } code.arguments = (1,0,0) directives.register_directive('code', code) def photologue_rst( name, arguments, options, content, lineno, content_offset, block_text, state, state_machine ): """ The code-block directive provides syntax highlighting for blocks of code. It is used with the the following syntax:: .. photologue:: 1 The directive requires the name of a language supported by SilverCity as its only argument. All code in the indented block following the directive will be colourized. Note that this directive is only supported for HTML writers. """ from photologue.models import Photo
stdout=subprocess.PIPE) p.stdin.write(content.encode('utf-8')) p.stdin.close() datalines = p.stdout.readlines() del datalines[:3] #ff=open(self.options['filename'],'w') #ff.write(data) #ff.close() #return [nodes.raw('',"""<embed src="%s" />"""%\ # self.options['filename'],format='html')] return [ nodes.raw('', ''.join(datalines).decode('utf-8'), format='html') ] directives.register_directive('dot', Dot) #XXX: 内嵌SVG的支持 #class SVG(Directive): # has_content=True # option_spec={ # 'filename': directives.unchanged_required, # 'height': directives.unchanged_required, # 'width': directives.unchanged_required, # } # # def run(self): # content=u'\n'.join(self.content) # filename=self.options['filename'] # height=self.options.get('height',200) # width=self.options.get('width',200)
try: linenothreshold = int(options['linenothreshold']) except Exception: linenothreshold = 10 else: linenothreshold = sys.maxint return [ addnodes.highlightlang(lang=arguments[0].strip(), linenothreshold=linenothreshold) ] highlightlang_directive.content = 0 highlightlang_directive.arguments = (1, 0, 0) highlightlang_directive.options = {'linenothreshold': directives.unchanged} directives.register_directive('highlight', highlightlang_directive) directives.register_directive('highlightlang', highlightlang_directive) # old name # ------ code-block directive ------------------------------------------------------- def codeblock_directive(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): code = u'\n'.join(content) literal = nodes.literal_block(code, code) literal['language'] = arguments[0] literal['linenos'] = 'linenos' in options return [literal]
break_class = arguments[0] else: break_class = 'clear' raw_node = nodes.raw('', '<hr class="%s" />' % break_class, format='html') # return [nodes.transition()] return [raw_node] break_directive.arguments = (0, 1, True) break_directive.options = { 'class':directives.class_option } break_directive.content = False directives.register_directive('break', break_directive) # ------------------------------------------------------------------------------ # a tag direktive!! # ------------------------------------------------------------------------------ SEEN_TAGS_CACHE = None TAG_COUNTER = None class TagDirective(Directive): """Convert tags into HTML annotation blocks.""" required_arguments = 0 optional_arguments = 1 final_argument_whitespace = True
# list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # # import os # import sys # sys.path.insert(0, os.path.abspath('.')) from docutils.parsers.rst import directives from sphinx.directives.code import CodeBlock directives.register_directive("code", CodeBlock) # -- Project information ----------------------------------------------------- project = "IntelOwl" copyright = "2020, Matteo Lodi" author = "Matteo Lodi" # The full version, including alpha/beta/rc tags release = "v2.5.0" # -- General configuration --------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones.
def set_site(self, site): """Set Nikola site.""" global _site _site = self.site = site directives.register_directive('chart', Chart) return super(Plugin, self).set_site(site)
def set_site(self, site): self.site = site directives.register_directive('youtube', Youtube) return super(Plugin, self).set_site(site)
# if self.options['showhide'] != "none": # self.options['content'] = BUTTON_HTML % (self.options) res = CONTAINER_HTML % (self.options) return [nodes.raw('', res, format='html')] source = """\ This is some text. .. avembed:: address type This is some more text. """ if __name__ == '__main__': from docutils.core import publish_parts directives.register_directive('avembed', avembed) doc_parts = publish_parts(source, settings_overrides={ 'output_encoding': 'utf8', 'initial_header_level': 2 }, writer_name="html") print doc_parts['html_body']
def register_directives(): directives.register_directive('video', video_directive)
def run(self): latex = ' '.join(self.content) try: mathml_tree = parse_latex_math(latex, inline=False) except SyntaxError, msg: error = self.state_machine.reporter.error(msg, nodes.literal_block( self.block_text, self.block_text), line=self.lineno) return [error] node = latex_math(self.block_text, mathml_tree) return [node] directives.register_directive('latex-math', latex_math_directive) # Add visit/depart methods to HTML-Translator: def visit_latex_math(self, node): mathml = ''.join(node.mathml_tree.xml()) self.body.append(mathml) if not self.has_mathml_dtd: doctype = ('<!DOCTYPE html' ' PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"' ' "http://www.w3.org/Math/DTD/mathml2/' 'xhtml-math11-f.dtd">\n') if self.settings.xml_declaration: self.head_prefix[1] = doctype else: self.head_prefix[0] = doctype
res = res + SCRIPTTAG % self.options['modelfile'] if 'viewerfile' in self.options: res = res + SCRIPTTAG % self.options['viewerfile'] res = res + SRC % self.options return [nodes.raw('', res, format='html')] source = ''' .. animation:: testanim :modelfile: sortmodels.js :viewerfile: sortviewers.js :model: SortModel :viewer: BarViewer ''' if __name__ == '__main__': from docutils.core import publish_parts directives.register_directive('animation', Animation) doc_parts = publish_parts(source, settings_overrides={ 'output_encoding': 'utf8', 'initial_header_level': 2 }, writer_name="html") print doc_parts['html_body']
def register(): directives.register_directive('podcast', Podcast)
from docutils.parsers.rst import directives from pkg_resources import parse_version import sphinx import numpy as np sys.path.insert( 0, os.path.join(os.path.dirname(__file__), '..', 'doc', 'sphinxext')) from numpydoc.docscrape_sphinx import get_doc_object SKIPBLOCK = doctest.register_optionflag('SKIPBLOCK') if parse_version(sphinx.__version__) >= parse_version('1.5'): # Enable specific Sphinx directives from sphinx.directives.other import SeeAlso, Only directives.register_directive('seealso', SeeAlso) directives.register_directive('only', Only) else: # Remove sphinx directives that don't run without Sphinx environment. # Sphinx < 1.5 installs all directives on import... directives._directives.pop('versionadded', None) directives._directives.pop('versionchanged', None) directives._directives.pop('moduleauthor', None) directives._directives.pop('sectionauthor', None) directives._directives.pop('codeauthor', None) directives._directives.pop('toctree', None) BASE_MODULE = "numpy" PUBLIC_SUBMODULES = [ 'core',
from config import nav_root_template, nav_item_template def navtree_directive(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): context = state.document.settings.context request = state.document.settings.request parsed = nav_tree(context, request, options.get('root_depth', 2)) return [nodes.raw('', parsed, format='html')] navtree_directive.arguments = (0, 1, 0) navtree_directive.has_content = 1 navtree_directive.content = 1 navtree_directive.options = {'root_depth': int} directives.register_directive('navtree', navtree_directive) # 生成navtree def nav_tree(context, request, root_depth): """render navtree structure, root_depth from root""" navtree = getMultiAdapter((context,request), INavtreeData) if navtree == None: return # get the root accoding to root_depth con = context parents = [] while con.__parent__ != None: parents.insert(0,con.__parent__) con = con.__parent__ if IFRSFolder.providedBy(context):
return markdown2.markdown(plain, extras=cls.extras) all.append(Markdown2) except ImportError: logging.warn('Markdown not enabled.') # Include ReStructuredText Parser, if we have docutils try: import docutils.core from docutils.writers.html4css1 import Writer as rst_html_writer from docutils.parsers.rst import directives if have_pygments: from wok.rst_pygments import Pygments as RST_Pygments directives.register_directive('Pygments', RST_Pygments) class ReStructuredText(Renderer): """reStructuredText renderer.""" extensions = ['rst'] @classmethod def render(cls, plain): w = rst_html_writer() return docutils.core.publish_parts(plain, writer=w)['body'] all.append(ReStructuredText) except ImportError: logging.warn('reStructuredText not enabled.')
def setup(app): # type: (Sphinx) -> Dict[unicode, Any] directives.register_directive('toctree', TocTree) directives.register_directive('sectionauthor', Author) directives.register_directive('moduleauthor', Author) directives.register_directive('codeauthor', Author) directives.register_directive('index', Index) directives.register_directive('deprecated', VersionChange) directives.register_directive('versionadded', VersionChange) directives.register_directive('versionchanged', VersionChange) directives.register_directive('seealso', SeeAlso) directives.register_directive('tabularcolumns', TabularColumns) directives.register_directive('centered', Centered) directives.register_directive('acks', Acks) directives.register_directive('hlist', HList) directives.register_directive('only', Only) directives.register_directive('include', Include) # register the standard rst class directive under a different name # only for backwards compatibility now directives.register_directive('cssclass', Class) # new standard name when default-domain with "class" is in effect directives.register_directive('rst-class', Class) return { 'version': 'builtin', 'parallel_read_safe': True, 'parallel_write_safe': True, }
label = self.options.get('label', None) fontsize = self.options.get('fontsize', None) color = self.options.get('color', None) return [ math_node(latex=latex, label=label, fontsize=fontsize, color=color, rawsource=''.join(self.content)) ] def __repr__(self): return ''.join(self.content) directives.register_directive('math', Math) class math_node(General, Inline, Element): children = () def __init__(self, rawsource='', label=None, fontsize=12, color='black', *children, **attributes): self.rawsource = rawsource self.math_data = attributes['latex']
def set_site(self, site): """Set Nikola site.""" self.site = site directives.register_directive('vimeo', Vimeo) return super().set_site(site)
def setup(builder): directives.register_directive('youtube', Youtube)
'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: Color: rgba: parse_color(root.colors['background']) Rectangle: pos: self.pos
# -*- coding: utf-8 -*- # This code is from http://countergram.com/youtube-in-rst from docutils import nodes from docutils.parsers.rst import directives CODE = """\ <object class="rst-youtube" type="application/x-shockwave-flash" %(attrs)s data="http://www.youtube.com/v/%(yid)s"> <param name="movie" value="http://www.youtube.com/v/%(yid)s"></param> <param name="wmode" value="transparent"></param> %(extra)s </object> """ PARAM = """\n<param name="%s" value="%s"></param>""" def youtube(name, args, options, content, lineno, contentOffset, blockText, state, stateMachine): """Restructured text extension for inserting youtube embedded videos.""" if len(content) == 0: return string_vars = {'yid': content[0], 'attrs': '', 'extra': ''} attrs = content[1:] # Because content[0] is ID attrs = [attr.strip() for attr in content[1:]] # key=value string_vars['attrs'] = " ".join(attrs) return [nodes.raw('', CODE % (string_vars), format='html')] youtube.content = True directives.register_directive('youtube', youtube)
def set_site(self, site): self.site = site directives.register_directive('post-list', PostList) PostList.site = site return super(Plugin, self).set_site(site)
content_offset, block_text, state, state_machine): try: lexer = get_lexer_by_name(arguments[0]) except ValueError: # no lexer found - use the text one instead of an exception lexer = TextLexer() # take an arbitrary option if more than one is given formatter = options and VARIANTS[options.keys()[0]] or DEFAULT parsed = highlight(u'\n'.join(content), lexer, formatter) return [nodes.raw('', parsed, format='html')] pygments_directive.arguments = (1, 0, 1) pygments_directive.content = 1 pygments_directive.options = dict([(key, directives.flag) for key in VARIANTS]) directives.register_directive('sourcecode', pygments_directive) # ---------------------------------------------------------------------------- import math_directive math_directive.register() try: import locale locale.setlocale(locale.LC_ALL, '') except: pass from docutils.core import publish_cmdline, default_description description = ('Generates (X)HTML documents from standalone reStructuredText '
'anchorlinenos': directives.flag, 'noclasses': directives.flag, } has_content = True def run(self): self.assert_has_content() try: lexer = get_lexer_by_name(self.arguments[0]) except ValueError: # no lexer found lexer = get_lexer_by_name('text') options = {} for (option, converter) in self.option_spec.iteritems(): if converter == directives.flag: if option in self.options: options[option] = True elif option in self.options: options[option] = self.options[option] formatter = HtmlFormatter(**options) parsed = highlight(u'\n'.join(self.content), lexer, formatter) return [nodes.raw('', parsed, format='html')] directives.register_directive('code', Pygments) directives.register_directive('code-block', Pygments) directives.register_directive('sourcecode', Pygments) directives.register_directive('sourcecode-block', Pygments)
# TODO: validate options here and (maybe) display an error defaults = {} for option in defaults.keys(): assert option in self.option_spec return defaults def run(self): if len(self.content) == 0: return # from nikola.plugins.compile.rest import rst2html # content = rst2html('\n'.join(self.content)) # TODO: use nikola.plugins.compile.rest.rst2html to compile this import uuid from docutils.core import publish_parts content = publish_parts('\n'.join(self.content), writer_name='html')['html_body'] output = self.site.template_system.render_template( 'collapse.tmpl', None, { 'uuid': uuid.uuid4().hex, 'title': ' '.join(self.arguments), 'content': content, }) return [nodes.raw('', output, format='html')] directives.register_directive('collapse', Collapse)
def setup(app): directives.register_directive('only', EagerOnly)