mirror of
https://github.com/torvalds/linux.git
synced 2024-11-22 20:22:09 +00:00
3e893e16af
Commit 31abfdda65 (docs: Deprecate use of Sphinx < 2.4.x) in 6.2 added a
warning that support for older versions of Sphinx would be going away.
There have been no complaints, so the time has come. Raise the minimum
Sphinx version to 2.4.4 and clean out some compatibility code that we no
longer need.
Reviewed-by: Mauro Carvalho Chehab <mchehab@kernel.org>
Link: https://lore.kernel.org/r/874jgs47fq.fsf@meer.lwn.net
Signed-off-by: Jonathan Corbet <corbet@lwn.net>
650 lines
22 KiB
Python
650 lines
22 KiB
Python
# -*- coding: utf-8; mode: python -*-
|
|
# pylint: disable=C0103, R0903, R0912, R0915
|
|
u"""
|
|
scalable figure and image handling
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Sphinx extension which implements scalable image handling.
|
|
|
|
:copyright: Copyright (C) 2016 Markus Heiser
|
|
:license: GPL Version 2, June 1991 see Linux/COPYING for details.
|
|
|
|
The build for image formats depend on image's source format and output's
|
|
destination format. This extension implement methods to simplify image
|
|
handling from the author's POV. Directives like ``kernel-figure`` implement
|
|
methods *to* always get the best output-format even if some tools are not
|
|
installed. For more details take a look at ``convert_image(...)`` which is
|
|
the core of all conversions.
|
|
|
|
* ``.. kernel-image``: for image handling / a ``.. image::`` replacement
|
|
|
|
* ``.. kernel-figure``: for figure handling / a ``.. figure::`` replacement
|
|
|
|
* ``.. kernel-render``: for render markup / a concept to embed *render*
|
|
markups (or languages). Supported markups (see ``RENDER_MARKUP_EXT``)
|
|
|
|
- ``DOT``: render embedded Graphviz's **DOC**
|
|
- ``SVG``: render embedded Scalable Vector Graphics (**SVG**)
|
|
- ... *developable*
|
|
|
|
Used tools:
|
|
|
|
* ``dot(1)``: Graphviz (https://www.graphviz.org). If Graphviz is not
|
|
available, the DOT language is inserted as literal-block.
|
|
For conversion to PDF, ``rsvg-convert(1)`` of librsvg
|
|
(https://gitlab.gnome.org/GNOME/librsvg) is used when available.
|
|
|
|
* SVG to PDF: To generate PDF, you need at least one of this tools:
|
|
|
|
- ``convert(1)``: ImageMagick (https://www.imagemagick.org)
|
|
- ``inkscape(1)``: Inkscape (https://inkscape.org/)
|
|
|
|
List of customizations:
|
|
|
|
* generate PDF from SVG / used by PDF (LaTeX) builder
|
|
|
|
* generate SVG (html-builder) and PDF (latex-builder) from DOT files.
|
|
DOT: see https://www.graphviz.org/content/dot-language
|
|
|
|
"""
|
|
|
|
import os
|
|
from os import path
|
|
import subprocess
|
|
from hashlib import sha1
|
|
import re
|
|
from docutils import nodes
|
|
from docutils.statemachine import ViewList
|
|
from docutils.parsers.rst import directives
|
|
from docutils.parsers.rst.directives import images
|
|
import sphinx
|
|
from sphinx.util.nodes import clean_astext
|
|
import kernellog
|
|
|
|
Figure = images.Figure
|
|
|
|
__version__ = '1.0.0'
|
|
|
|
# simple helper
|
|
# -------------
|
|
|
|
def which(cmd):
|
|
"""Searches the ``cmd`` in the ``PATH`` environment.
|
|
|
|
This *which* searches the PATH for executable ``cmd`` . First match is
|
|
returned, if nothing is found, ``None` is returned.
|
|
"""
|
|
envpath = os.environ.get('PATH', None) or os.defpath
|
|
for folder in envpath.split(os.pathsep):
|
|
fname = folder + os.sep + cmd
|
|
if path.isfile(fname):
|
|
return fname
|
|
|
|
def mkdir(folder, mode=0o775):
|
|
if not path.isdir(folder):
|
|
os.makedirs(folder, mode)
|
|
|
|
def file2literal(fname):
|
|
with open(fname, "r") as src:
|
|
data = src.read()
|
|
node = nodes.literal_block(data, data)
|
|
return node
|
|
|
|
def isNewer(path1, path2):
|
|
"""Returns True if ``path1`` is newer than ``path2``
|
|
|
|
If ``path1`` exists and is newer than ``path2`` the function returns
|
|
``True`` is returned otherwise ``False``
|
|
"""
|
|
return (path.exists(path1)
|
|
and os.stat(path1).st_ctime > os.stat(path2).st_ctime)
|
|
|
|
def pass_handle(self, node): # pylint: disable=W0613
|
|
pass
|
|
|
|
# setup conversion tools and sphinx extension
|
|
# -------------------------------------------
|
|
|
|
# Graphviz's dot(1) support
|
|
dot_cmd = None
|
|
# dot(1) -Tpdf should be used
|
|
dot_Tpdf = False
|
|
|
|
# ImageMagick' convert(1) support
|
|
convert_cmd = None
|
|
|
|
# librsvg's rsvg-convert(1) support
|
|
rsvg_convert_cmd = None
|
|
|
|
# Inkscape's inkscape(1) support
|
|
inkscape_cmd = None
|
|
# Inkscape prior to 1.0 uses different command options
|
|
inkscape_ver_one = False
|
|
|
|
|
|
def setup(app):
|
|
# check toolchain first
|
|
app.connect('builder-inited', setupTools)
|
|
|
|
# image handling
|
|
app.add_directive("kernel-image", KernelImage)
|
|
app.add_node(kernel_image,
|
|
html = (visit_kernel_image, pass_handle),
|
|
latex = (visit_kernel_image, pass_handle),
|
|
texinfo = (visit_kernel_image, pass_handle),
|
|
text = (visit_kernel_image, pass_handle),
|
|
man = (visit_kernel_image, pass_handle), )
|
|
|
|
# figure handling
|
|
app.add_directive("kernel-figure", KernelFigure)
|
|
app.add_node(kernel_figure,
|
|
html = (visit_kernel_figure, pass_handle),
|
|
latex = (visit_kernel_figure, pass_handle),
|
|
texinfo = (visit_kernel_figure, pass_handle),
|
|
text = (visit_kernel_figure, pass_handle),
|
|
man = (visit_kernel_figure, pass_handle), )
|
|
|
|
# render handling
|
|
app.add_directive('kernel-render', KernelRender)
|
|
app.add_node(kernel_render,
|
|
html = (visit_kernel_render, pass_handle),
|
|
latex = (visit_kernel_render, pass_handle),
|
|
texinfo = (visit_kernel_render, pass_handle),
|
|
text = (visit_kernel_render, pass_handle),
|
|
man = (visit_kernel_render, pass_handle), )
|
|
|
|
app.connect('doctree-read', add_kernel_figure_to_std_domain)
|
|
|
|
return dict(
|
|
version = __version__,
|
|
parallel_read_safe = True,
|
|
parallel_write_safe = True
|
|
)
|
|
|
|
|
|
def setupTools(app):
|
|
u"""
|
|
Check available build tools and log some *verbose* messages.
|
|
|
|
This function is called once, when the builder is initiated.
|
|
"""
|
|
global dot_cmd, dot_Tpdf, convert_cmd, rsvg_convert_cmd # pylint: disable=W0603
|
|
global inkscape_cmd, inkscape_ver_one # pylint: disable=W0603
|
|
kernellog.verbose(app, "kfigure: check installed tools ...")
|
|
|
|
dot_cmd = which('dot')
|
|
convert_cmd = which('convert')
|
|
rsvg_convert_cmd = which('rsvg-convert')
|
|
inkscape_cmd = which('inkscape')
|
|
|
|
if dot_cmd:
|
|
kernellog.verbose(app, "use dot(1) from: " + dot_cmd)
|
|
|
|
try:
|
|
dot_Thelp_list = subprocess.check_output([dot_cmd, '-Thelp'],
|
|
stderr=subprocess.STDOUT)
|
|
except subprocess.CalledProcessError as err:
|
|
dot_Thelp_list = err.output
|
|
pass
|
|
|
|
dot_Tpdf_ptn = b'pdf'
|
|
dot_Tpdf = re.search(dot_Tpdf_ptn, dot_Thelp_list)
|
|
else:
|
|
kernellog.warn(app, "dot(1) not found, for better output quality install "
|
|
"graphviz from https://www.graphviz.org")
|
|
if inkscape_cmd:
|
|
kernellog.verbose(app, "use inkscape(1) from: " + inkscape_cmd)
|
|
inkscape_ver = subprocess.check_output([inkscape_cmd, '--version'],
|
|
stderr=subprocess.DEVNULL)
|
|
ver_one_ptn = b'Inkscape 1'
|
|
inkscape_ver_one = re.search(ver_one_ptn, inkscape_ver)
|
|
convert_cmd = None
|
|
rsvg_convert_cmd = None
|
|
dot_Tpdf = False
|
|
|
|
else:
|
|
if convert_cmd:
|
|
kernellog.verbose(app, "use convert(1) from: " + convert_cmd)
|
|
else:
|
|
kernellog.verbose(app,
|
|
"Neither inkscape(1) nor convert(1) found.\n"
|
|
"For SVG to PDF conversion, "
|
|
"install either Inkscape (https://inkscape.org/) (preferred) or\n"
|
|
"ImageMagick (https://www.imagemagick.org)")
|
|
|
|
if rsvg_convert_cmd:
|
|
kernellog.verbose(app, "use rsvg-convert(1) from: " + rsvg_convert_cmd)
|
|
kernellog.verbose(app, "use 'dot -Tsvg' and rsvg-convert(1) for DOT -> PDF conversion")
|
|
dot_Tpdf = False
|
|
else:
|
|
kernellog.verbose(app,
|
|
"rsvg-convert(1) not found.\n"
|
|
" SVG rendering of convert(1) is done by ImageMagick-native renderer.")
|
|
if dot_Tpdf:
|
|
kernellog.verbose(app, "use 'dot -Tpdf' for DOT -> PDF conversion")
|
|
else:
|
|
kernellog.verbose(app, "use 'dot -Tsvg' and convert(1) for DOT -> PDF conversion")
|
|
|
|
|
|
# integrate conversion tools
|
|
# --------------------------
|
|
|
|
RENDER_MARKUP_EXT = {
|
|
# The '.ext' must be handled by convert_image(..) function's *in_ext* input.
|
|
# <name> : <.ext>
|
|
'DOT' : '.dot',
|
|
'SVG' : '.svg'
|
|
}
|
|
|
|
def convert_image(img_node, translator, src_fname=None):
|
|
"""Convert a image node for the builder.
|
|
|
|
Different builder prefer different image formats, e.g. *latex* builder
|
|
prefer PDF while *html* builder prefer SVG format for images.
|
|
|
|
This function handles output image formats in dependence of source the
|
|
format (of the image) and the translator's output format.
|
|
"""
|
|
app = translator.builder.app
|
|
|
|
fname, in_ext = path.splitext(path.basename(img_node['uri']))
|
|
if src_fname is None:
|
|
src_fname = path.join(translator.builder.srcdir, img_node['uri'])
|
|
if not path.exists(src_fname):
|
|
src_fname = path.join(translator.builder.outdir, img_node['uri'])
|
|
|
|
dst_fname = None
|
|
|
|
# in kernel builds, use 'make SPHINXOPTS=-v' to see verbose messages
|
|
|
|
kernellog.verbose(app, 'assert best format for: ' + img_node['uri'])
|
|
|
|
if in_ext == '.dot':
|
|
|
|
if not dot_cmd:
|
|
kernellog.verbose(app,
|
|
"dot from graphviz not available / include DOT raw.")
|
|
img_node.replace_self(file2literal(src_fname))
|
|
|
|
elif translator.builder.format == 'latex':
|
|
dst_fname = path.join(translator.builder.outdir, fname + '.pdf')
|
|
img_node['uri'] = fname + '.pdf'
|
|
img_node['candidates'] = {'*': fname + '.pdf'}
|
|
|
|
|
|
elif translator.builder.format == 'html':
|
|
dst_fname = path.join(
|
|
translator.builder.outdir,
|
|
translator.builder.imagedir,
|
|
fname + '.svg')
|
|
img_node['uri'] = path.join(
|
|
translator.builder.imgpath, fname + '.svg')
|
|
img_node['candidates'] = {
|
|
'*': path.join(translator.builder.imgpath, fname + '.svg')}
|
|
|
|
else:
|
|
# all other builder formats will include DOT as raw
|
|
img_node.replace_self(file2literal(src_fname))
|
|
|
|
elif in_ext == '.svg':
|
|
|
|
if translator.builder.format == 'latex':
|
|
if not inkscape_cmd and convert_cmd is None:
|
|
kernellog.warn(app,
|
|
"no SVG to PDF conversion available / include SVG raw."
|
|
"\nIncluding large raw SVGs can cause xelatex error."
|
|
"\nInstall Inkscape (preferred) or ImageMagick.")
|
|
img_node.replace_self(file2literal(src_fname))
|
|
else:
|
|
dst_fname = path.join(translator.builder.outdir, fname + '.pdf')
|
|
img_node['uri'] = fname + '.pdf'
|
|
img_node['candidates'] = {'*': fname + '.pdf'}
|
|
|
|
if dst_fname:
|
|
# the builder needs not to copy one more time, so pop it if exists.
|
|
translator.builder.images.pop(img_node['uri'], None)
|
|
_name = dst_fname[len(str(translator.builder.outdir)) + 1:]
|
|
|
|
if isNewer(dst_fname, src_fname):
|
|
kernellog.verbose(app,
|
|
"convert: {out}/%s already exists and is newer" % _name)
|
|
|
|
else:
|
|
ok = False
|
|
mkdir(path.dirname(dst_fname))
|
|
|
|
if in_ext == '.dot':
|
|
kernellog.verbose(app, 'convert DOT to: {out}/' + _name)
|
|
if translator.builder.format == 'latex' and not dot_Tpdf:
|
|
svg_fname = path.join(translator.builder.outdir, fname + '.svg')
|
|
ok1 = dot2format(app, src_fname, svg_fname)
|
|
ok2 = svg2pdf_by_rsvg(app, svg_fname, dst_fname)
|
|
ok = ok1 and ok2
|
|
|
|
else:
|
|
ok = dot2format(app, src_fname, dst_fname)
|
|
|
|
elif in_ext == '.svg':
|
|
kernellog.verbose(app, 'convert SVG to: {out}/' + _name)
|
|
ok = svg2pdf(app, src_fname, dst_fname)
|
|
|
|
if not ok:
|
|
img_node.replace_self(file2literal(src_fname))
|
|
|
|
|
|
def dot2format(app, dot_fname, out_fname):
|
|
"""Converts DOT file to ``out_fname`` using ``dot(1)``.
|
|
|
|
* ``dot_fname`` pathname of the input DOT file, including extension ``.dot``
|
|
* ``out_fname`` pathname of the output file, including format extension
|
|
|
|
The *format extension* depends on the ``dot`` command (see ``man dot``
|
|
option ``-Txxx``). Normally you will use one of the following extensions:
|
|
|
|
- ``.ps`` for PostScript,
|
|
- ``.svg`` or ``svgz`` for Structured Vector Graphics,
|
|
- ``.fig`` for XFIG graphics and
|
|
- ``.png`` or ``gif`` for common bitmap graphics.
|
|
|
|
"""
|
|
out_format = path.splitext(out_fname)[1][1:]
|
|
cmd = [dot_cmd, '-T%s' % out_format, dot_fname]
|
|
exit_code = 42
|
|
|
|
with open(out_fname, "w") as out:
|
|
exit_code = subprocess.call(cmd, stdout = out)
|
|
if exit_code != 0:
|
|
kernellog.warn(app,
|
|
"Error #%d when calling: %s" % (exit_code, " ".join(cmd)))
|
|
return bool(exit_code == 0)
|
|
|
|
def svg2pdf(app, svg_fname, pdf_fname):
|
|
"""Converts SVG to PDF with ``inkscape(1)`` or ``convert(1)`` command.
|
|
|
|
Uses ``inkscape(1)`` from Inkscape (https://inkscape.org/) or ``convert(1)``
|
|
from ImageMagick (https://www.imagemagick.org) for conversion.
|
|
Returns ``True`` on success and ``False`` if an error occurred.
|
|
|
|
* ``svg_fname`` pathname of the input SVG file with extension (``.svg``)
|
|
* ``pdf_name`` pathname of the output PDF file with extension (``.pdf``)
|
|
|
|
"""
|
|
cmd = [convert_cmd, svg_fname, pdf_fname]
|
|
cmd_name = 'convert(1)'
|
|
|
|
if inkscape_cmd:
|
|
cmd_name = 'inkscape(1)'
|
|
if inkscape_ver_one:
|
|
cmd = [inkscape_cmd, '-o', pdf_fname, svg_fname]
|
|
else:
|
|
cmd = [inkscape_cmd, '-z', '--export-pdf=%s' % pdf_fname, svg_fname]
|
|
|
|
try:
|
|
warning_msg = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
|
exit_code = 0
|
|
except subprocess.CalledProcessError as err:
|
|
warning_msg = err.output
|
|
exit_code = err.returncode
|
|
pass
|
|
|
|
if exit_code != 0:
|
|
kernellog.warn(app, "Error #%d when calling: %s" % (exit_code, " ".join(cmd)))
|
|
if warning_msg:
|
|
kernellog.warn(app, "Warning msg from %s: %s"
|
|
% (cmd_name, str(warning_msg, 'utf-8')))
|
|
elif warning_msg:
|
|
kernellog.verbose(app, "Warning msg from %s (likely harmless):\n%s"
|
|
% (cmd_name, str(warning_msg, 'utf-8')))
|
|
|
|
return bool(exit_code == 0)
|
|
|
|
def svg2pdf_by_rsvg(app, svg_fname, pdf_fname):
|
|
"""Convert SVG to PDF with ``rsvg-convert(1)`` command.
|
|
|
|
* ``svg_fname`` pathname of input SVG file, including extension ``.svg``
|
|
* ``pdf_fname`` pathname of output PDF file, including extension ``.pdf``
|
|
|
|
Input SVG file should be the one generated by ``dot2format()``.
|
|
SVG -> PDF conversion is done by ``rsvg-convert(1)``.
|
|
|
|
If ``rsvg-convert(1)`` is unavailable, fall back to ``svg2pdf()``.
|
|
|
|
"""
|
|
|
|
if rsvg_convert_cmd is None:
|
|
ok = svg2pdf(app, svg_fname, pdf_fname)
|
|
else:
|
|
cmd = [rsvg_convert_cmd, '--format=pdf', '-o', pdf_fname, svg_fname]
|
|
# use stdout and stderr from parent
|
|
exit_code = subprocess.call(cmd)
|
|
if exit_code != 0:
|
|
kernellog.warn(app, "Error #%d when calling: %s" % (exit_code, " ".join(cmd)))
|
|
ok = bool(exit_code == 0)
|
|
|
|
return ok
|
|
|
|
|
|
# image handling
|
|
# ---------------------
|
|
|
|
def visit_kernel_image(self, node): # pylint: disable=W0613
|
|
"""Visitor of the ``kernel_image`` Node.
|
|
|
|
Handles the ``image`` child-node with the ``convert_image(...)``.
|
|
"""
|
|
img_node = node[0]
|
|
convert_image(img_node, self)
|
|
|
|
class kernel_image(nodes.image):
|
|
"""Node for ``kernel-image`` directive."""
|
|
pass
|
|
|
|
class KernelImage(images.Image):
|
|
u"""KernelImage directive
|
|
|
|
Earns everything from ``.. image::`` directive, except *remote URI* and
|
|
*glob* pattern. The KernelImage wraps a image node into a
|
|
kernel_image node. See ``visit_kernel_image``.
|
|
"""
|
|
|
|
def run(self):
|
|
uri = self.arguments[0]
|
|
if uri.endswith('.*') or uri.find('://') != -1:
|
|
raise self.severe(
|
|
'Error in "%s: %s": glob pattern and remote images are not allowed'
|
|
% (self.name, uri))
|
|
result = images.Image.run(self)
|
|
if len(result) == 2 or isinstance(result[0], nodes.system_message):
|
|
return result
|
|
(image_node,) = result
|
|
# wrap image node into a kernel_image node / see visitors
|
|
node = kernel_image('', image_node)
|
|
return [node]
|
|
|
|
# figure handling
|
|
# ---------------------
|
|
|
|
def visit_kernel_figure(self, node): # pylint: disable=W0613
|
|
"""Visitor of the ``kernel_figure`` Node.
|
|
|
|
Handles the ``image`` child-node with the ``convert_image(...)``.
|
|
"""
|
|
img_node = node[0][0]
|
|
convert_image(img_node, self)
|
|
|
|
class kernel_figure(nodes.figure):
|
|
"""Node for ``kernel-figure`` directive."""
|
|
|
|
class KernelFigure(Figure):
|
|
u"""KernelImage directive
|
|
|
|
Earns everything from ``.. figure::`` directive, except *remote URI* and
|
|
*glob* pattern. The KernelFigure wraps a figure node into a kernel_figure
|
|
node. See ``visit_kernel_figure``.
|
|
"""
|
|
|
|
def run(self):
|
|
uri = self.arguments[0]
|
|
if uri.endswith('.*') or uri.find('://') != -1:
|
|
raise self.severe(
|
|
'Error in "%s: %s":'
|
|
' glob pattern and remote images are not allowed'
|
|
% (self.name, uri))
|
|
result = Figure.run(self)
|
|
if len(result) == 2 or isinstance(result[0], nodes.system_message):
|
|
return result
|
|
(figure_node,) = result
|
|
# wrap figure node into a kernel_figure node / see visitors
|
|
node = kernel_figure('', figure_node)
|
|
return [node]
|
|
|
|
|
|
# render handling
|
|
# ---------------------
|
|
|
|
def visit_kernel_render(self, node):
|
|
"""Visitor of the ``kernel_render`` Node.
|
|
|
|
If rendering tools available, save the markup of the ``literal_block`` child
|
|
node into a file and replace the ``literal_block`` node with a new created
|
|
``image`` node, pointing to the saved markup file. Afterwards, handle the
|
|
image child-node with the ``convert_image(...)``.
|
|
"""
|
|
app = self.builder.app
|
|
srclang = node.get('srclang')
|
|
|
|
kernellog.verbose(app, 'visit kernel-render node lang: "%s"' % (srclang))
|
|
|
|
tmp_ext = RENDER_MARKUP_EXT.get(srclang, None)
|
|
if tmp_ext is None:
|
|
kernellog.warn(app, 'kernel-render: "%s" unknown / include raw.' % (srclang))
|
|
return
|
|
|
|
if not dot_cmd and tmp_ext == '.dot':
|
|
kernellog.verbose(app, "dot from graphviz not available / include raw.")
|
|
return
|
|
|
|
literal_block = node[0]
|
|
|
|
code = literal_block.astext()
|
|
hashobj = code.encode('utf-8') # str(node.attributes)
|
|
fname = path.join('%s-%s' % (srclang, sha1(hashobj).hexdigest()))
|
|
|
|
tmp_fname = path.join(
|
|
self.builder.outdir, self.builder.imagedir, fname + tmp_ext)
|
|
|
|
if not path.isfile(tmp_fname):
|
|
mkdir(path.dirname(tmp_fname))
|
|
with open(tmp_fname, "w") as out:
|
|
out.write(code)
|
|
|
|
img_node = nodes.image(node.rawsource, **node.attributes)
|
|
img_node['uri'] = path.join(self.builder.imgpath, fname + tmp_ext)
|
|
img_node['candidates'] = {
|
|
'*': path.join(self.builder.imgpath, fname + tmp_ext)}
|
|
|
|
literal_block.replace_self(img_node)
|
|
convert_image(img_node, self, tmp_fname)
|
|
|
|
|
|
class kernel_render(nodes.General, nodes.Inline, nodes.Element):
|
|
"""Node for ``kernel-render`` directive."""
|
|
pass
|
|
|
|
class KernelRender(Figure):
|
|
u"""KernelRender directive
|
|
|
|
Render content by external tool. Has all the options known from the
|
|
*figure* directive, plus option ``caption``. If ``caption`` has a
|
|
value, a figure node with the *caption* is inserted. If not, a image node is
|
|
inserted.
|
|
|
|
The KernelRender directive wraps the text of the directive into a
|
|
literal_block node and wraps it into a kernel_render node. See
|
|
``visit_kernel_render``.
|
|
"""
|
|
has_content = True
|
|
required_arguments = 1
|
|
optional_arguments = 0
|
|
final_argument_whitespace = False
|
|
|
|
# earn options from 'figure'
|
|
option_spec = Figure.option_spec.copy()
|
|
option_spec['caption'] = directives.unchanged
|
|
|
|
def run(self):
|
|
return [self.build_node()]
|
|
|
|
def build_node(self):
|
|
|
|
srclang = self.arguments[0].strip()
|
|
if srclang not in RENDER_MARKUP_EXT.keys():
|
|
return [self.state_machine.reporter.warning(
|
|
'Unknown source language "%s", use one of: %s.' % (
|
|
srclang, ",".join(RENDER_MARKUP_EXT.keys())),
|
|
line=self.lineno)]
|
|
|
|
code = '\n'.join(self.content)
|
|
if not code.strip():
|
|
return [self.state_machine.reporter.warning(
|
|
'Ignoring "%s" directive without content.' % (
|
|
self.name),
|
|
line=self.lineno)]
|
|
|
|
node = kernel_render()
|
|
node['alt'] = self.options.get('alt','')
|
|
node['srclang'] = srclang
|
|
literal_node = nodes.literal_block(code, code)
|
|
node += literal_node
|
|
|
|
caption = self.options.get('caption')
|
|
if caption:
|
|
# parse caption's content
|
|
parsed = nodes.Element()
|
|
self.state.nested_parse(
|
|
ViewList([caption], source=''), self.content_offset, parsed)
|
|
caption_node = nodes.caption(
|
|
parsed[0].rawsource, '', *parsed[0].children)
|
|
caption_node.source = parsed[0].source
|
|
caption_node.line = parsed[0].line
|
|
|
|
figure_node = nodes.figure('', node)
|
|
for k,v in self.options.items():
|
|
figure_node[k] = v
|
|
figure_node += caption_node
|
|
|
|
node = figure_node
|
|
|
|
return node
|
|
|
|
def add_kernel_figure_to_std_domain(app, doctree):
|
|
"""Add kernel-figure anchors to 'std' domain.
|
|
|
|
The ``StandardDomain.process_doc(..)`` method does not know how to resolve
|
|
the caption (label) of ``kernel-figure`` directive (it only knows about
|
|
standard nodes, e.g. table, figure etc.). Without any additional handling
|
|
this will result in a 'undefined label' for kernel-figures.
|
|
|
|
This handle adds labels of kernel-figure to the 'std' domain labels.
|
|
"""
|
|
|
|
std = app.env.domains["std"]
|
|
docname = app.env.docname
|
|
labels = std.data["labels"]
|
|
|
|
for name, explicit in doctree.nametypes.items():
|
|
if not explicit:
|
|
continue
|
|
labelid = doctree.nameids[name]
|
|
if labelid is None:
|
|
continue
|
|
node = doctree.ids[labelid]
|
|
|
|
if node.tagname == 'kernel_figure':
|
|
for n in node.next_node():
|
|
if n.tagname == 'caption':
|
|
sectname = clean_astext(n)
|
|
# add label to std domain
|
|
labels[name] = docname, labelid, sectname
|
|
break
|