diff options
Diffstat (limited to '')
33 files changed, 3147 insertions, 2622 deletions
diff --git a/doc/usage/advanced/intl.rst b/doc/usage/advanced/intl.rst index ae6e7dc..e858c3c 100644 --- a/doc/usage/advanced/intl.rst +++ b/doc/usage/advanced/intl.rst @@ -27,7 +27,7 @@ Sphinx uses these facilities to translate whole documents. Initially project maintainers have to collect all translatable strings (also referred to as *messages*) to make them known to translators. Sphinx extracts -these through invocation of ``sphinx-build -b gettext``. +these through invocation of ``sphinx-build -M gettext``. Every single element in the doctree will end up in a single message which results in lists being equally split into different chunks while large diff --git a/doc/usage/advanced/websupport/quickstart.rst b/doc/usage/advanced/websupport/quickstart.rst index 1cdd23f..e7c2b51 100644 --- a/doc/usage/advanced/websupport/quickstart.rst +++ b/doc/usage/advanced/websupport/quickstart.rst @@ -137,7 +137,7 @@ add this data to the ``COMMENT_OPTIONS`` that are used in the template. This only works if your documentation is served from your document root. If it is served from another directory, you will - need to prefix the url route with that directory, and give the `docroot` + need to prefix the url route with that directory, and give the *docroot* keyword argument when creating the web support object:: support = WebSupport(..., docroot='docs') @@ -150,7 +150,7 @@ Performing Searches To use the search form built-in to the Sphinx sidebar, create a function to handle requests to the URL 'search' relative to the documentation root. The -user's search query will be in the GET parameters, with the key `q`. Then use +user's search query will be in the GET parameters, with the key ``q``. Then use the :meth:`~sphinxcontrib.websupport.WebSupport.get_search_results` method to retrieve search results. In `Flask <https://flask.palletsprojects.com/>`_ that would be like this:: diff --git a/doc/usage/advanced/websupport/searchadapters.rst b/doc/usage/advanced/websupport/searchadapters.rst index 262d666..ad7a11c 100644 --- a/doc/usage/advanced/websupport/searchadapters.rst +++ b/doc/usage/advanced/websupport/searchadapters.rst @@ -7,7 +7,7 @@ Search Adapters To create a custom search adapter you will need to subclass the :class:`BaseSearch` class. Then create an instance of the new class and pass -that as the `search` keyword argument when you create the :class:`~.WebSupport` +that as the *search* keyword argument when you create the :class:`~.WebSupport` object:: support = WebSupport(srcdir=srcdir, diff --git a/doc/usage/advanced/websupport/storagebackends.rst b/doc/usage/advanced/websupport/storagebackends.rst index ccb00b6..c50edf8 100644 --- a/doc/usage/advanced/websupport/storagebackends.rst +++ b/doc/usage/advanced/websupport/storagebackends.rst @@ -7,7 +7,7 @@ Storage Backends To create a custom storage backend you will need to subclass the :class:`StorageBackend` class. Then create an instance of the new class and -pass that as the `storage` keyword argument when you create the +pass that as the *storage* keyword argument when you create the :class:`~.WebSupport` object:: support = WebSupport(srcdir=srcdir, diff --git a/doc/usage/builders/index.rst b/doc/usage/builders/index.rst index ce2c5dc..9c538ee 100644 --- a/doc/usage/builders/index.rst +++ b/doc/usage/builders/index.rst @@ -10,9 +10,62 @@ Builders These are the built-in Sphinx builders. More builders can be added by :doc:`extensions </usage/extensions/index>`. -The builder's "name" must be given to the **-b** command-line option of +The builder's "name" must be given to the **-M** or **-b** command-line options of :program:`sphinx-build` to select a builder. +The most common builders are: + +**html** + Build HTML pages. This is the default builder. + +**dirhtml** + Build HTML pages, but with a single directory per document. Makes for + prettier URLs (no ``.html``) if served from a webserver. + +**singlehtml** + Build a single HTML with the whole content. + +**htmlhelp**, **qthelp**, **devhelp**, **epub** + Build HTML files with additional information for building a documentation + collection in one of these formats. + +**applehelp** + Build an Apple Help Book. Requires :program:`hiutil` and + :program:`codesign`, which are not Open Source and presently only + available on Mac OS X 10.6 and higher. + +**latex** + Build LaTeX sources that can be compiled to a PDF document using + :program:`pdflatex`. + +**man** + Build manual pages in groff format for UNIX systems. + +**texinfo** + Build Texinfo files that can be processed into Info files using + :program:`makeinfo`. + +**text** + Build plain text files. + +**gettext** + Build gettext-style message catalogs (``.pot`` files). + +**doctest** + Run all doctests in the documentation, if the :mod:`~sphinx.ext.doctest` + extension is enabled. + +**linkcheck** + Check the integrity of all external links. + +**xml** + Build Docutils-native XML files. + +**pseudoxml** + Build compact pretty-printed "pseudo-XML" files displaying the + internal structure of the intermediate document trees. + +-------------- .. module:: sphinx.builders.html .. class:: StandaloneHTMLBuilder @@ -146,7 +199,7 @@ The builder's "name" must be given to the **-b** command-line option of This builder produces the same output as the standalone HTML builder, but also generates an *epub* file for ebook readers. See :ref:`epub-faq` for details about it. For definition of the epub format, have a look at - `<http://idpf.org/epub>`_ or `<https://en.wikipedia.org/wiki/EPUB>`_. + `<https://idpf.org/epub>`_ or `<https://en.wikipedia.org/wiki/EPUB>`_. The builder creates *EPUB 3* files. .. autoattribute:: name @@ -300,8 +353,8 @@ name is ``rinoh``. Refer to the `rinohtype manual`_ for details. .. class:: SerializingHTMLBuilder This builder uses a module that implements the Python serialization API - (`pickle`, `simplejson`, `phpserialize`, and others) to dump the generated - HTML documentation. The pickle builder is a subclass of it. + (``pickle``, ``simplejson``, ``phpserialize``, and others) to dump the + generated HTML documentation. The pickle builder is a subclass of it. A concrete subclass of this builder serializing to the `PHP serialization`_ format could look like this:: @@ -319,10 +372,10 @@ name is ``rinoh``. Refer to the `rinohtype manual`_ for details. .. attribute:: implementation - A module that implements `dump()`, `load()`, `dumps()` and `loads()` + A module that implements ``dump()``, ``load()``, ``dumps()`` and ``loads()`` functions that conform to the functions with the same names from the pickle module. Known modules implementing this interface are - `simplejson`, `phpserialize`, `plistlib`, and others. + ``simplejson``, ``phpserialize``, ``plistlib``, and others. .. attribute:: out_suffix @@ -400,9 +453,9 @@ name is ``rinoh``. Refer to the `rinohtype manual`_ for details. .. class:: ChangesBuilder This builder produces an HTML overview of all :rst:dir:`versionadded`, - :rst:dir:`versionchanged` and :rst:dir:`deprecated` directives for the - current :confval:`version`. This is useful to generate a ChangeLog file, for - example. + :rst:dir:`versionchanged`, :rst:dir:`deprecated` and :rst:dir:`versionremoved` + directives for the current :confval:`version`. This is useful to generate a + changelog file, for example. .. autoattribute:: name diff --git a/doc/usage/configuration.rst b/doc/usage/configuration.rst index d440132..a27107f 100644 --- a/doc/usage/configuration.rst +++ b/doc/usage/configuration.rst @@ -228,6 +228,7 @@ General configuration are matched against the source file names relative to the source directory, using slashes as directory separators on all platforms. The default is ``**``, meaning that all files are recursively included from the source directory. + :confval:`exclude_patterns` has priority over :confval:`include_patterns`. Example patterns: @@ -292,7 +293,7 @@ General configuration .. index:: default; domain primary; domain - The name of the default :doc:`domain </usage/restructuredtext/domains>`. + The name of the default :doc:`domain </usage/domains/index>`. Can also be ``None`` to disable a default domain. The default is ``'py'``. Those objects in other domains (whether the domain name is given explicitly, or selected by a :rst:dir:`default-domain` directive) will have the domain @@ -325,18 +326,26 @@ General configuration .. versionadded:: 0.5 +.. confval:: show_warning_types + + If ``True``, the type of each warning is added as a suffix to the warning message, + e.g., ``WARNING: [...] [index]`` or ``WARNING: [...] [toc.circular]``. + The default is ``False``. + + .. versionadded:: 7.3.0 + .. confval:: suppress_warnings A list of warning types to suppress arbitrary warning messages. - Sphinx supports following warning types: + Sphinx core supports following warning types: * ``app.add_node`` * ``app.add_directive`` * ``app.add_role`` * ``app.add_generic_role`` * ``app.add_source_parser`` - * ``autosectionlabel.*`` + * ``config.cache`` * ``download.not_readable`` * ``epub.unknown_project_files`` * ``epub.duplicated_toc_entry`` @@ -358,11 +367,18 @@ General configuration * ``toc.not_readable`` * ``toc.secnum`` + Extensions can also define their own warning types. + Those defined by the first-party ``sphinx.ext`` extensions are: + + * ``autodoc`` + * ``autodoc.import_object`` + * ``autosectionlabel.<document name>`` + * ``autosummary`` + * ``intersphinx.external`` + You can choose from these types. You can also give only the first component to exclude all warnings attached to it. - Now, this option should be considered *experimental*. - .. versionadded:: 1.4 .. versionchanged:: 1.5 @@ -379,7 +395,7 @@ General configuration .. versionchanged:: 2.1 - Added ``autosectionlabel.*`` + Added ``autosectionlabel.<document name>`` .. versionchanged:: 3.3.0 @@ -393,9 +409,13 @@ General configuration Added ``i18n.inconsistent_references`` - .. versionadded:: 7.1 + .. versionadded:: 7.1 - Added ``index`` warning type. + Added ``index`` warning type. + + .. versionadded:: 7.3 + + Added ``config.cache`` warning type. .. confval:: needs_sphinx @@ -1178,7 +1198,7 @@ that use Sphinx's HTMLWriter class. ('print.css', {'media': 'print'})] As a special attribute, *priority* can be set as an integer to load the CSS - file earlier or lazier step. For more information, refer + file at an earlier or lazier step. For more information, refer :meth:`.Sphinx.add_css_file()`. .. versionadded:: 1.8 @@ -1200,9 +1220,9 @@ that use Sphinx's HTMLWriter class. 'https://example.com/scripts/custom.js', ('custom.js', {'async': 'async'})] - As a special attribute, *priority* can be set as an integer to load the CSS - file earlier or lazier step. For more information, refer - :meth:`.Sphinx.add_css_file()`. + As a special attribute, *priority* can be set as an integer to load the + JavaScript file at an earlier or lazier step. For more information, refer + :meth:`.Sphinx.add_js_file()`. .. versionadded:: 1.8 .. versionchanged:: 3.5 @@ -1591,7 +1611,41 @@ that use Sphinx's HTMLWriter class. The name of a JavaScript file (relative to the configuration directory) that implements a search results scorer. If empty, the default will be used. - .. XXX describe interface for scorer here + The scorer must implement the following interface, + and may optionally define the ``score()`` function for more granular control. + + .. code-block:: javascript + + const Scorer = { + // Implement the following function to further tweak the score for each result + score: result => { + const [docName, title, anchor, descr, score, filename] = result + + // ... calculate a new score ... + return score + }, + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: { + 0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5, // used to be unimportantResults + }, + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + + // query found in terms + term: 5, + partialTerm: 2, + }; .. versionadded:: 1.2 @@ -1641,7 +1695,7 @@ Options for Single HTML output .. confval:: singlehtml_sidebars Custom sidebar templates, must be a dictionary that maps document names to - template names. And it only allows a key named `'index'`. All other keys + template names. And it only allows a key named ``'index'``. All other keys are ignored. For more information, refer to :confval:`html_sidebars`. By default, it is same as :confval:`html_sidebars`. @@ -1963,7 +2017,7 @@ the `Dublin Core metadata <https://dublincore.org/>`_. Meta data for the guide element of :file:`content.opf`. This is a sequence of tuples containing the *type*, the *uri* and the *title* of the optional guide information. See the OPF documentation - at `<http://idpf.org/epub>`_ for details. If possible, default entries + at `<https://idpf.org/epub>`_ for details. If possible, default entries for the *cover* and *toc* types are automatically inserted. However, the types can be explicitly overwritten if the default entries are not appropriate. Example:: @@ -2366,7 +2420,7 @@ These options influence LaTeX output. usage). This means that words with UTF-8 characters will get ordered correctly for the :confval:`language`. - __ http://xindy.sourceforge.net/ + __ https://xindy.sourceforge.net/ - This option is ignored if :confval:`latex_engine` is ``'platex'`` (Japanese documents; :program:`mendex` replaces :program:`makeindex` @@ -2742,7 +2796,7 @@ Options for the linkcheck builder A list of regular expressions that match URIs that should not be checked when doing a ``linkcheck`` build. Example:: - linkcheck_ignore = [r'http://localhost:\d+/'] + linkcheck_ignore = [r'https://localhost:\d+/'] .. versionadded:: 1.1 @@ -2804,8 +2858,8 @@ Options for the linkcheck builder .. confval:: linkcheck_timeout - A timeout value, in seconds, for the linkcheck builder. The default is to - use Python's global socket timeout. + The duration, in seconds, that the linkcheck builder will wait for a + response after each hyperlink request. Defaults to 30 seconds. .. versionadded:: 1.1 @@ -2896,7 +2950,8 @@ Options for the linkcheck builder Otherwise, ``linkcheck`` waits for a minute before to retry and keeps doubling the wait time between attempts until it succeeds or exceeds the - ``linkcheck_rate_limit_timeout``. By default, the timeout is 5 minutes. + ``linkcheck_rate_limit_timeout``. By default, the timeout is 300 seconds + and custom timeouts should be given in seconds. .. _Retry-After: https://datatracker.ietf.org/doc/html/rfc7231#section-7.1.3 @@ -2915,6 +2970,33 @@ Options for the linkcheck builder .. versionadded:: 4.4 +.. confval:: linkcheck_allow_unauthorized + + When a webserver responds with an HTTP 401 (unauthorized) response, the + current default behaviour of Sphinx is to treat the link as "working". To + change that behaviour, set this option to ``False``. + + The default value for this option will be changed in Sphinx 8.0; from that + version onwards, HTTP 401 responses to checked hyperlinks will be treated + as "broken" by default. + + .. versionadded:: 7.3 + +.. confval:: linkcheck_report_timeouts_as_broken + + When an HTTP response is not received from a webserver before the configured + :confval:`linkcheck_timeout` expires, + the current default behaviour of Sphinx is to treat the link as 'broken'. + To report timeouts using a distinct report code of ``timeout``, + set :confval:`linkcheck_report_timeouts_as_broken` to ``False``. + + From Sphinx 8.0 onwards, timeouts that occur while checking hyperlinks + will be reported using the new 'timeout' status code. + + .. xref RemovedInSphinx80Warning + + .. versionadded:: 7.3 + Options for the XML builder --------------------------- @@ -3066,7 +3148,7 @@ Options for the Python domain for the latter, the signature length ignores the length of the type parameters list. - For instance, with `python_maximum_signature_line_length = 20`, + For instance, with ``python_maximum_signature_line_length = 20``, only the list of type parameters will be wrapped while the arguments list will be rendered on a single line diff --git a/doc/usage/domains/c.rst b/doc/usage/domains/c.rst new file mode 100644 index 0000000..3c1a41d --- /dev/null +++ b/doc/usage/domains/c.rst @@ -0,0 +1,367 @@ +.. highlight:: rst + +============ +The C Domain +============ + +.. versionadded:: 1.0 + +The C domain (name **c**) is suited for documentation of C API. + +.. rst:directive:: .. c:member:: declaration + .. c:var:: declaration + + Describes a C struct member or variable. Example signature:: + + .. c:member:: PyObject *PyTypeObject.tp_bases + + The difference between the two directives is only cosmetic. + +.. rst:directive:: .. c:function:: function prototype + + Describes a C function. The signature should be given as in C, e.g.:: + + .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) + + Note that you don't have to backslash-escape asterisks in the signature, as + it is not parsed by the reST inliner. + + In the description of a function you can use the following info fields + (see also :ref:`info-field-lists`). + + * ``param``, ``parameter``, ``arg``, ``argument``, + Description of a parameter. + * ``type``: Type of a parameter, + written as if passed to the :rst:role:`c:expr` role. + * ``returns``, ``return``: Description of the return value. + * ``rtype``: Return type, + written as if passed to the :rst:role:`c:expr` role. + * ``retval``, ``retvals``: An alternative to ``returns`` for describing + the result of the function. + + .. versionadded:: 4.3 + The ``retval`` field type. + + For example:: + + .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) + + :param type: description of the first parameter. + :param nitems: description of the second parameter. + :returns: a result. + :retval NULL: under some conditions. + :retval NULL: under some other conditions as well. + + which renders as + + .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) + + .. + ** for some editors (e.g., vim) to stop bold-highlighting the source + + :no-contents-entry: + :no-index-entry: + :param type: description of the first parameter. + :param nitems: description of the second parameter. + :returns: a result. + :retval NULL: under some conditions. + :retval NULL: under some other conditions as well. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's parameters will be emitted on a single logical + line, overriding :confval:`c_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + +.. rst:directive:: .. c:macro:: name + .. c:macro:: name(arg list) + + Describes a C macro, i.e., a C-language ``#define``, without the replacement + text. + + In the description of a macro you can use the same info fields as for the + :rst:dir:`c:function` directive. + + .. versionadded:: 3.0 + The function style variant. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the macro's parameters will be emitted on a single logical + line, overriding :confval:`c_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. c:struct:: name + + Describes a C struct. + + .. versionadded:: 3.0 + +.. rst:directive:: .. c:union:: name + + Describes a C union. + + .. versionadded:: 3.0 + +.. rst:directive:: .. c:enum:: name + + Describes a C enum. + + .. versionadded:: 3.0 + +.. rst:directive:: .. c:enumerator:: name + + Describes a C enumerator. + + .. versionadded:: 3.0 + +.. rst:directive:: .. c:type:: typedef-like declaration + .. c:type:: name + + Describes a C type, either as a typedef, or the alias for an unspecified + type. + +.. _c-roles: + +Cross-referencing C constructs +------------------------------ + +The following roles create cross-references to C-language constructs if they +are defined in the documentation: + +.. rst:role:: c:member + c:data + c:var + c:func + c:macro + c:struct + c:union + c:enum + c:enumerator + c:type + + Reference a C declaration, as defined above. + Note that :rst:role:`c:member`, :rst:role:`c:data`, and + :rst:role:`c:var` are equivalent. + + .. versionadded:: 3.0 + The var, struct, union, enum, and enumerator roles. + + +Anonymous Entities +------------------ + +C supports anonymous structs, enums, and unions. +For the sake of documentation they must be given some name that starts with +``@``, e.g., ``@42`` or ``@data``. +These names can also be used in cross-references, +though nested symbols will be found even when omitted. +The ``@...`` name will always be rendered as **[anonymous]** (possibly as a +link). + +Example:: + + .. c:struct:: Data + + .. c:union:: @data + + .. c:var:: int a + + .. c:var:: double b + + Explicit ref: :c:var:`Data.@data.a`. Short-hand ref: :c:var:`Data.a`. + +This will be rendered as: + +.. c:struct:: Data + :no-contents-entry: + :no-index-entry: + + .. c:union:: @data + :no-contents-entry: + :no-index-entry: + + .. c:var:: int a + :no-contents-entry: + :no-index-entry: + + .. c:var:: double b + :no-contents-entry: + :no-index-entry: + +Explicit ref: :c:var:`Data.@data.a`. Short-hand ref: :c:var:`Data.a`. + +.. versionadded:: 3.0 + + +Aliasing Declarations +--------------------- + +.. c:namespace-push:: @alias + +Sometimes it may be helpful list declarations elsewhere than their main +documentation, e.g., when creating a synopsis of an interface. +The following directive can be used for this purpose. + +.. rst:directive:: .. c:alias:: name + + Insert one or more alias declarations. Each entity can be specified + as they can in the :rst:role:`c:any` role. + + For example:: + + .. c:var:: int data + .. c:function:: int f(double k) + + .. c:alias:: data + f + + becomes + + .. c:var:: int data + :no-contents-entry: + :no-index-entry: + + .. c:function:: int f(double k) + :no-contents-entry: + :no-index-entry: + + .. c:alias:: data + f + + .. versionadded:: 3.2 + + + .. rubric:: Options + + .. rst:directive:option:: maxdepth: int + + Insert nested declarations as well, up to the total depth given. + Use 0 for infinite depth and 1 for just the mentioned declaration. + Defaults to 1. + + .. versionadded:: 3.3 + + .. rst:directive:option:: noroot + + Skip the mentioned declarations and only render nested declarations. + Requires ``maxdepth`` either 0 or at least 2. + + .. versionadded:: 3.5 + + +.. c:namespace-pop:: + + +Inline Expressions and Types +---------------------------- + +.. rst:role:: c:expr + c:texpr + + Insert a C expression or type either as inline code (``cpp:expr``) + or inline text (``cpp:texpr``). For example:: + + .. c:var:: int a = 42 + + .. c:function:: int f(int i) + + An expression: :c:expr:`a * f(a)` (or as text: :c:texpr:`a * f(a)`). + + A type: :c:expr:`const Data*` + (or as text :c:texpr:`const Data*`). + + will be rendered as follows: + + .. c:var:: int a = 42 + :no-contents-entry: + :no-index-entry: + + .. c:function:: int f(int i) + :no-contents-entry: + :no-index-entry: + + An expression: :c:expr:`a * f(a)` (or as text: :c:texpr:`a * f(a)`). + + A type: :c:expr:`const Data*` + (or as text :c:texpr:`const Data*`). + + .. versionadded:: 3.0 + + +Namespacing +----------- + +.. versionadded:: 3.1 + +The C language it self does not support namespacing, but it can sometimes be +useful to emulate it in documentation, e.g., to show alternate declarations. +The feature may also be used to document members of structs/unions/enums +separate from their parent declaration. + +The current scope can be changed using three namespace directives. They manage +a stack declarations where ``c:namespace`` resets the stack and changes a given +scope. + +The ``c:namespace-push`` directive changes the scope to a given inner scope +of the current one. + +The ``c:namespace-pop`` directive undoes the most recent +``c:namespace-push`` directive. + +.. rst:directive:: .. c:namespace:: scope specification + + Changes the current scope for the subsequent objects to the given scope, and + resets the namespace directive stack. Note that nested scopes can be + specified by separating with a dot, e.g.:: + + .. c:namespace:: Namespace1.Namespace2.SomeStruct.AnInnerStruct + + All subsequent objects will be defined as if their name were declared with + the scope prepended. The subsequent cross-references will be searched for + starting in the current scope. + + Using ``NULL`` or ``0`` as the scope will change to global scope. + +.. rst:directive:: .. c:namespace-push:: scope specification + + Change the scope relatively to the current scope. For example, after:: + + .. c:namespace:: A.B + + .. c:namespace-push:: C.D + + the current scope will be ``A.B.C.D``. + +.. rst:directive:: .. c:namespace-pop:: + + Undo the previous ``c:namespace-push`` directive (*not* just pop a scope). + For example, after:: + + .. c:namespace:: A.B + + .. c:namespace-push:: C.D + + .. c:namespace-pop:: + + the current scope will be ``A.B`` (*not* ``A.B.C``). + + If no previous ``c:namespace-push`` directive has been used, but only a + ``c:namespace`` directive, then the current scope will be reset to global + scope. That is, ``.. c:namespace:: A.B`` is equivalent to:: + + .. c:namespace:: NULL + + .. c:namespace-push:: A.B + +Configuration Variables +----------------------- + +See :ref:`c-config`. diff --git a/doc/usage/domains/cpp.rst b/doc/usage/domains/cpp.rst new file mode 100644 index 0000000..6c9372b --- /dev/null +++ b/doc/usage/domains/cpp.rst @@ -0,0 +1,760 @@ +.. highlight:: rst + +============== +The C++ Domain +============== + +.. versionadded:: 1.0 + +The C++ domain (name **cpp**) supports documenting C++ projects. + +Directives for Declaring Entities +--------------------------------- + +The following directives are available. All declarations can start with a +visibility statement (``public``, ``private`` or ``protected``). + +.. rst:directive:: .. cpp:class:: class specifier + .. cpp:struct:: class specifier + + Describe a class/struct, possibly with specification of inheritance, e.g.,:: + + .. cpp:class:: MyClass : public MyBase, MyOtherBase + + The difference between :rst:dir:`cpp:class` and :rst:dir:`cpp:struct` is + only cosmetic: the prefix rendered in the output, and the specifier shown + in the index. + + The class can be directly declared inside a nested scope, e.g.,:: + + .. cpp:class:: OuterScope::MyClass : public MyBase, MyOtherBase + + A class template can be declared:: + + .. cpp:class:: template<typename T, std::size_t N> std::array + + or with a line break:: + + .. cpp:class:: template<typename T, std::size_t N> \ + std::array + + Full and partial template specialisations can be declared:: + + .. cpp:class:: template<> \ + std::array<bool, 256> + + .. cpp:class:: template<typename T> \ + std::array<T, 42> + + .. versionadded:: 2.0 + The :rst:dir:`cpp:struct` directive. + +.. rst:directive:: .. cpp:function:: (member) function prototype + + Describe a function or member function, e.g.,:: + + .. cpp:function:: bool myMethod(int arg1, std::string arg2) + + A function with parameters and types. + + .. cpp:function:: bool myMethod(int, double) + + A function with unnamed parameters. + + .. cpp:function:: const T &MyClass::operator[](std::size_t i) const + + An overload for the indexing operator. + + .. cpp:function:: operator bool() const + + A casting operator. + + .. cpp:function:: constexpr void foo(std::string &bar[2]) noexcept + + A constexpr function. + + .. cpp:function:: MyClass::MyClass(const MyClass&) = default + + A copy constructor with default implementation. + + Function templates can also be described:: + + .. cpp:function:: template<typename U> \ + void print(U &&u) + + and function template specialisations:: + + .. cpp:function:: template<> \ + void print(int i) + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's parameters will be emitted on a single logical + line, overriding :confval:`cpp_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. cpp:member:: (member) variable declaration + .. cpp:var:: (member) variable declaration + + Describe a variable or member variable, e.g.,:: + + .. cpp:member:: std::string MyClass::myMember + + .. cpp:var:: std::string MyClass::myOtherMember[N][M] + + .. cpp:member:: int a = 42 + + Variable templates can also be described:: + + .. cpp:member:: template<class T> \ + constexpr T pi = T(3.1415926535897932385) + +.. rst:directive:: .. cpp:type:: typedef declaration + .. cpp:type:: name + .. cpp:type:: type alias declaration + + Describe a type as in a typedef declaration, a type alias declaration, or + simply the name of a type with unspecified type, e.g.,:: + + .. cpp:type:: std::vector<int> MyList + + A typedef-like declaration of a type. + + .. cpp:type:: MyContainer::const_iterator + + Declaration of a type alias with unspecified type. + + .. cpp:type:: MyType = std::unordered_map<int, std::string> + + Declaration of a type alias. + + A type alias can also be templated:: + + .. cpp:type:: template<typename T> \ + MyContainer = std::vector<T> + + The example are rendered as follows. + + .. cpp:type:: std::vector<int> MyList + :no-contents-entry: + :no-index-entry: + + A typedef-like declaration of a type. + + .. cpp:type:: MyContainer::const_iterator + :no-contents-entry: + :no-index-entry: + + Declaration of a type alias with unspecified type. + + .. cpp:type:: MyType = std::unordered_map<int, std::string> + :no-contents-entry: + :no-index-entry: + + Declaration of a type alias. + + .. cpp:type:: template<typename T> \ + MyContainer = std::vector<T> + :no-contents-entry: + :no-index-entry: + +.. rst:directive:: .. cpp:enum:: unscoped enum declaration + .. cpp:enum-struct:: scoped enum declaration + .. cpp:enum-class:: scoped enum declaration + + Describe a (scoped) enum, possibly with the underlying type specified. Any + enumerators declared inside an unscoped enum will be declared both in the + enum scope and in the parent scope. Examples:: + + .. cpp:enum:: MyEnum + + An unscoped enum. + + .. cpp:enum:: MySpecificEnum : long + + An unscoped enum with specified underlying type. + + .. cpp:enum-class:: MyScopedEnum + + A scoped enum. + + .. cpp:enum-struct:: protected MyScopedVisibilityEnum : std::underlying_type<MySpecificEnum>::type + + A scoped enum with non-default visibility, and with a specified + underlying type. + +.. rst:directive:: .. cpp:enumerator:: name + .. cpp:enumerator:: name = constant + + Describe an enumerator, optionally with its value defined, e.g.,:: + + .. cpp:enumerator:: MyEnum::myEnumerator + + .. cpp:enumerator:: MyEnum::myOtherEnumerator = 42 + +.. rst:directive:: .. cpp:union:: name + + Describe a union. + + .. versionadded:: 1.8 + +.. rst:directive:: .. cpp:concept:: template-parameter-list name + + .. warning:: The support for concepts is experimental. It is based on the + current draft standard and the Concepts Technical Specification. + The features may change as they evolve. + + Describe a concept. It must have exactly 1 template parameter list. The name + may be a nested name. Example:: + + .. cpp:concept:: template<typename It> std::Iterator + + Proxy to an element of a notional sequence that can be compared, + indirected, or incremented. + + **Notation** + + .. cpp:var:: It r + + An lvalue. + + **Valid Expressions** + + - :cpp:expr:`*r`, when :cpp:expr:`r` is dereferenceable. + - :cpp:expr:`++r`, with return type :cpp:expr:`It&`, when + :cpp:expr:`r` is incrementable. + + This will render as follows: + + .. cpp:concept:: template<typename It> std::Iterator + :no-contents-entry: + :no-index-entry: + + Proxy to an element of a notional sequence that can be compared, + indirected, or incremented. + + **Notation** + + .. cpp:var:: It r + + An lvalue. + + **Valid Expressions** + + - :cpp:expr:`*r`, when :cpp:expr:`r` is dereferenceable. + - :cpp:expr:`++r`, with return type :cpp:expr:`It&`, when :cpp:expr:`r` + is incrementable. + + .. versionadded:: 1.5 + + +Options +~~~~~~~ + +Some directives support options: + +- ``:no-index-entry:`` and ``:no-contents-entry:``, see :ref:`basic-domain-markup`. +- ``:tparam-line-spec:``, for templated declarations. + If specified, each template parameter will be rendered on a separate line. + + .. versionadded:: 1.6 + +Anonymous Entities +------------------ + +C++ supports anonymous namespaces, classes, enums, and unions. +For the sake of documentation they must be given some name that starts with +``@``, e.g., ``@42`` or ``@data``. +These names can also be used in cross-references and (type) expressions, +though nested symbols will be found even when omitted. +The ``@...`` name will always be rendered as **[anonymous]** (possibly as a +link). + +Example:: + + .. cpp:class:: Data + + .. cpp:union:: @data + + .. cpp:var:: int a + + .. cpp:var:: double b + + Explicit ref: :cpp:var:`Data::@data::a`. Short-hand ref: :cpp:var:`Data::a`. + +This will be rendered as: + +.. cpp:class:: Data + :no-contents-entry: + :no-index-entry: + + .. cpp:union:: @data + :no-contents-entry: + :no-index-entry: + + .. cpp:var:: int a + :no-contents-entry: + :no-index-entry: + + .. cpp:var:: double b + :no-contents-entry: + :no-index-entry: + +Explicit ref: :cpp:var:`Data::@data::a`. Short-hand ref: :cpp:var:`Data::a`. + +.. versionadded:: 1.8 + + +Aliasing Declarations +--------------------- + +Sometimes it may be helpful list declarations elsewhere than their main +documentation, e.g., when creating a synopsis of a class interface. +The following directive can be used for this purpose. + +.. rst:directive:: .. cpp:alias:: name or function signature + + Insert one or more alias declarations. Each entity can be specified + as they can in the :rst:role:`cpp:any` role. + If the name of a function is given (as opposed to the complete signature), + then all overloads of the function will be listed. + + For example:: + + .. cpp:alias:: Data::a + overload_example::C::f + + becomes + + .. cpp:alias:: Data::a + overload_example::C::f + + whereas:: + + .. cpp:alias:: void overload_example::C::f(double d) const + void overload_example::C::f(double d) + + becomes + + .. cpp:alias:: void overload_example::C::f(double d) const + void overload_example::C::f(double d) + + .. versionadded:: 2.0 + + + .. rubric:: Options + + .. rst:directive:option:: maxdepth: int + + Insert nested declarations as well, up to the total depth given. + Use 0 for infinite depth and 1 for just the mentioned declaration. + Defaults to 1. + + .. versionadded:: 3.5 + + .. rst:directive:option:: noroot + + Skip the mentioned declarations and only render nested declarations. + Requires ``maxdepth`` either 0 or at least 2. + + .. versionadded:: 3.5 + + +Constrained Templates +--------------------- + +.. warning:: The support for concepts is experimental. It is based on the + current draft standard and the Concepts Technical Specification. + The features may change as they evolve. + +.. note:: Sphinx does not currently support ``requires`` clauses. + +Placeholders +~~~~~~~~~~~~ + +Declarations may use the name of a concept to introduce constrained template +parameters, or the keyword ``auto`` to introduce unconstrained template +parameters:: + + .. cpp:function:: void f(auto &&arg) + + A function template with a single unconstrained template parameter. + + .. cpp:function:: void f(std::Iterator it) + + A function template with a single template parameter, constrained by the + Iterator concept. + +Template Introductions +~~~~~~~~~~~~~~~~~~~~~~ + +Simple constrained function or class templates can be declared with a `template +introduction` instead of a template parameter list:: + + .. cpp:function:: std::Iterator{It} void advance(It &it) + + A function template with a template parameter constrained to be an + Iterator. + + .. cpp:class:: std::LessThanComparable{T} MySortedContainer + + A class template with a template parameter constrained to be + LessThanComparable. + +They are rendered as follows. + +.. cpp:function:: std::Iterator{It} void advance(It &it) + :no-contents-entry: + :no-index-entry: + + A function template with a template parameter constrained to be an Iterator. + +.. cpp:class:: std::LessThanComparable{T} MySortedContainer + :no-contents-entry: + :no-index-entry: + + A class template with a template parameter constrained to be + LessThanComparable. + +Note however that no checking is performed with respect to parameter +compatibility. E.g., ``Iterator{A, B, C}`` will be accepted as an introduction +even though it would not be valid C++. + +Inline Expressions and Types +---------------------------- + +.. rst:role:: cpp:expr + cpp:texpr + + Insert a C++ expression or type either as inline code (``cpp:expr``) + or inline text (``cpp:texpr``). For example:: + + .. cpp:var:: int a = 42 + + .. cpp:function:: int f(int i) + + An expression: :cpp:expr:`a * f(a)` (or as text: :cpp:texpr:`a * f(a)`). + + A type: :cpp:expr:`const MySortedContainer<int>&` + (or as text :cpp:texpr:`const MySortedContainer<int>&`). + + will be rendered as follows: + + .. cpp:var:: int a = 42 + :no-contents-entry: + :no-index-entry: + + .. cpp:function:: int f(int i) + :no-contents-entry: + :no-index-entry: + + An expression: :cpp:expr:`a * f(a)` (or as text: :cpp:texpr:`a * f(a)`). + + A type: :cpp:expr:`const MySortedContainer<int>&` + (or as text :cpp:texpr:`const MySortedContainer<int>&`). + + .. versionadded:: 1.7 + The :rst:role:`cpp:expr` role. + + .. versionadded:: 1.8 + The :rst:role:`cpp:texpr` role. + +Namespacing +----------- + +Declarations in the C++ domain are as default placed in global scope. The +current scope can be changed using three namespace directives. They manage a +stack declarations where ``cpp:namespace`` resets the stack and changes a given +scope. + +The ``cpp:namespace-push`` directive changes the scope to a given inner scope +of the current one. + +The ``cpp:namespace-pop`` directive undoes the most recent +``cpp:namespace-push`` directive. + +.. rst:directive:: .. cpp:namespace:: scope specification + + Changes the current scope for the subsequent objects to the given scope, and + resets the namespace directive stack. Note that the namespace does not need + to correspond to C++ namespaces, but can end in names of classes, e.g.,:: + + .. cpp:namespace:: Namespace1::Namespace2::SomeClass::AnInnerClass + + All subsequent objects will be defined as if their name were declared with + the scope prepended. The subsequent cross-references will be searched for + starting in the current scope. + + Using ``NULL``, ``0``, or ``nullptr`` as the scope will change to global + scope. + + A namespace declaration can also be templated, e.g.,:: + + .. cpp:class:: template<typename T> \ + std::vector + + .. cpp:namespace:: template<typename T> std::vector + + .. cpp:function:: std::size_t size() const + + declares ``size`` as a member function of the class template + ``std::vector``. Equivalently this could have been declared using:: + + .. cpp:class:: template<typename T> \ + std::vector + + .. cpp:function:: std::size_t size() const + + or:: + + .. cpp:class:: template<typename T> \ + std::vector + +.. rst:directive:: .. cpp:namespace-push:: scope specification + + Change the scope relatively to the current scope. For example, after:: + + .. cpp:namespace:: A::B + + .. cpp:namespace-push:: C::D + + the current scope will be ``A::B::C::D``. + + .. versionadded:: 1.4 + +.. rst:directive:: .. cpp:namespace-pop:: + + Undo the previous ``cpp:namespace-push`` directive (*not* just pop a scope). + For example, after:: + + .. cpp:namespace:: A::B + + .. cpp:namespace-push:: C::D + + .. cpp:namespace-pop:: + + the current scope will be ``A::B`` (*not* ``A::B::C``). + + If no previous ``cpp:namespace-push`` directive has been used, but only a + ``cpp:namespace`` directive, then the current scope will be reset to global + scope. That is, ``.. cpp:namespace:: A::B`` is equivalent to:: + + .. cpp:namespace:: nullptr + + .. cpp:namespace-push:: A::B + + .. versionadded:: 1.4 + +Info field lists +---------------- + +All the C++ directives for declaring entities support the following +info fields (see also :ref:`info-field-lists`): + +* ``tparam``: Description of a template parameter. + +The :rst:dir:`cpp:function` directive additionally supports the +following fields: + +* ``param``, ``parameter``, ``arg``, ``argument``: Description of a parameter. +* ``returns``, ``return``: Description of a return value. +* ``retval``, ``retvals``: An alternative to ``returns`` for describing + the result of the function. +* ``throws``, ``throw``, ``exception``: Description of a possibly thrown exception. + +.. versionadded:: 4.3 + The ``retval`` field type. + +.. _cpp-roles: + +Cross-referencing +----------------- + +These roles link to the given declaration types: + +.. rst:role:: cpp:any + cpp:class + cpp:struct + cpp:func + cpp:member + cpp:var + cpp:type + cpp:concept + cpp:enum + cpp:enumerator + + Reference a C++ declaration by name (see below for details). The name must + be properly qualified relative to the position of the link. + + .. versionadded:: 2.0 + The :rst:role:`cpp:struct` role as alias for the :rst:role:`cpp:class` + role. + +.. admonition:: Note on References with Templates Parameters/Arguments + + These roles follow the Sphinx :ref:`xref-syntax` rules. This means care must + be taken when referencing a (partial) template specialization, e.g. if the + link looks like this: ``:cpp:class:`MyClass<int>```. + This is interpreted as a link to ``int`` with a title of ``MyClass``. + In this case, escape the opening angle bracket with a backslash, + like this: ``:cpp:class:`MyClass\<int>```. + + When a custom title is not needed it may be useful to use the roles for + inline expressions, :rst:role:`cpp:expr` and :rst:role:`cpp:texpr`, where + angle brackets do not need escaping. + +Declarations without template parameters and template arguments +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +For linking to non-templated declarations the name must be a nested name, e.g., +``f`` or ``MyClass::f``. + + +Overloaded (member) functions +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When a (member) function is referenced using just its name, the reference +will point to an arbitrary matching overload. +The :rst:role:`cpp:any` and :rst:role:`cpp:func` roles use an alternative +format, which simply is a complete function declaration. +This will resolve to the exact matching overload. +As example, consider the following class declaration: + +.. cpp:namespace-push:: overload_example +.. cpp:class:: C + :no-contents-entry: + :no-index-entry: + + .. cpp:function:: void f(double d) const + :no-contents-entry: + :no-index-entry: + .. cpp:function:: void f(double d) + :no-contents-entry: + :no-index-entry: + .. cpp:function:: void f(int i) + :no-contents-entry: + :no-index-entry: + .. cpp:function:: void f() + :no-contents-entry: + :no-index-entry: + +References using the :rst:role:`cpp:func` role: + +- Arbitrary overload: ``C::f``, :cpp:func:`C::f` +- Also arbitrary overload: ``C::f()``, :cpp:func:`C::f()` +- Specific overload: ``void C::f()``, :cpp:func:`void C::f()` +- Specific overload: ``void C::f(int)``, :cpp:func:`void C::f(int)` +- Specific overload: ``void C::f(double)``, :cpp:func:`void C::f(double)` +- Specific overload: ``void C::f(double) const``, + :cpp:func:`void C::f(double) const` + +Note that the :confval:`add_function_parentheses` configuration variable +does not influence specific overload references. + +.. cpp:namespace-pop:: + + +Templated declarations +~~~~~~~~~~~~~~~~~~~~~~ + +Assume the following declarations. + +.. cpp:class:: Wrapper + :no-contents-entry: + :no-index-entry: + + .. cpp:class:: template<typename TOuter> \ + Outer + :no-contents-entry: + :no-index-entry: + + .. cpp:class:: template<typename TInner> \ + Inner + :no-contents-entry: + :no-index-entry: + +In general the reference must include the template parameter declarations, +and template arguments for the prefix of qualified names. For example: + +- ``template\<typename TOuter> Wrapper::Outer`` + (:cpp:class:`template\<typename TOuter> Wrapper::Outer`) +- ``template\<typename TOuter> template\<typename TInner> Wrapper::Outer<TOuter>::Inner`` + (:cpp:class:`template\<typename TOuter> template\<typename TInner> Wrapper::Outer<TOuter>::Inner`) + +Currently the lookup only succeed if the template parameter identifiers are +equal strings. That is, ``template\<typename UOuter> Wrapper::Outer`` will not +work. + +As a shorthand notation, if a template parameter list is omitted, +then the lookup will assume either a primary template or a non-template, +but not a partial template specialisation. +This means the following references work as well: + +- ``Wrapper::Outer`` + (:cpp:class:`Wrapper::Outer`) +- ``Wrapper::Outer::Inner`` + (:cpp:class:`Wrapper::Outer::Inner`) +- ``template\<typename TInner> Wrapper::Outer::Inner`` + (:cpp:class:`template\<typename TInner> Wrapper::Outer::Inner`) + +(Full) Template Specialisations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Assume the following declarations. + +.. cpp:class:: template<typename TOuter> \ + Outer + :no-contents-entry: + :no-index-entry: + + .. cpp:class:: template<typename TInner> \ + Inner + :no-contents-entry: + :no-index-entry: + +.. cpp:class:: template<> \ + Outer<int> + :no-contents-entry: + :no-index-entry: + + .. cpp:class:: template<typename TInner> \ + Inner + :no-contents-entry: + :no-index-entry: + + .. cpp:class:: template<> \ + Inner<bool> + :no-contents-entry: + :no-index-entry: + +In general the reference must include a template parameter list for each +template argument list. The full specialisation above can therefore be +referenced with ``template\<> Outer\<int>`` (:cpp:class:`template\<> +Outer\<int>`) and ``template\<> template\<> Outer\<int>::Inner\<bool>`` +(:cpp:class:`template\<> template\<> Outer\<int>::Inner\<bool>`). As a +shorthand the empty template parameter list can be omitted, e.g., +``Outer\<int>`` (:cpp:class:`Outer\<int>`) and ``Outer\<int>::Inner\<bool>`` +(:cpp:class:`Outer\<int>::Inner\<bool>`). + +Partial Template Specialisations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Assume the following declaration. + +.. cpp:class:: template<typename T> \ + Outer<T*> + :no-contents-entry: + :no-index-entry: + +References to partial specialisations must always include the template +parameter lists, e.g., ``template\<typename T> Outer\<T*>`` +(:cpp:class:`template\<typename T> Outer\<T*>`). Currently the lookup only +succeed if the template parameter identifiers are equal strings. + +Configuration Variables +----------------------- + +See :ref:`cpp-config`. diff --git a/doc/usage/domains/index.rst b/doc/usage/domains/index.rst new file mode 100644 index 0000000..b5d43ce --- /dev/null +++ b/doc/usage/domains/index.rst @@ -0,0 +1,208 @@ +.. highlight:: rst + +======= +Domains +======= + +.. versionadded:: 1.0 + +Originally, Sphinx was conceived for a single project, the documentation of the +Python language. Shortly afterwards, it was made available for everyone as a +documentation tool, but the documentation of Python modules remained deeply +built in -- the most fundamental directives, like ``function``, were designed +for Python objects. Since Sphinx has become somewhat popular, interest +developed in using it for many different purposes: C/C++ projects, JavaScript, +or even reStructuredText markup (like in this documentation). + +While this was always possible, it is now much easier to easily support +documentation of projects using different programming languages or even ones +not supported by the main Sphinx distribution, by providing a **domain** for +every such purpose. + +A domain is a collection of markup (reStructuredText :term:`directive`\ s and +:term:`role`\ s) to describe and link to :term:`object`\ s belonging together, +e.g. elements of a programming language. Directive and role names in a domain +have names like ``domain:name``, e.g. ``py:function``. Domains can also +provide custom indices (like the Python Module Index). + +Having domains means that there are no naming problems when one set of +documentation wants to refer to e.g. C++ and Python classes. It also means +that extensions that support the documentation of whole new languages are much +easier to write. + +This section describes what the domains that are included with Sphinx provide. +The domain API is documented as well, in the section :ref:`domain-api`. + + +.. _basic-domain-markup: + +Basic Markup +------------ + +Most domains provide a number of :dfn:`object description directives`, used to +describe specific objects provided by modules. Each directive requires one or +more signatures to provide basic information about what is being described, and +the content should be the description. + +A domain will typically keep an internal index of all entities to aid +cross-referencing. +Typically it will also add entries in the shown general index. +If you want to suppress the addition of an entry in the shown index, you can +give the directive option flag ``:no-index-entry:``. +If you want to exclude the object description from the table of contents, you +can give the directive option flag ``:no-contents-entry:``. +If you want to typeset an object description, without even making it available +for cross-referencing, you can give the directive option flag ``:no-index:`` +(which implies ``:no-index-entry:``). +If you do not want to typeset anything, you can give the directive option flag +``:no-typesetting:``. This can for example be used to create only a target and +index entry for later reference. +Though, note that not every directive in every domain may support these +options. + +.. versionadded:: 3.2 + The directive option ``noindexentry`` in the Python, C, C++, and Javascript + domains. + +.. versionadded:: 5.2.3 + The directive option ``:nocontentsentry:`` in the Python, C, C++, Javascript, + and reStructuredText domains. + +.. versionadded:: 7.2 + The directive option ``no-typesetting`` in the Python, C, C++, Javascript, + and reStructuredText domains. + +.. versionchanged:: 7.2 + + * The directive option ``:noindex:`` was renamed + to ``:no-index:``. + * The directive option ``:noindexentry:`` was renamed + to ``:no-index-entry:``. + * The directive option ``:nocontentsentry:`` was renamed + to ``:no-contents-entry:``. + + The previous names are retained as aliases, + but will be deprecated and removed + in a future version of Sphinx. + +An example using a Python domain directive:: + + .. py:function:: spam(eggs) + ham(eggs) + + Spam or ham the foo. + +This describes the two Python functions ``spam`` and ``ham``. (Note that when +signatures become too long, you can break them if you add a backslash to lines +that are continued in the next line. Example:: + + .. py:function:: filterwarnings(action, message='', category=Warning, \ + module='', lineno=0, append=False) + :no-index: + +(This example also shows how to use the ``:no-index:`` flag.) + +The domains also provide roles that link back to these object descriptions. +For example, to link to one of the functions described in the example above, +you could say :: + + The function :py:func:`spam` does a similar thing. + +As you can see, both directive and role names contain the domain name and the +directive name. + +The directive option ``:no-typesetting:`` can be used to create a target +(and index entry) which can later be referenced +by the roles provided by the domain. +This is particularly useful for literate programming: + +.. code-block:: rst + + .. py:function:: spam(eggs) + :no-typesetting: + + .. code:: + + def spam(eggs): + pass + + The function :py:func:`spam` does nothing. + +.. rubric:: Default Domain + +For documentation describing objects from solely one domain, authors will not +have to state again its name at each directive, role, etc... after +having specified a default. This can be done either via the config +value :confval:`primary_domain` or via this directive: + +.. rst:directive:: .. default-domain:: name + + Select a new default domain. While the :confval:`primary_domain` selects a + global default, this only has an effect within the same file. + +If no other default is selected, the Python domain (named ``py``) is the +default one, mostly for compatibility with documentation written for older +versions of Sphinx. + +Directives and roles that belong to the default domain can be mentioned without +giving the domain name, i.e. :: + + .. function:: pyfunc() + + Describes a Python function. + + Reference to :func:`pyfunc`. + +Cross-referencing syntax +~~~~~~~~~~~~~~~~~~~~~~~~ + +For cross-reference roles provided by domains, the same facilities exist as for +general cross-references. See :ref:`xref-syntax`. + +In short: + +* You may supply an explicit title and reference target: ``:role:`title + <target>``` will refer to *target*, but the link text will be *title*. + +* If you prefix the content with ``!``, no reference/hyperlink will be created. + +* If you prefix the content with ``~``, the link text will only be the last + component of the target. For example, ``:py:meth:`~Queue.Queue.get``` will + refer to ``Queue.Queue.get`` but only display ``get`` as the link text. + +Built-in domains +---------------- + +The following domains are included within Sphinx: + +.. toctree:: + :maxdepth: 1 + + standard + c + cpp + javascript + mathematics + python + restructuredtext + +More domains +------------ + +There are several third-party domains available as extensions, including: + +* `Ada <https://pypi.org/project/sphinxcontrib-adadomain/>`__ +* `Chapel <https://pypi.org/project/sphinxcontrib-chapeldomain/>`__ +* `CoffeeScript <https://pypi.org/project/sphinxcontrib-coffee/>`__ +* `Common Lisp <https://pypi.org/project/sphinxcontrib-cldomain/>`__ +* `dqn <https://pypi.org/project/sphinxcontrib-dqndomain/>`__ +* `Erlang <https://pypi.org/project/sphinxcontrib-erlangdomain/>`__ +* `Go <https://pypi.org/project/sphinxcontrib-golangdomain/>`__ +* `HTTP <https://pypi.org/project/sphinxcontrib-httpdomain/>`__ +* `Jinja <https://pypi.org/project/sphinxcontrib-jinjadomain/>`__ +* `Lasso <https://pypi.org/project/sphinxcontrib-lassodomain/>`__ +* `MATLAB <https://pypi.org/project/sphinxcontrib-matlabdomain/>`__ +* `Operation <https://pypi.org/project/sphinxcontrib-operationdomain/>`__ +* `PHP <https://pypi.org/project/sphinxcontrib-phpdomain/>`__ +* `Ruby <https://pypi.org/project/sphinxcontrib-rubydomain/>`__ +* `Scala <https://pypi.org/project/sphinxcontrib-scaladomain/>`__ diff --git a/doc/usage/domains/javascript.rst b/doc/usage/domains/javascript.rst new file mode 100644 index 0000000..630b52e --- /dev/null +++ b/doc/usage/domains/javascript.rst @@ -0,0 +1,132 @@ +.. highlight:: rst + +===================== +The JavaScript Domain +===================== + +.. versionadded:: 1.0 + +The JavaScript domain (name **js**) provides the following directives: + +.. rst:directive:: .. js:module:: name + + This directive sets the module name for object declarations that follow + after. The module name is used in the global module index and in cross + references. This directive does not create an object heading like + :rst:dir:`py:class` would, for example. + + By default, this directive will create a linkable entity and will cause an + entry in the global module index, unless the ``no-index`` option is + specified. If this option is specified, the directive will only update the + current module name. + + .. versionadded:: 1.6 + .. versionchanged:: 5.2 + + Module directives support body content. + +.. rst:directive:: .. js:function:: name(signature) + + Describes a JavaScript function or method. If you want to describe + arguments as optional use square brackets as :ref:`documented <signatures>` + for Python signatures. + + You can use fields to give more details about arguments and their expected + types, errors which may be thrown by the function, and the value being + returned:: + + .. js:function:: $.getJSON(href, callback[, errback]) + + :param string href: An URI to the location of the resource. + :param callback: Gets called with the object. + :param errback: + Gets called in case the request fails. And a lot of other + text so we need multiple lines. + :throws SomeError: For whatever reason in that case. + :returns: Something. + + This is rendered as: + + .. js:function:: $.getJSON(href, callback[, errback]) + :no-contents-entry: + :no-index-entry: + + :param string href: An URI to the location of the resource. + :param callback: Gets called with the object. + :param errback: + Gets called in case the request fails. And a lot of other + text so we need multiple lines. + :throws SomeError: For whatever reason in that case. + :returns: Something. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's parameters will be emitted on a single logical + line, overriding :confval:`javascript_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. js:method:: name(signature) + + This directive is an alias for :rst:dir:`js:function`, however it describes + a function that is implemented as a method on a class object. + + .. versionadded:: 1.6 + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's parameters will be emitted on a single logical + line, overriding :confval:`javascript_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. js:class:: name + + Describes a constructor that creates an object. This is basically like a + function but will show up with a `class` prefix:: + + .. js:class:: MyAnimal(name[, age]) + + :param string name: The name of the animal + :param number age: an optional age for the animal + + This is rendered as: + + .. js:class:: MyAnimal(name[, age]) + :no-contents-entry: + :no-index-entry: + + :param string name: The name of the animal + :param number age: an optional age for the animal + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's parameters will be emitted on a single logical + line, overriding :confval:`javascript_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. js:data:: name + + Describes a global variable or constant. + +.. rst:directive:: .. js:attribute:: object.name + + Describes the attribute *name* of *object*. + +.. _js-roles: + +These roles are provided to refer to the described objects: + +.. rst:role:: js:mod + js:func + js:meth + js:class + js:data + js:attr diff --git a/doc/usage/domains/mathematics.rst b/doc/usage/domains/mathematics.rst new file mode 100644 index 0000000..9f02c6d --- /dev/null +++ b/doc/usage/domains/mathematics.rst @@ -0,0 +1,22 @@ +.. highlight:: rst + +====================== +The Mathematics Domain +====================== + +.. versionadded:: 1.8 + +The math domain (name **math**) provides the following roles: + +.. rst:role:: math:numref + + Role for cross-referencing equations defined by :rst:dir:`math` directive + via their label. Example:: + + .. math:: e^{i\pi} + 1 = 0 + :label: euler + + Euler's identity, equation :math:numref:`euler`, was elected one of the + most beautiful mathematical formulas. + + .. versionadded:: 1.8 diff --git a/doc/usage/domains/python.rst b/doc/usage/domains/python.rst new file mode 100644 index 0000000..96982f1 --- /dev/null +++ b/doc/usage/domains/python.rst @@ -0,0 +1,688 @@ +.. highlight:: rst + +================= +The Python Domain +================= + +.. versionadded:: 1.0 + +The Python domain (name **py**) provides the following directives for module +declarations: + +.. rst:directive:: .. py:module:: name + + This directive marks the beginning of the description of a module (or package + submodule, in which case the name should be fully qualified, including the + package name). A description of the module such as the docstring can be + placed in the body of the directive. + + This directive will also cause an entry in the global module index. + + .. versionchanged:: 5.2 + + Module directives support body content. + + .. rubric:: options + + .. rst:directive:option:: platform: platforms + :type: comma separated list + + Indicate platforms which the module is available (if it is available on + all platforms, the option should be omitted). The keys are short + identifiers; examples that are in use include "IRIX", "Mac", "Windows" + and "Unix". It is important to use a key which has already been used when + applicable. + + .. rst:directive:option:: synopsis: purpose + :type: text + + Consist of one sentence describing the module's purpose -- it is currently + only used in the Global Module Index. + + .. rst:directive:option:: deprecated + :type: no argument + + Mark a module as deprecated; it will be designated as such in various + locations then. + + +.. rst:directive:: .. py:currentmodule:: name + + This directive tells Sphinx that the classes, functions etc. documented from + here are in the given module (like :rst:dir:`py:module`), but it will not + create index entries, an entry in the Global Module Index, or a link target + for :rst:role:`py:mod`. This is helpful in situations where documentation + for things in a module is spread over multiple files or sections -- one + location has the :rst:dir:`py:module` directive, the others only + :rst:dir:`py:currentmodule`. + +The following directives are provided for module and class contents: + +.. rst:directive:: .. py:function:: name(parameters) + .. py:function:: name[type parameters](parameters) + + Describes a module-level function. + The signature should include the parameters, + together with optional type parameters, + as given in the Python function definition, see :ref:`signatures`. + For example:: + + .. py:function:: Timer.repeat(repeat=3, number=1_000_000) + .. py:function:: add[T](a: T, b: T) -> T + + For methods you should use :rst:dir:`py:method`. + + The description normally includes information about the parameters required + and how they are used (especially whether mutable objects passed as + parameters are modified), side effects, and possible exceptions. + + This information can (in any ``py`` directive) optionally be given in a + structured form, see :ref:`info-field-lists`. + + .. rubric:: options + + .. rst:directive:option:: async + :type: no value + + Indicate the function is an async function. + + .. versionadded:: 2.1 + + .. rst:directive:option:: canonical + :type: full qualified name including module name + + Describe the location where the object is defined if the object is + imported from other modules + + .. versionadded:: 4.0 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the function's arguments will be emitted on a single logical + line, overriding :confval:`python_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + .. rst:directive:option:: single-line-type-parameter-list + :type: no value + + Ensure that the function's type parameters are emitted on a single + logical line, overriding :confval:`python_maximum_signature_line_length` + and :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + +.. rst:directive:: .. py:data:: name + + Describes global data in a module, including both variables and values used + as "defined constants." Class and object attributes are not documented + using this environment. + + .. rubric:: options + + .. rst:directive:option:: type: type of the variable + :type: text + + .. versionadded:: 2.4 + + .. rst:directive:option:: value: initial value of the variable + :type: text + + .. versionadded:: 2.4 + + .. rst:directive:option:: canonical + :type: full qualified name including module name + + Describe the location where the object is defined if the object is + imported from other modules + + .. versionadded:: 4.0 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + +.. rst:directive:: .. py:exception:: name + .. py:exception:: name(parameters) + .. py:exception:: name[type parameters](parameters) + + Describes an exception class. + The signature can, but need not include parentheses with constructor arguments, + or may optionally include type parameters (see :pep:`695`). + + .. rubric:: options + + .. rst:directive:option:: final + :type: no value + + Indicate the class is a final class. + + .. versionadded:: 3.1 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + See :rst:dir:`py:class:single-line-parameter-list`. + + .. versionadded:: 7.1 + + .. rst:directive:option:: single-line-type-parameter-list + :type: no value + + See :rst:dir:`py:class:single-line-type-parameter-list`. + + .. versionadded:: 7.1 + +.. rst:directive:: .. py:class:: name + .. py:class:: name(parameters) + .. py:class:: name[type parameters](parameters) + + Describes a class. + The signature can optionally include type parameters (see :pep:`695`) + or parentheses with parameters which will be shown as the constructor arguments. + See also :ref:`signatures`. + + Methods and attributes belonging to the class should be placed in this + directive's body. If they are placed outside, the supplied name should + contain the class name so that cross-references still work. Example:: + + .. py:class:: Foo + + .. py:method:: quux() + + -- or -- + + .. py:class:: Bar + + .. py:method:: Bar.quux() + + The first way is the preferred one. + + .. rubric:: options + + .. rst:directive:option:: canonical + :type: full qualified name including module name + + Describe the location where the object is defined if the object is + imported from other modules + + .. versionadded:: 4.0 + + .. rst:directive:option:: final + :type: no value + + Indicate the class is a final class. + + .. versionadded:: 3.1 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the class constructor's arguments will be emitted on a single + logical line, overriding :confval:`python_maximum_signature_line_length` + and :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + .. rst:directive:option:: single-line-type-parameter-list + :type: no value + + Ensure that the class type parameters are emitted on a single logical + line, overriding :confval:`python_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + +.. rst:directive:: .. py:attribute:: name + + Describes an object data attribute. The description should include + information about the type of the data to be expected and whether it may be + changed directly. + + .. rubric:: options + + .. rst:directive:option:: type: type of the attribute + :type: text + + .. versionadded:: 2.4 + + .. rst:directive:option:: value: initial value of the attribute + :type: text + + .. versionadded:: 2.4 + + .. rst:directive:option:: canonical + :type: full qualified name including module name + + Describe the location where the object is defined if the object is + imported from other modules + + .. versionadded:: 4.0 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + +.. rst:directive:: .. py:property:: name + + Describes an object property. + + .. versionadded:: 4.0 + + .. rubric:: options + + .. rst:directive:option:: abstractmethod + :type: no value + + Indicate the property is abstract. + + .. rst:directive:option:: classmethod + :type: no value + + Indicate the property is a classmethod. + + .. versionadded:: 4.2 + + .. rst:directive:option:: type: type of the property + :type: text + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + +.. rst:directive:: .. py:method:: name(parameters) + .. py:method:: name[type parameters](parameters) + + Describes an object method. The parameters should not include the ``self`` + parameter. The description should include similar information to that + described for ``function``. See also :ref:`signatures` and + :ref:`info-field-lists`. + + .. rubric:: options + + .. rst:directive:option:: abstractmethod + :type: no value + + Indicate the method is an abstract method. + + .. versionadded:: 2.1 + + .. rst:directive:option:: async + :type: no value + + Indicate the method is an async method. + + .. versionadded:: 2.1 + + .. rst:directive:option:: canonical + :type: full qualified name including module name + + Describe the location where the object is defined if the object is + imported from other modules + + .. versionadded:: 4.0 + + .. rst:directive:option:: classmethod + :type: no value + + Indicate the method is a class method. + + .. versionadded:: 2.1 + + .. rst:directive:option:: final + :type: no value + + Indicate the method is a final method. + + .. versionadded:: 3.1 + + .. rst::directive:option:: module + :type: text + + Describe the location where the object is defined. The default value is + the module specified by :rst:dir:`py:currentmodule`. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the method's arguments will be emitted on a single logical + line, overriding :confval:`python_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + .. rst:directive:option:: single-line-type-parameter-list + :type: no value + + Ensure that the method's type parameters are emitted on a single logical + line, overriding :confval:`python_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.2 + + .. rst:directive:option:: staticmethod + :type: no value + + Indicate the method is a static method. + + .. versionadded:: 2.1 + + +.. rst:directive:: .. py:staticmethod:: name(parameters) + .. py:staticmethod:: name[type parameters](parameters) + + Like :rst:dir:`py:method`, but indicates that the method is a static method. + + .. versionadded:: 0.4 + +.. rst:directive:: .. py:classmethod:: name(parameters) + .. py:classmethod:: name[type parameters](parameters) + + Like :rst:dir:`py:method`, but indicates that the method is a class method. + + .. versionadded:: 0.6 + +.. rst:directive:: .. py:decorator:: name + .. py:decorator:: name(parameters) + .. py:decorator:: name[type parameters](parameters) + + Describes a decorator function. The signature should represent the usage as + a decorator. For example, given the functions + + .. code-block:: python + + def removename(func): + func.__name__ = '' + return func + + def setnewname(name): + def decorator(func): + func.__name__ = name + return func + return decorator + + the descriptions should look like this:: + + .. py:decorator:: removename + + Remove name of the decorated function. + + .. py:decorator:: setnewname(name) + + Set name of the decorated function to *name*. + + (as opposed to ``.. py:decorator:: removename(func)``.) + + There is no ``py:deco`` role to link to a decorator that is marked up with + this directive; rather, use the :rst:role:`py:func` role. + + .. rst:directive:option:: single-line-parameter-list + :type: no value + + Ensures that the decorator's arguments will be emitted on a single logical + line, overriding :confval:`python_maximum_signature_line_length` and + :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.1 + + .. rst:directive:option:: single-line-type-parameter-list + :type: no value + + Ensure that the decorator's type parameters are emitted on a single + logical line, overriding :confval:`python_maximum_signature_line_length` + and :confval:`maximum_signature_line_length`. + + .. versionadded:: 7.2 + +.. rst:directive:: .. py:decoratormethod:: name + .. py:decoratormethod:: name(signature) + .. py:decoratormethod:: name[type parameters](signature) + + Same as :rst:dir:`py:decorator`, but for decorators that are methods. + + Refer to a decorator method using the :rst:role:`py:meth` role. + +.. _signatures: + +Python Signatures +----------------- + +Signatures of functions, methods and class constructors can be given like they +would be written in Python. + +Default values for optional arguments can be given (but if they contain commas, +they will confuse the signature parser). Python 3-style argument annotations +can also be given as well as return type annotations:: + + .. py:function:: compile(source : string, filename, symbol='file') -> ast object + +For functions with optional parameters that don't have default values +(typically functions implemented in C extension modules without keyword +argument support), you can use brackets to specify the optional parts: + +.. py:function:: compile(source[, filename[, symbol]]) + :no-contents-entry: + :no-index-entry: + +It is customary to put the opening bracket before the comma. + +Python 3.12 introduced *type parameters*, which are type variables +declared directly within the class or function definition: + +.. code:: python + + class AnimalList[AnimalT](list[AnimalT]): + ... + + def add[T](a: T, b: T) -> T: + return a + b + +The corresponding reStructuredText documentation would be: + +.. code:: rst + + .. py:class:: AnimalList[AnimalT] + + .. py:function:: add[T](a: T, b: T) -> T + +See :pep:`695` and :pep:`696` for details and the full specification. + +.. _info-field-lists: + +Info field lists +---------------- + +.. versionadded:: 0.4 +.. versionchanged:: 3.0 + + meta fields are added. + +Inside Python object description directives, reST field lists with these fields +are recognized and formatted nicely: + +* ``param``, ``parameter``, ``arg``, ``argument``, ``key``, ``keyword``: + Description of a parameter. +* ``type``: Type of a parameter. Creates a link if possible. +* ``raises``, ``raise``, ``except``, ``exception``: That (and when) a specific + exception is raised. +* ``var``, ``ivar``, ``cvar``: Description of a variable. +* ``vartype``: Type of a variable. Creates a link if possible. +* ``returns``, ``return``: Description of the return value. +* ``rtype``: Return type. Creates a link if possible. +* ``meta``: Add metadata to description of the python object. The metadata will + not be shown on output document. For example, ``:meta private:`` indicates + the python object is private member. It is used in + :py:mod:`sphinx.ext.autodoc` for filtering members. + +.. note:: + + In current release, all ``var``, ``ivar`` and ``cvar`` are represented as + "Variable". There is no difference at all. + +The field names must consist of one of these keywords and an argument (except +for ``returns`` and ``rtype``, which do not need an argument). This is best +explained by an example:: + + .. py:function:: send_message(sender, recipient, message_body, [priority=1]) + + Send a message to a recipient + + :param str sender: The person sending the message + :param str recipient: The recipient of the message + :param str message_body: The body of the message + :param priority: The priority of the message, can be a number 1-5 + :type priority: integer or None + :return: the message id + :rtype: int + :raises ValueError: if the message_body exceeds 160 characters + :raises TypeError: if the message_body is not a basestring + +This will render like this: + +.. py:function:: send_message(sender, recipient, message_body, [priority=1]) + :no-contents-entry: + :no-index-entry: + + Send a message to a recipient + + :param str sender: The person sending the message + :param str recipient: The recipient of the message + :param str message_body: The body of the message + :param priority: The priority of the message, can be a number 1-5 + :type priority: int or None + :return: the message id + :rtype: int + :raises ValueError: if the message_body exceeds 160 characters + :raises TypeError: if the message_body is not a basestring + +It is also possible to combine parameter type and description, if the type is a +single word, like this:: + + :param int priority: The priority of the message, can be a number 1-5 + +.. versionadded:: 1.5 + +Container types such as lists and dictionaries can be linked automatically +using the following syntax:: + + :type priorities: list(int) + :type priorities: list[int] + :type mapping: dict(str, int) + :type mapping: dict[str, int] + :type point: tuple(float, float) + :type point: tuple[float, float] + +Multiple types in a type field will be linked automatically if separated by the +word "or":: + + :type an_arg: int or None + :vartype a_var: str or int + :rtype: float or str + +.. _python-roles: + +Cross-referencing Python objects +-------------------------------- + +The following roles refer to objects in modules and are possibly hyperlinked if +a matching identifier is found: + +.. rst:role:: py:mod + + Reference a module; a dotted name may be used. This should also be used for + package names. + +.. rst:role:: py:func + + Reference a Python function; dotted names may be used. The role text needs + not include trailing parentheses to enhance readability; they will be added + automatically by Sphinx if the :confval:`add_function_parentheses` config + value is ``True`` (the default). + +.. rst:role:: py:data + + Reference a module-level variable. + +.. rst:role:: py:const + + Reference a "defined" constant. This may be a Python variable that is not + intended to be changed. + +.. rst:role:: py:class + + Reference a class; a dotted name may be used. + +.. rst:role:: py:meth + + Reference a method of an object. The role text can include the type name + and the method name; if it occurs within the description of a type, the type + name can be omitted. A dotted name may be used. + +.. rst:role:: py:attr + + Reference a data attribute of an object. + + .. note:: The role is also able to refer to property. + +.. rst:role:: py:exc + + Reference an exception. A dotted name may be used. + +.. rst:role:: py:obj + + Reference an object of unspecified type. Useful e.g. as the + :confval:`default_role`. + + .. versionadded:: 0.4 + +The name enclosed in this markup can include a module name and/or a class name. +For example, ``:py:func:`filter``` could refer to a function named ``filter`` +in the current module, or the built-in function of that name. In contrast, +``:py:func:`foo.filter``` clearly refers to the ``filter`` function in the +``foo`` module. + +Normally, names in these roles are searched first without any further +qualification, then with the current module name prepended, then with the +current module and class name (if any) prepended. If you prefix the name with +a dot, this order is reversed. For example, in the documentation of Python's +:mod:`codecs` module, ``:py:func:`open``` always refers to the built-in +function, while ``:py:func:`.open``` refers to :func:`codecs.open`. + +A similar heuristic is used to determine whether the name is an attribute of +the currently documented class. + +Also, if the name is prefixed with a dot, and no exact match is found, the +target is taken as a suffix and all object names with that suffix are searched. +For example, ``:py:meth:`.TarFile.close``` references the +``tarfile.TarFile.close()`` function, even if the current module is not +``tarfile``. Since this can get ambiguous, if there is more than one possible +match, you will get a warning from Sphinx. + +Note that you can combine the ``~`` and ``.`` prefixes: +``:py:meth:`~.TarFile.close``` will reference the ``tarfile.TarFile.close()`` +method, but the visible link caption will only be ``close()``. diff --git a/doc/usage/domains/restructuredtext.rst b/doc/usage/domains/restructuredtext.rst new file mode 100644 index 0000000..3a936a6 --- /dev/null +++ b/doc/usage/domains/restructuredtext.rst @@ -0,0 +1,99 @@ +.. highlight:: rst + +=========================== +The reStructuredText Domain +=========================== + +.. versionadded:: 1.0 + +The reStructuredText domain (name **rst**) provides the following directives: + +.. rst:directive:: .. rst:directive:: name + + Describes a reST directive. The *name* can be a single directive name or + actual directive syntax (`..` prefix and `::` suffix) with arguments that + will be rendered differently. For example:: + + .. rst:directive:: foo + + Foo description. + + .. rst:directive:: .. bar:: baz + + Bar description. + + will be rendered as: + + .. rst:directive:: foo + :no-contents-entry: + :no-index-entry: + + Foo description. + + .. rst:directive:: .. bar:: baz + :no-contents-entry: + :no-index-entry: + + Bar description. + +.. rst:directive:: .. rst:directive:option:: name + + Describes an option for reST directive. The *name* can be a single option + name or option name with arguments which separated with colon (``:``). + For example:: + + .. rst:directive:: toctree + + .. rst:directive:option:: caption: caption of ToC + + .. rst:directive:option:: glob + + will be rendered as: + + .. rst:directive:: toctree + :no-index: + + .. rst:directive:option:: caption: caption of ToC + :no-index: + + .. rst:directive:option:: glob + :no-index: + + .. rubric:: options + + .. rst:directive:option:: type: description of argument + :type: text + + Describe the type of option value. + + For example:: + + .. rst:directive:: toctree + + .. rst:directive:option:: maxdepth + :type: integer or no value + + .. versionadded:: 2.1 + +.. rst:directive:: .. rst:role:: name + + Describes a reST role. For example:: + + .. rst:role:: foo + + Foo description. + + will be rendered as: + + .. rst:role:: foo + :no-contents-entry: + :no-index-entry: + + Foo description. + +.. _rst-roles: + +These roles are provided to refer to the described objects: + +.. rst:role:: rst:dir + rst:role diff --git a/doc/usage/domains/standard.rst b/doc/usage/domains/standard.rst new file mode 100644 index 0000000..59b7e72 --- /dev/null +++ b/doc/usage/domains/standard.rst @@ -0,0 +1,95 @@ +.. highlight:: rst + +=================== +The Standard Domain +=================== + +.. versionadded:: 1.0 + +The so-called "standard" domain collects all markup that doesn't warrant a +domain of its own. Its directives and roles are not prefixed with a domain +name. + +The standard domain is also where custom object descriptions, added using the +:func:`~sphinx.application.Sphinx.add_object_type` API, are placed. + +There is a set of directives allowing documenting command-line programs: + +.. rst:directive:: .. option:: name args, name args, ... + + Describes a command line argument or switch. Option argument names should + be enclosed in angle brackets. Examples:: + + .. option:: dest_dir + + Destination directory. + + .. option:: -m <module>, --module <module> + + Run a module as a script. + + The directive will create cross-reference targets for the given options, + referenceable by :rst:role:`option` (in the example case, you'd use something + like ``:option:`dest_dir```, ``:option:`-m```, or ``:option:`--module```). + + .. versionchanged:: 5.3 + + One can cross-reference including an option value: ``:option:`--module=foobar```, + ,``:option:`--module[=foobar]``` or ``:option:`--module foobar```. + + Use :confval:`option_emphasise_placeholders` for parsing of + "variable part" of a literal text (similarly to the :rst:role:`samp` role). + + ``cmdoption`` directive is a deprecated alias for the ``option`` directive. + +.. rst:directive:: .. envvar:: name + + Describes an environment variable that the documented code or program uses + or defines. Referenceable by :rst:role:`envvar`. + +.. rst:directive:: .. program:: name + + Like :rst:dir:`py:currentmodule`, this directive produces no output. + Instead, it serves to notify Sphinx that all following :rst:dir:`option` + directives document options for the program called *name*. + + If you use :rst:dir:`program`, you have to qualify the references in your + :rst:role:`option` roles by the program name, so if you have the following + situation :: + + .. program:: rm + + .. option:: -r + + Work recursively. + + .. program:: svn + + .. option:: -r <revision> + + Specify the revision to work upon. + + then ``:option:`rm -r``` would refer to the first option, while + ``:option:`svn -r``` would refer to the second one. + + If ``None`` is passed to the argument, the directive will reset the + current program name. + + The program name may contain spaces (in case you want to document + subcommands like ``svn add`` and ``svn commit`` separately). + + .. versionadded:: 0.5 + +There is also a very generic object description directive, which is not tied to +any domain: + +.. rst:directive:: .. describe:: text + .. object:: text + + This directive produces the same formatting as the specific ones provided by + domains, but does not create index entries or cross-referencing targets. + Example:: + + .. describe:: PAPER + + You can set this variable to select a paper size. diff --git a/doc/usage/extensions/autodoc.rst b/doc/usage/extensions/autodoc.rst index 1498ae9..c920de8 100644 --- a/doc/usage/extensions/autodoc.rst +++ b/doc/usage/extensions/autodoc.rst @@ -40,7 +40,7 @@ you can also enable the :mod:`napoleon <sphinx.ext.napoleon>` extension. :mod:`napoleon <sphinx.ext.napoleon>` is a preprocessor that converts your docstrings to correct reStructuredText before :mod:`autodoc` processes them. -.. _Google: https://github.com/google/styleguide/blob/gh-pages/pyguide.md#38-comments-and-docstrings +.. _Google: https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings .. _NumPy: https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard diff --git a/doc/usage/extensions/coverage.rst b/doc/usage/extensions/coverage.rst index 1390ebf..b9c493b 100644 --- a/doc/usage/extensions/coverage.rst +++ b/doc/usage/extensions/coverage.rst @@ -9,7 +9,7 @@ This extension features one additional builder, the :class:`CoverageBuilder`. .. class:: CoverageBuilder To use this builder, activate the coverage extension in your configuration - file and give ``-b coverage`` on the command line. + file and give ``-M coverage`` on the command line. .. todo:: Write this section. @@ -62,7 +62,7 @@ should check: .. confval:: coverage_statistics_to_report - Print a tabluar report of the coverage statistics to the coverage report. + Print a tabular report of the coverage statistics to the coverage report. ``True`` by default. Example output: @@ -81,7 +81,7 @@ should check: .. confval:: coverage_statistics_to_stdout - Print a tabluar report of the coverage statistics to standard output. + Print a tabular report of the coverage statistics to standard output. ``False`` by default. Example output: diff --git a/doc/usage/extensions/example_google.py b/doc/usage/extensions/example_google.py index 434fa3b..7cd24d1 100644 --- a/doc/usage/extensions/example_google.py +++ b/doc/usage/extensions/example_google.py @@ -290,6 +290,7 @@ class ExampleClass: def _private_without_docstring(self): pass + class ExamplePEP526Class: """The summary line for a class docstring should fit on one line. diff --git a/doc/usage/extensions/example_numpy.py b/doc/usage/extensions/example_numpy.py index 2346b1e..d258ca3 100644 --- a/doc/usage/extensions/example_numpy.py +++ b/doc/usage/extensions/example_numpy.py @@ -266,7 +266,7 @@ class ExampleClass: self.attr3 = param3 #: Doc comment *inline* with attribute #: list(str): Doc comment *before* attribute, with type specified - self.attr4 = ["attr4"] + self.attr4 = ['attr4'] self.attr5 = None """str: Docstring *after* attribute, with type specified.""" @@ -274,7 +274,7 @@ class ExampleClass: @property def readonly_property(self): """str: Properties should be documented in their getter method.""" - return "readonly_property" + return 'readonly_property' @property def readwrite_property(self): @@ -284,7 +284,7 @@ class ExampleClass: If the setter method contains notable behavior, it should be mentioned here. """ - return ["readwrite_property"] + return ['readwrite_property'] @readwrite_property.setter def readwrite_property(self, value): diff --git a/doc/usage/extensions/graphviz.rst b/doc/usage/extensions/graphviz.rst index c134f6d..231bd36 100644 --- a/doc/usage/extensions/graphviz.rst +++ b/doc/usage/extensions/graphviz.rst @@ -211,7 +211,7 @@ There are also these config values: :program:`sphinx-build` command line via the :option:`-D <sphinx-build -D>` option should be preferable, like this:: - sphinx-build -b html -D graphviz_dot=C:\graphviz\bin\dot.exe . _build/html + sphinx-build -M html -D graphviz_dot=C:\graphviz\bin\dot.exe . _build .. confval:: graphviz_dot_args diff --git a/doc/usage/extensions/intersphinx.rst b/doc/usage/extensions/intersphinx.rst index 5aaaf9f..e81719f 100644 --- a/doc/usage/extensions/intersphinx.rst +++ b/doc/usage/extensions/intersphinx.rst @@ -218,6 +218,7 @@ The Intersphinx extension provides the following role. e.g., ``:external:py:class:`zipfile.ZipFile```, or - ``:external:reftype:`target```, e.g., ``:external:doc:`installation```. + With this shorthand, the domain is assumed to be ``std``. If you would like to constrain the lookup to a specific external project, then the key of the project, as specified in :confval:`intersphinx_mapping`, diff --git a/doc/usage/extensions/math.rst b/doc/usage/extensions/math.rst index df4fc6b..251d721 100644 --- a/doc/usage/extensions/math.rst +++ b/doc/usage/extensions/math.rst @@ -75,7 +75,7 @@ are built: :program:`sphinx-build` command line via the :option:`-D <sphinx-build -D>` option should be preferable, like this:: - sphinx-build -b html -D imgmath_latex=C:\tex\latex.exe . _build/html + sphinx-build -M html -D imgmath_latex=C:\tex\latex.exe . _build This value should only contain the path to the latex executable, not further arguments; use :confval:`imgmath_latex_args` for that purpose. @@ -316,5 +316,5 @@ package jsMath_. It provides this config value: .. _dvisvgm: https://dvisvgm.de/ .. _dvisvgm FAQ: https://dvisvgm.de/FAQ .. _MathJax: https://www.mathjax.org/ -.. _jsMath: http://www.math.union.edu/~dpvc/jsmath/ +.. _jsMath: https://www.math.union.edu/~dpvc/jsmath/ .. _LaTeX preview package: https://www.gnu.org/software/auctex/preview-latex.html diff --git a/doc/usage/extensions/napoleon.rst b/doc/usage/extensions/napoleon.rst index d2391da..4b077de 100644 --- a/doc/usage/extensions/napoleon.rst +++ b/doc/usage/extensions/napoleon.rst @@ -63,14 +63,14 @@ Getting Started ~~~~~~~~~~~~~~~ 1. After :doc:`setting up Sphinx </usage/quickstart>` to build your docs, - enable napoleon in the Sphinx `conf.py` file:: + enable napoleon in the Sphinx ``conf.py`` file:: # conf.py # Add napoleon to the extensions list extensions = ['sphinx.ext.napoleon'] -2. Use `sphinx-apidoc` to build your API documentation:: +2. Use ``sphinx-apidoc`` to build your API documentation:: $ sphinx-apidoc -f -o docs/source projectdir @@ -271,8 +271,8 @@ Configuration ------------- Listed below are all the settings used by napoleon and their default -values. These settings can be changed in the Sphinx `conf.py` file. Make -sure that "sphinx.ext.napoleon" is enabled in `conf.py`:: +values. These settings can be changed in the Sphinx ``conf.py`` file. Make +sure that "sphinx.ext.napoleon" is enabled in ``conf.py``:: # conf.py diff --git a/doc/usage/index.rst b/doc/usage/index.rst index fd8cdd8..167c7aa 100644 --- a/doc/usage/index.rst +++ b/doc/usage/index.rst @@ -12,8 +12,10 @@ looking for guidance on extending Sphinx, refer to :doc:`/development/index`. restructuredtext/index markdown + referencing configuration builders/index + domains/index extensions/index theming advanced/intl diff --git a/doc/usage/installation.rst b/doc/usage/installation.rst index e85603e..13dc6a9 100644 --- a/doc/usage/installation.rst +++ b/doc/usage/installation.rst @@ -64,7 +64,7 @@ a Python distribution such as `Anaconda`__. __ https://brew.sh/ __ https://www.macports.org/ -__ https://www.anaconda.com/download/#macos +__ https://www.anaconda.com/download Homebrew ~~~~~~~~ @@ -199,9 +199,7 @@ use the following command. $ python -m venv .venv -You can read more about them in the `Python Packaging User Guide`_. - -.. _Python Packaging User Guide: https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment +.. seealso:: :mod:`venv` -- creating virtual environments .. warning:: diff --git a/doc/usage/quickstart.rst b/doc/usage/quickstart.rst index 0773f60..fcbfa80 100644 --- a/doc/usage/quickstart.rst +++ b/doc/usage/quickstart.rst @@ -18,7 +18,7 @@ its :doc:`significant extensibility capabilities </development/index>`. The goal of this document is to give you a quick taste of what Sphinx is and how you might use it. When you're done here, you can check out the :doc:`installation guide </usage/installation>` followed by the intro to the -default markup format used by Sphinx, :doc:`reStucturedText +default markup format used by Sphinx, :doc:`reStructuredText </usage/restructuredtext/index>`. For a great "introduction" to writing docs in general -- the whys and hows, see @@ -130,11 +130,11 @@ docs. A build is started with the :program:`sphinx-build` program: .. code-block:: console - $ sphinx-build -b html sourcedir builddir + $ sphinx-build -M html sourcedir outputdir -where *sourcedir* is the :term:`source directory`, and *builddir* is the +where *sourcedir* is the :term:`source directory`, and *outputdir* is the directory in which you want to place the built documentation. -The :option:`-b <sphinx-build -b>` option selects a builder; in this example +The :option:`-M <sphinx-build -M>` option selects a builder; in this example Sphinx will build HTML files. |more| Refer to the :doc:`sphinx-build man page </man/sphinx-build>` for all @@ -220,7 +220,7 @@ Each domain will have special rules for how the signatures can look like, and make the formatted output look pretty, or add specific features like links to parameter types, e.g. in the C/C++ domains. -|more| See :doc:`/usage/restructuredtext/domains` for all the available domains +|more| See :doc:`/usage/domains/index` for all the available domains and their directives/roles. diff --git a/doc/usage/referencing.rst b/doc/usage/referencing.rst new file mode 100644 index 0000000..c2ad715 --- /dev/null +++ b/doc/usage/referencing.rst @@ -0,0 +1,258 @@ +.. _xref-syntax: + +======================== +Cross-referencing syntax +======================== + +Cross-references are generated by many semantic interpreted text roles. +Basically, you only need to write ``:role:`target```, and a link will be +created to the item named *target* of the type indicated by *role*. The link's +text will be the same as *target*. + +There are some additional facilities, however, that make cross-referencing +roles more versatile: + +* You may supply an explicit title and reference target, like in reST direct + hyperlinks: ``:role:`title <target>``` will refer to *target*, but the link + text will be *title*. + +* If you prefix the content with ``!``, no reference/hyperlink will be created. + +* If you prefix the content with ``~``, the link text will only be the last + component of the target. For example, ``:py:meth:`~Queue.Queue.get``` will + refer to ``Queue.Queue.get`` but only display ``get`` as the link text. This + does not work with all cross-reference roles, but is domain specific. + + In HTML output, the link's ``title`` attribute (that is e.g. shown as a + tool-tip on mouse-hover) will always be the full target name. + + +.. _any-role: + +Cross-referencing anything +-------------------------- + +.. rst:role:: any + + .. versionadded:: 1.3 + + This convenience role tries to do its best to find a valid target for its + reference text. + + * First, it tries standard cross-reference targets that would be referenced + by :rst:role:`doc`, :rst:role:`ref` or :rst:role:`option`. + + Custom objects added to the standard domain by extensions (see + :meth:`.Sphinx.add_object_type`) are also searched. + + * Then, it looks for objects (targets) in all loaded domains. It is up to + the domains how specific a match must be. For example, in the Python + domain a reference of ``:any:`Builder``` would match the + ``sphinx.builders.Builder`` class. + + If none or multiple targets are found, a warning will be emitted. In the + case of multiple targets, you can change "any" to a specific role. + + This role is a good candidate for setting :confval:`default_role`. If you + do, you can write cross-references without a lot of markup overhead. For + example, in this Python function documentation:: + + .. function:: install() + + This function installs a `handler` for every signal known by the + `signal` module. See the section `about-signals` for more information. + + there could be references to a glossary term (usually ``:term:`handler```), a + Python module (usually ``:py:mod:`signal``` or ``:mod:`signal```) and a + section (usually ``:ref:`about-signals```). + + The :rst:role:`any` role also works together with the + :mod:`~sphinx.ext.intersphinx` extension: when no local cross-reference is + found, all object types of intersphinx inventories are also searched. + +Cross-referencing objects +------------------------- + +These roles are described with their respective domains: + +* :ref:`Python <python-roles>` +* :ref:`C <c-roles>` +* :ref:`C++ <cpp-roles>` +* :ref:`JavaScript <js-roles>` +* :ref:`ReST <rst-roles>` + + +.. _ref-role: + +Cross-referencing arbitrary locations +------------------------------------- + +.. rst:role:: ref + + To support cross-referencing to arbitrary locations in any document, the + standard reST labels are used. For this to work label names must be unique + throughout the entire documentation. There are two ways in which you can + refer to labels: + + * If you place a label directly before a section title, you can reference to + it with ``:ref:`label-name```. For example:: + + .. _my-reference-label: + + Section to cross-reference + -------------------------- + + This is the text of the section. + + It refers to the section itself, see :ref:`my-reference-label`. + + The ``:ref:`` role would then generate a link to the section, with the + link title being "Section to cross-reference". This works just as well + when section and reference are in different source files. + + Automatic labels also work with figures. For example:: + + .. _my-figure: + + .. figure:: whatever + + Figure caption + + In this case, a reference ``:ref:`my-figure``` would insert a reference + to the figure with link text "Figure caption". + + The same works for tables that are given an explicit caption using the + :dudir:`table` directive. + + * Labels that aren't placed before a section title can still be referenced, + but you must give the link an explicit title, using this syntax: + ``:ref:`Link title <label-name>```. + + .. note:: + + Reference labels must start with an underscore. When referencing a label, + the underscore must be omitted (see examples above). + + Using :rst:role:`ref` is advised over standard reStructuredText links to + sections (like ```Section title`_``) because it works across files, when + section headings are changed, will raise warnings if incorrect, and works + for all builders that support cross-references. + + +Cross-referencing documents +--------------------------- + +.. versionadded:: 0.6 + +There is also a way to directly link to documents: + +.. rst:role:: doc + + Link to the specified document; the document name can be specified in + absolute or relative fashion. For example, if the reference + ``:doc:`parrot``` occurs in the document ``sketches/index``, then the link + refers to ``sketches/parrot``. If the reference is ``:doc:`/people``` or + ``:doc:`../people```, the link refers to ``people``. + + If no explicit link text is given (like usual: ``:doc:`Monty Python members + </people>```), the link caption will be the title of the given document. + + +Referencing downloadable files +------------------------------ + +.. versionadded:: 0.6 + +.. rst:role:: download + + This role lets you link to files within your source tree that are not reST + documents that can be viewed, but files that can be downloaded. + + When you use this role, the referenced file is automatically marked for + inclusion in the output when building (obviously, for HTML output only). + All downloadable files are put into a ``_downloads/<unique hash>/`` + subdirectory of the output directory; duplicate filenames are handled. + + An example:: + + See :download:`this example script <../example.py>`. + + The given filename is usually relative to the directory the current source + file is contained in, but if it absolute (starting with ``/``), it is taken + as relative to the top source directory. + + The ``example.py`` file will be copied to the output directory, and a + suitable link generated to it. + + Not to show unavailable download links, you should wrap whole paragraphs that + have this role:: + + .. only:: builder_html + + See :download:`this example script <../example.py>`. + +Cross-referencing figures by figure number +------------------------------------------ + +.. versionadded:: 1.3 + +.. versionchanged:: 1.5 + :rst:role:`numref` role can also refer sections. + And :rst:role:`numref` allows ``{name}`` for the link text. + +.. rst:role:: numref + + Link to the specified figures, tables, code-blocks and sections; the standard + reST labels are used. When you use this role, it will insert a reference to + the figure with link text by its figure number like "Fig. 1.1". + + If an explicit link text is given (as usual: ``:numref:`Image of Sphinx (Fig. + %s) <my-figure>```), the link caption will serve as title of the reference. + As placeholders, `%s` and `{number}` get replaced by the figure + number and `{name}` by the figure caption. + If no explicit link text is given, the :confval:`numfig_format` setting is + used as fall-back default. + + If :confval:`numfig` is ``False``, figures are not numbered, + so this role inserts not a reference but the label or the link text. + +Cross-referencing other items of interest +----------------------------------------- + +The following roles do possibly create a cross-reference, but do not refer to +objects: + +.. rst:role:: envvar + + An environment variable. Index entries are generated. Also generates a link + to the matching :rst:dir:`envvar` directive, if it exists. + +.. rst:role:: token + + The name of a grammar token (used to create links between + :rst:dir:`productionlist` directives). + +.. rst:role:: keyword + + The name of a keyword in Python. This creates a link to a reference label + with that name, if it exists. + +.. rst:role:: option + + A command-line option to an executable program. This generates a link to + a :rst:dir:`option` directive, if it exists. + + +The following role creates a cross-reference to a term in a +:ref:`glossary <glossary-directive>`: + +.. rst:role:: term + + Reference to a term in a glossary. A glossary is created using the + ``glossary`` directive containing a definition list with terms and + definitions. It does not have to be in the same file as the ``term`` markup, + for example the Python docs have one global glossary in the ``glossary.rst`` + file. + + If you use a term that's not explained in a glossary, you'll get a warning + during build. diff --git a/doc/usage/restructuredtext/basics.rst b/doc/usage/restructuredtext/basics.rst index cc3c615..7aab544 100644 --- a/doc/usage/restructuredtext/basics.rst +++ b/doc/usage/restructuredtext/basics.rst @@ -289,7 +289,7 @@ information. Roles ----- -A role or "custom interpreted text role" (:duref:`ref <roles>`) is an inline +A role or "custom interpreted text role" (:dupage:`ref <roles>`) is an inline piece of explicit markup. It signifies that the enclosed text should be interpreted in a specific way. Sphinx uses this to provide semantic markup and cross-referencing of identifiers, as described in the appropriate section. The diff --git a/doc/usage/restructuredtext/directives.rst b/doc/usage/restructuredtext/directives.rst index 1fd5b66..ff42524 100644 --- a/doc/usage/restructuredtext/directives.rst +++ b/doc/usage/restructuredtext/directives.rst @@ -9,7 +9,7 @@ of explicit markup. While Docutils provides a number of directives, Sphinx provides many more and uses directives as one of the primary extension mechanisms. -See :doc:`/usage/restructuredtext/domains` for roles added by domains. +See :doc:`/usage/domains/index` for roles added by domains. .. seealso:: @@ -323,6 +323,18 @@ units as well as normal text. .. deprecated:: 3.1 Use :func:`spam` instead. +.. rst:directive:: .. versionremoved:: version + + Similar to :rst:dir:`versionadded`, but describes when the feature was removed. + An explanation may be provided to inform the reader what to use instead, + or why the feature was removed. + Example:: + + .. versionremoved:: 4.0 + The :func:`spam` function is more flexible, and should be used instead. + + .. versionadded:: 7.3 + .. rst:directive:: seealso Many sections include a list of references to module documentation or @@ -341,7 +353,7 @@ units as well as normal text. Module :py:mod:`zipfile` Documentation of the :py:mod:`zipfile` standard module. - `GNU tar manual, Basic Tar Format <http://link>`_ + `GNU tar manual, Basic Tar Format <https://link>`_ Documentation for tar archive files, including GNU tar extensions. There's also a "short form" allowed that looks like this:: @@ -544,9 +556,9 @@ __ https://pygments.org/docs/lexers def some_function(): interesting = False - print 'This line is highlighted.' - print 'This one is not...' - print '...but this one is.' + print('This line is highlighted.') + print('This one is not...') + print('...but this one is.') .. versionadded:: 1.1 .. versionchanged:: 1.6.6 @@ -576,7 +588,7 @@ __ https://pygments.org/docs/lexers :caption: this.py :name: this-py - print 'Explicit is better than implicit.' + print('Explicit is better than implicit.') In order to cross-reference a code-block using either the :rst:role:`ref` or the :rst:role:`numref` role, it is necessary @@ -881,7 +893,7 @@ Index-generating markup Sphinx automatically creates index entries from all object descriptions (like functions, classes or attributes) like discussed in -:doc:`/usage/restructuredtext/domains`. +:doc:`/usage/domains/index`. However, there is also explicit markup available, to make the index more comprehensive and enable index entries in documents where information is not @@ -1042,7 +1054,7 @@ Including content based on tags Undefined tags are false, defined tags (via the ``-t`` command-line option or within :file:`conf.py`, see :ref:`here <conf-tags>`) are true. Boolean - expressions, also using parentheses (like ``html and (latex or draft)``) are + expressions, also using parentheses (like ``(latex or html) and draft``) are supported. The *format* and the *name* of the current builder (``html``, ``latex`` or diff --git a/doc/usage/restructuredtext/domains.rst b/doc/usage/restructuredtext/domains.rst index 729e651..3d9bd49 100644 --- a/doc/usage/restructuredtext/domains.rst +++ b/doc/usage/restructuredtext/domains.rst @@ -1,2303 +1,278 @@ -.. highlight:: rst +============== +MOVED: Domains +============== -======= -Domains -======= - -.. versionadded:: 1.0 - -Originally, Sphinx was conceived for a single project, the documentation of the -Python language. Shortly afterwards, it was made available for everyone as a -documentation tool, but the documentation of Python modules remained deeply -built in -- the most fundamental directives, like ``function``, were designed -for Python objects. Since Sphinx has become somewhat popular, interest -developed in using it for many different purposes: C/C++ projects, JavaScript, -or even reStructuredText markup (like in this documentation). - -While this was always possible, it is now much easier to easily support -documentation of projects using different programming languages or even ones -not supported by the main Sphinx distribution, by providing a **domain** for -every such purpose. - -A domain is a collection of markup (reStructuredText :term:`directive`\ s and -:term:`role`\ s) to describe and link to :term:`object`\ s belonging together, -e.g. elements of a programming language. Directive and role names in a domain -have names like ``domain:name``, e.g. ``py:function``. Domains can also -provide custom indices (like the Python Module Index). - -Having domains means that there are no naming problems when one set of -documentation wants to refer to e.g. C++ and Python classes. It also means -that extensions that support the documentation of whole new languages are much -easier to write. - -This section describes what the domains that are included with Sphinx provide. -The domain API is documented as well, in the section :ref:`domain-api`. - - -.. _basic-domain-markup: - -Basic Markup ------------- - -Most domains provide a number of :dfn:`object description directives`, used to -describe specific objects provided by modules. Each directive requires one or -more signatures to provide basic information about what is being described, and -the content should be the description. - -A domain will typically keep an internal index of all entities to aid -cross-referencing. -Typically it will also add entries in the shown general index. -If you want to suppress the addition of an entry in the shown index, you can -give the directive option flag ``:no-index-entry:``. -If you want to exclude the object description from the table of contents, you -can give the directive option flag ``:no-contents-entry:``. -If you want to typeset an object description, without even making it available -for cross-referencing, you can give the directive option flag ``:no-index:`` -(which implies ``:no-index-entry:``). -If you do not want to typeset anything, you can give the directive option flag -``:no-typesetting:``. This can for example be used to create only a target and -index entry for later reference. -Though, note that not every directive in every domain may support these -options. - -.. versionadded:: 3.2 - The directive option ``noindexentry`` in the Python, C, C++, and Javascript - domains. - -.. versionadded:: 5.2.3 - The directive option ``:nocontentsentry:`` in the Python, C, C++, Javascript, - and reStructuredText domains. - -.. versionadded:: 7.2 - The directive option ``no-typesetting`` in the Python, C, C++, Javascript, - and reStructuredText domains. - -.. versionchanged:: 7.2 - - * The directive option ``:noindex:`` was renamed - to ``:no-index:``. - * The directive option ``:noindexentry:`` was renamed - to ``:no-index-entry:``. - * The directive option ``:nocontentsentry:`` was renamed - to ``:no-contents-entry:``. - - The previous names are retained as aliases, - but will be deprecated and removed - in a future version of Sphinx. - -An example using a Python domain directive:: - - .. py:function:: spam(eggs) - ham(eggs) - - Spam or ham the foo. - -This describes the two Python functions ``spam`` and ``ham``. (Note that when -signatures become too long, you can break them if you add a backslash to lines -that are continued in the next line. Example:: - - .. py:function:: filterwarnings(action, message='', category=Warning, \ - module='', lineno=0, append=False) - :no-index: - -(This example also shows how to use the ``:no-index:`` flag.) - -The domains also provide roles that link back to these object descriptions. -For example, to link to one of the functions described in the example above, -you could say :: - - The function :py:func:`spam` does a similar thing. - -As you can see, both directive and role names contain the domain name and the -directive name. - -The directive option ``:no-typesetting:`` can be used to create a target -(and index entry) which can later be referenced -by the roles provided by the domain. -This is particularly useful for literate programming: - -.. code-block:: rst - - .. py:function:: spam(eggs) - :no-typesetting: - - .. code:: - - def spam(eggs): - pass - - The function :py:func:`spam` does nothing. - -.. rubric:: Default Domain - -For documentation describing objects from solely one domain, authors will not -have to state again its name at each directive, role, etc... after -having specified a default. This can be done either via the config -value :confval:`primary_domain` or via this directive: - -.. rst:directive:: .. default-domain:: name - - Select a new default domain. While the :confval:`primary_domain` selects a - global default, this only has an effect within the same file. - -If no other default is selected, the Python domain (named ``py``) is the -default one, mostly for compatibility with documentation written for older -versions of Sphinx. - -Directives and roles that belong to the default domain can be mentioned without -giving the domain name, i.e. :: - - .. function:: pyfunc() - - Describes a Python function. - - Reference to :func:`pyfunc`. - -Cross-referencing syntax -~~~~~~~~~~~~~~~~~~~~~~~~ - -For cross-reference roles provided by domains, the same facilities exist as for -general cross-references. See :ref:`xref-syntax`. - -In short: - -* You may supply an explicit title and reference target: ``:role:`title - <target>``` will refer to *target*, but the link text will be *title*. - -* If you prefix the content with ``!``, no reference/hyperlink will be created. - -* If you prefix the content with ``~``, the link text will only be the last - component of the target. For example, ``:py:meth:`~Queue.Queue.get``` will - refer to ``Queue.Queue.get`` but only display ``get`` as the link text. - -.. _python-domain: - -The Python Domain ------------------ - -The Python domain (name **py**) provides the following directives for module -declarations: - -.. rst:directive:: .. py:module:: name - - This directive marks the beginning of the description of a module (or package - submodule, in which case the name should be fully qualified, including the - package name). A description of the module such as the docstring can be - placed in the body of the directive. - - This directive will also cause an entry in the global module index. - - .. versionchanged:: 5.2 - - Module directives support body content. - - .. rubric:: options - - .. rst:directive:option:: platform: platforms - :type: comma separated list - - Indicate platforms which the module is available (if it is available on - all platforms, the option should be omitted). The keys are short - identifiers; examples that are in use include "IRIX", "Mac", "Windows" - and "Unix". It is important to use a key which has already been used when - applicable. - - .. rst:directive:option:: synopsis: purpose - :type: text - - Consist of one sentence describing the module's purpose -- it is currently - only used in the Global Module Index. - - .. rst:directive:option:: deprecated - :type: no argument - - Mark a module as deprecated; it will be designated as such in various - locations then. - - - -.. rst:directive:: .. py:currentmodule:: name - - This directive tells Sphinx that the classes, functions etc. documented from - here are in the given module (like :rst:dir:`py:module`), but it will not - create index entries, an entry in the Global Module Index, or a link target - for :rst:role:`py:mod`. This is helpful in situations where documentation - for things in a module is spread over multiple files or sections -- one - location has the :rst:dir:`py:module` directive, the others only - :rst:dir:`py:currentmodule`. - -The following directives are provided for module and class contents: - -.. rst:directive:: .. py:function:: name(parameters) - .. py:function:: name[type parameters](parameters) - - Describes a module-level function. - The signature should include the parameters, - together with optional type parameters, - as given in the Python function definition, see :ref:`signatures`. - For example:: - - .. py:function:: Timer.repeat(repeat=3, number=1_000_000) - .. py:function:: add[T](a: T, b: T) -> T - - For methods you should use :rst:dir:`py:method`. - - The description normally includes information about the parameters required - and how they are used (especially whether mutable objects passed as - parameters are modified), side effects, and possible exceptions. - - This information can (in any ``py`` directive) optionally be given in a - structured form, see :ref:`info-field-lists`. - - .. rubric:: options - - .. rst:directive:option:: async - :type: no value - - Indicate the function is an async function. - - .. versionadded:: 2.1 - - .. rst:directive:option:: canonical - :type: full qualified name including module name - - Describe the location where the object is defined if the object is - imported from other modules - - .. versionadded:: 4.0 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's arguments will be emitted on a single logical - line, overriding :confval:`python_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - .. rst:directive:option:: single-line-type-parameter-list - :type: no value - - Ensure that the function's type parameters are emitted on a single - logical line, overriding :confval:`python_maximum_signature_line_length` - and :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - -.. rst:directive:: .. py:data:: name - - Describes global data in a module, including both variables and values used - as "defined constants." Class and object attributes are not documented - using this environment. - - .. rubric:: options - - .. rst:directive:option:: type: type of the variable - :type: text - - .. versionadded:: 2.4 - - .. rst:directive:option:: value: initial value of the variable - :type: text - - .. versionadded:: 2.4 - - .. rst:directive:option:: canonical - :type: full qualified name including module name - - Describe the location where the object is defined if the object is - imported from other modules - - .. versionadded:: 4.0 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - -.. rst:directive:: .. py:exception:: name - .. py:exception:: name(parameters) - .. py:exception:: name[type parmeters](parameters) - - Describes an exception class. - The signature can, but need not include parentheses with constructor arguments, - or may optionally include type parameters (see :pep:`695`). - - .. rubric:: options - - .. rst:directive:option:: final - :type: no value - - Indicate the class is a final class. - - .. versionadded:: 3.1 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - See :rst:dir:`py:class:single-line-parameter-list`. - - .. versionadded:: 7.1 - - .. rst:directive:option:: single-line-type-parameter-list - :type: no value - - See :rst:dir:`py:class:single-line-type-parameter-list`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. py:class:: name - .. py:class:: name(parameters) - .. py:class:: name[type parmeters](parameters) - - Describes a class. - The signature can optionally include type parameters (see :pep:`695`) - or parentheses with parameters which will be shown as the constructor arguments. - See also :ref:`signatures`. - - Methods and attributes belonging to the class should be placed in this - directive's body. If they are placed outside, the supplied name should - contain the class name so that cross-references still work. Example:: - - .. py:class:: Foo - - .. py:method:: quux() - - -- or -- - - .. py:class:: Bar - - .. py:method:: Bar.quux() - - The first way is the preferred one. - - .. rubric:: options - - .. rst:directive:option:: canonical - :type: full qualified name including module name - - Describe the location where the object is defined if the object is - imported from other modules - - .. versionadded:: 4.0 - - .. rst:directive:option:: final - :type: no value - - Indicate the class is a final class. - - .. versionadded:: 3.1 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the class constructor's arguments will be emitted on a single - logical line, overriding :confval:`python_maximum_signature_line_length` - and :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - .. rst:directive:option:: single-line-type-parameter-list - :type: no value - - Ensure that the class type parameters are emitted on a single logical - line, overriding :confval:`python_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - -.. rst:directive:: .. py:attribute:: name - - Describes an object data attribute. The description should include - information about the type of the data to be expected and whether it may be - changed directly. - - .. rubric:: options - - .. rst:directive:option:: type: type of the attribute - :type: text - - .. versionadded:: 2.4 - - .. rst:directive:option:: value: initial value of the attribute - :type: text - - .. versionadded:: 2.4 - - .. rst:directive:option:: canonical - :type: full qualified name including module name - - Describe the location where the object is defined if the object is - imported from other modules - - .. versionadded:: 4.0 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - -.. rst:directive:: .. py:property:: name - - Describes an object property. - - .. versionadded:: 4.0 - - .. rubric:: options - - .. rst:directive:option:: abstractmethod - :type: no value - - Indicate the property is abstract. - - .. rst:directive:option:: classmethod - :type: no value - - Indicate the property is a classmethod. - - .. versionaddedd: 4.2 - - .. rst:directive:option:: type: type of the property - :type: text - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - -.. rst:directive:: .. py:method:: name(parameters) - .. py:method:: name[type parameters](parameters) - - Describes an object method. The parameters should not include the ``self`` - parameter. The description should include similar information to that - described for ``function``. See also :ref:`signatures` and - :ref:`info-field-lists`. - - .. rubric:: options - - .. rst:directive:option:: abstractmethod - :type: no value - - Indicate the method is an abstract method. - - .. versionadded:: 2.1 - - .. rst:directive:option:: async - :type: no value - - Indicate the method is an async method. - - .. versionadded:: 2.1 - - .. rst:directive:option:: canonical - :type: full qualified name including module name - - Describe the location where the object is defined if the object is - imported from other modules - - .. versionadded:: 4.0 - - .. rst:directive:option:: classmethod - :type: no value - - Indicate the method is a class method. - - .. versionadded:: 2.1 - - .. rst:directive:option:: final - :type: no value - - Indicate the class is a final method. - - .. versionadded:: 3.1 - - .. rst::directive:option:: module - :type: text - - Describe the location where the object is defined. The default value is - the module specified by :rst:dir:`py:currentmodule`. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the method's arguments will be emitted on a single logical - line, overriding :confval:`python_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - .. rst:directive:option:: single-line-type-parameter-list - :type: no value - - Ensure that the method's type parameters are emitted on a single logical - line, overriding :confval:`python_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.2 - - .. rst:directive:option:: staticmethod - :type: no value - - Indicate the method is a static method. - - .. versionadded:: 2.1 - - -.. rst:directive:: .. py:staticmethod:: name(parameters) - .. py:staticmethod:: name[type parameters](parameters) - - Like :rst:dir:`py:method`, but indicates that the method is a static method. - - .. versionadded:: 0.4 - -.. rst:directive:: .. py:classmethod:: name(parameters) - .. py:classmethod:: name[type parameters](parameters) - - Like :rst:dir:`py:method`, but indicates that the method is a class method. - - .. versionadded:: 0.6 - -.. rst:directive:: .. py:decorator:: name - .. py:decorator:: name(parameters) - .. py:decorator:: name[type parameters](parameters) - - Describes a decorator function. The signature should represent the usage as - a decorator. For example, given the functions - - .. code-block:: python - - def removename(func): - func.__name__ = '' - return func - - def setnewname(name): - def decorator(func): - func.__name__ = name - return func - return decorator - - the descriptions should look like this:: - - .. py:decorator:: removename - - Remove name of the decorated function. - - .. py:decorator:: setnewname(name) - - Set name of the decorated function to *name*. - - (as opposed to ``.. py:decorator:: removename(func)``.) - - There is no ``py:deco`` role to link to a decorator that is marked up with - this directive; rather, use the :rst:role:`py:func` role. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the decorator's arguments will be emitted on a single logical - line, overriding :confval:`python_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - .. rst:directive:option:: single-line-type-parameter-list - :type: no value - - Ensure that the decorator's type parameters are emitted on a single - logical line, overriding :confval:`python_maximum_signature_line_length` - and :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.2 - -.. rst:directive:: .. py:decoratormethod:: name - .. py:decoratormethod:: name(signature) - .. py:decoratormethod:: name[type parameters](signature) - - Same as :rst:dir:`py:decorator`, but for decorators that are methods. - - Refer to a decorator method using the :rst:role:`py:meth` role. - -.. _signatures: - -Python Signatures -~~~~~~~~~~~~~~~~~ - -Signatures of functions, methods and class constructors can be given like they -would be written in Python. - -Default values for optional arguments can be given (but if they contain commas, -they will confuse the signature parser). Python 3-style argument annotations -can also be given as well as return type annotations:: - - .. py:function:: compile(source : string, filename, symbol='file') -> ast object - -For functions with optional parameters that don't have default values -(typically functions implemented in C extension modules without keyword -argument support), you can use brackets to specify the optional parts: - -.. py:function:: compile(source[, filename[, symbol]]) - :no-index: - -It is customary to put the opening bracket before the comma. - -Python 3.12 introduced *type parameters*, which are type variables -declared directly within the class or function definition: - -.. code:: python - - class AnimalList[AnimalT](list[AnimalT]): - ... - - def add[T](a: T, b: T) -> T: - return a + b - -The corresponding reStructuredText documentation would be: - -.. code:: rst - - .. py:class:: AnimalList[AnimalT] - - .. py:function:: add[T](a: T, b: T) -> T - -See :pep:`695` and :pep:`696` for details and the full specification. - -.. _info-field-lists: - -Info field lists -~~~~~~~~~~~~~~~~ - -.. versionadded:: 0.4 -.. versionchanged:: 3.0 - - meta fields are added. - -Inside Python object description directives, reST field lists with these fields -are recognized and formatted nicely: - -* ``param``, ``parameter``, ``arg``, ``argument``, ``key``, ``keyword``: - Description of a parameter. -* ``type``: Type of a parameter. Creates a link if possible. -* ``raises``, ``raise``, ``except``, ``exception``: That (and when) a specific - exception is raised. -* ``var``, ``ivar``, ``cvar``: Description of a variable. -* ``vartype``: Type of a variable. Creates a link if possible. -* ``returns``, ``return``: Description of the return value. -* ``rtype``: Return type. Creates a link if possible. -* ``meta``: Add metadata to description of the python object. The metadata will - not be shown on output document. For example, ``:meta private:`` indicates - the python object is private member. It is used in - :py:mod:`sphinx.ext.autodoc` for filtering members. - -.. note:: - - In current release, all ``var``, ``ivar`` and ``cvar`` are represented as - "Variable". There is no difference at all. - -The field names must consist of one of these keywords and an argument (except -for ``returns`` and ``rtype``, which do not need an argument). This is best -explained by an example:: - - .. py:function:: send_message(sender, recipient, message_body, [priority=1]) - - Send a message to a recipient - - :param str sender: The person sending the message - :param str recipient: The recipient of the message - :param str message_body: The body of the message - :param priority: The priority of the message, can be a number 1-5 - :type priority: integer or None - :return: the message id - :rtype: int - :raises ValueError: if the message_body exceeds 160 characters - :raises TypeError: if the message_body is not a basestring - -This will render like this: - -.. py:function:: send_message(sender, recipient, message_body, [priority=1]) - :no-index: - - Send a message to a recipient - - :param str sender: The person sending the message - :param str recipient: The recipient of the message - :param str message_body: The body of the message - :param priority: The priority of the message, can be a number 1-5 - :type priority: int or None - :return: the message id - :rtype: int - :raises ValueError: if the message_body exceeds 160 characters - :raises TypeError: if the message_body is not a basestring - -It is also possible to combine parameter type and description, if the type is a -single word, like this:: - - :param int priority: The priority of the message, can be a number 1-5 - -.. versionadded:: 1.5 - -Container types such as lists and dictionaries can be linked automatically -using the following syntax:: - - :type priorities: list(int) - :type priorities: list[int] - :type mapping: dict(str, int) - :type mapping: dict[str, int] - :type point: tuple(float, float) - :type point: tuple[float, float] - -Multiple types in a type field will be linked automatically if separated by the -word "or":: - - :type an_arg: int or None - :vartype a_var: str or int - :rtype: float or str - -.. _python-roles: - -Cross-referencing Python objects -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The following roles refer to objects in modules and are possibly hyperlinked if -a matching identifier is found: - -.. rst:role:: py:mod - - Reference a module; a dotted name may be used. This should also be used for - package names. - -.. rst:role:: py:func - - Reference a Python function; dotted names may be used. The role text needs - not include trailing parentheses to enhance readability; they will be added - automatically by Sphinx if the :confval:`add_function_parentheses` config - value is ``True`` (the default). - -.. rst:role:: py:data - - Reference a module-level variable. - -.. rst:role:: py:const - - Reference a "defined" constant. This may be a Python variable that is not - intended to be changed. - -.. rst:role:: py:class - - Reference a class; a dotted name may be used. - -.. rst:role:: py:meth - - Reference a method of an object. The role text can include the type name - and the method name; if it occurs within the description of a type, the type - name can be omitted. A dotted name may be used. - -.. rst:role:: py:attr - - Reference a data attribute of an object. - - .. note:: The role is also able to refer to property. - -.. rst:role:: py:exc - - Reference an exception. A dotted name may be used. - -.. rst:role:: py:obj - - Reference an object of unspecified type. Useful e.g. as the - :confval:`default_role`. - - .. versionadded:: 0.4 - -The name enclosed in this markup can include a module name and/or a class name. -For example, ``:py:func:`filter``` could refer to a function named ``filter`` -in the current module, or the built-in function of that name. In contrast, -``:py:func:`foo.filter``` clearly refers to the ``filter`` function in the -``foo`` module. - -Normally, names in these roles are searched first without any further -qualification, then with the current module name prepended, then with the -current module and class name (if any) prepended. If you prefix the name with -a dot, this order is reversed. For example, in the documentation of Python's -:mod:`codecs` module, ``:py:func:`open``` always refers to the built-in -function, while ``:py:func:`.open``` refers to :func:`codecs.open`. - -A similar heuristic is used to determine whether the name is an attribute of -the currently documented class. - -Also, if the name is prefixed with a dot, and no exact match is found, the -target is taken as a suffix and all object names with that suffix are searched. -For example, ``:py:meth:`.TarFile.close``` references the -``tarfile.TarFile.close()`` function, even if the current module is not -``tarfile``. Since this can get ambiguous, if there is more than one possible -match, you will get a warning from Sphinx. - -Note that you can combine the ``~`` and ``.`` prefixes: -``:py:meth:`~.TarFile.close``` will reference the ``tarfile.TarFile.close()`` -method, but the visible link caption will only be ``close()``. - - -.. _c-domain: - -The C Domain ------------- - -The C domain (name **c**) is suited for documentation of C API. - -.. rst:directive:: .. c:member:: declaration - .. c:var:: declaration - - Describes a C struct member or variable. Example signature:: - - .. c:member:: PyObject *PyTypeObject.tp_bases - - The difference between the two directives is only cosmetic. - -.. rst:directive:: .. c:function:: function prototype - - Describes a C function. The signature should be given as in C, e.g.:: - - .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) - - Note that you don't have to backslash-escape asterisks in the signature, as - it is not parsed by the reST inliner. - - In the description of a function you can use the following info fields - (see also :ref:`info-field-lists`). - - * ``param``, ``parameter``, ``arg``, ``argument``, - Description of a parameter. - * ``type``: Type of a parameter, - written as if passed to the :rst:role:`c:expr` role. - * ``returns``, ``return``: Description of the return value. - * ``rtype``: Return type, - written as if passed to the :rst:role:`c:expr` role. - * ``retval``, ``retvals``: An alternative to ``returns`` for describing - the result of the function. - - .. versionadded:: 4.3 - The ``retval`` field type. - - For example:: - - .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) - - :param type: description of the first parameter. - :param nitems: description of the second parameter. - :returns: a result. - :retval NULL: under some conditions. - :retval NULL: under some other conditions as well. - - which renders as - - .. c:function:: PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) - - .. - ** for some editors (e.g., vim) to stop bold-highlighting the source - - :param type: description of the first parameter. - :param nitems: description of the second parameter. - :returns: a result. - :retval NULL: under some conditions. - :retval NULL: under some other conditions as well. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's parameters will be emitted on a single logical - line, overriding :confval:`c_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - - -.. rst:directive:: .. c:macro:: name - .. c:macro:: name(arg list) - - Describes a C macro, i.e., a C-language ``#define``, without the replacement - text. - - In the description of a macro you can use the same info fields as for the - :rst:dir:`c:function` directive. - - .. versionadded:: 3.0 - The function style variant. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the macro's parameters will be emitted on a single logical - line, overriding :confval:`c_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. c:struct:: name - - Describes a C struct. - - .. versionadded:: 3.0 - -.. rst:directive:: .. c:union:: name - - Describes a C union. - - .. versionadded:: 3.0 - -.. rst:directive:: .. c:enum:: name - - Describes a C enum. - - .. versionadded:: 3.0 - -.. rst:directive:: .. c:enumerator:: name - - Describes a C enumerator. - - .. versionadded:: 3.0 - -.. rst:directive:: .. c:type:: typedef-like declaration - .. c:type:: name - - Describes a C type, either as a typedef, or the alias for an unspecified - type. - -.. _c-roles: - -Cross-referencing C constructs -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The following roles create cross-references to C-language constructs if they -are defined in the documentation: - -.. rst:role:: c:member - c:data - c:var - c:func - c:macro - c:struct - c:union - c:enum - c:enumerator - c:type - - Reference a C declaration, as defined above. - Note that :rst:role:`c:member`, :rst:role:`c:data`, and - :rst:role:`c:var` are equivalent. - - .. versionadded:: 3.0 - The var, struct, union, enum, and enumerator roles. - - -Anonymous Entities -~~~~~~~~~~~~~~~~~~ - -C supports anonymous structs, enums, and unions. -For the sake of documentation they must be given some name that starts with -``@``, e.g., ``@42`` or ``@data``. -These names can also be used in cross-references, -though nested symbols will be found even when omitted. -The ``@...`` name will always be rendered as **[anonymous]** (possibly as a -link). - -Example:: - - .. c:struct:: Data - - .. c:union:: @data - - .. c:var:: int a - - .. c:var:: double b - - Explicit ref: :c:var:`Data.@data.a`. Short-hand ref: :c:var:`Data.a`. - -This will be rendered as: - -.. c:struct:: Data - :no-contents-entry: - :no-index-entry: - - .. c:union:: @data - :no-contents-entry: - :no-index-entry: - - .. c:var:: int a - :no-contents-entry: - :no-index-entry: - - .. c:var:: double b - :no-contents-entry: - :no-index-entry: - -Explicit ref: :c:var:`Data.@data.a`. Short-hand ref: :c:var:`Data.a`. - -.. versionadded:: 3.0 - - -Aliasing Declarations -~~~~~~~~~~~~~~~~~~~~~ - -.. c:namespace-push:: @alias - -Sometimes it may be helpful list declarations elsewhere than their main -documentation, e.g., when creating a synopsis of an interface. -The following directive can be used for this purpose. - -.. rst:directive:: .. c:alias:: name - - Insert one or more alias declarations. Each entity can be specified - as they can in the :rst:role:`c:any` role. - - For example:: - - .. c:var:: int data - .. c:function:: int f(double k) - - .. c:alias:: data - f - - becomes - - .. c:var:: int data - .. c:function:: int f(double k) - - .. c:alias:: data - f - - .. versionadded:: 3.2 - - - .. rubric:: Options - - .. rst:directive:option:: maxdepth: int - - Insert nested declarations as well, up to the total depth given. - Use 0 for infinite depth and 1 for just the mentioned declaration. - Defaults to 1. - - .. versionadded:: 3.3 - - .. rst:directive:option:: noroot - - Skip the mentioned declarations and only render nested declarations. - Requires ``maxdepth`` either 0 or at least 2. - - .. versionadded:: 3.5 - - -.. c:namespace-pop:: - - -Inline Expressions and Types -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. rst:role:: c:expr - c:texpr - - Insert a C expression or type either as inline code (``cpp:expr``) - or inline text (``cpp:texpr``). For example:: - - .. c:var:: int a = 42 - - .. c:function:: int f(int i) - - An expression: :c:expr:`a * f(a)` (or as text: :c:texpr:`a * f(a)`). - - A type: :c:expr:`const Data*` - (or as text :c:texpr:`const Data*`). - - will be rendered as follows: - - .. c:var:: int a = 42 - :no-contents-entry: - :no-index-entry: - - .. c:function:: int f(int i) - :no-contents-entry: - :no-index-entry: - - An expression: :c:expr:`a * f(a)` (or as text: :c:texpr:`a * f(a)`). - - A type: :c:expr:`const Data*` - (or as text :c:texpr:`const Data*`). - - .. versionadded:: 3.0 - - -Namespacing -~~~~~~~~~~~ - -.. versionadded:: 3.1 - -The C language it self does not support namespacing, but it can sometimes be -useful to emulate it in documentation, e.g., to show alternate declarations. -The feature may also be used to document members of structs/unions/enums -separate from their parent declaration. - -The current scope can be changed using three namespace directives. They manage -a stack declarations where ``c:namespace`` resets the stack and changes a given -scope. - -The ``c:namespace-push`` directive changes the scope to a given inner scope -of the current one. - -The ``c:namespace-pop`` directive undoes the most recent -``c:namespace-push`` directive. - -.. rst:directive:: .. c:namespace:: scope specification - - Changes the current scope for the subsequent objects to the given scope, and - resets the namespace directive stack. Note that nested scopes can be - specified by separating with a dot, e.g.:: - - .. c:namespace:: Namespace1.Namespace2.SomeStruct.AnInnerStruct - - All subsequent objects will be defined as if their name were declared with - the scope prepended. The subsequent cross-references will be searched for - starting in the current scope. - - Using ``NULL`` or ``0`` as the scope will change to global scope. - -.. rst:directive:: .. c:namespace-push:: scope specification - - Change the scope relatively to the current scope. For example, after:: - - .. c:namespace:: A.B - - .. c:namespace-push:: C.D - - the current scope will be ``A.B.C.D``. - -.. rst:directive:: .. c:namespace-pop:: - - Undo the previous ``c:namespace-push`` directive (*not* just pop a scope). - For example, after:: - - .. c:namespace:: A.B - - .. c:namespace-push:: C.D - - .. c:namespace-pop:: - - the current scope will be ``A.B`` (*not* ``A.B.C``). - - If no previous ``c:namespace-push`` directive has been used, but only a - ``c:namespace`` directive, then the current scope will be reset to global - scope. That is, ``.. c:namespace:: A.B`` is equivalent to:: - - .. c:namespace:: NULL - - .. c:namespace-push:: A.B - -Configuration Variables -~~~~~~~~~~~~~~~~~~~~~~~ - -See :ref:`c-config`. - - -.. _cpp-domain: - -The C++ Domain --------------- - -The C++ domain (name **cpp**) supports documenting C++ projects. - -Directives for Declaring Entities -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The following directives are available. All declarations can start with a -visibility statement (``public``, ``private`` or ``protected``). - -.. rst:directive:: .. cpp:class:: class specifier - .. cpp:struct:: class specifier - - Describe a class/struct, possibly with specification of inheritance, e.g.,:: - - .. cpp:class:: MyClass : public MyBase, MyOtherBase - - The difference between :rst:dir:`cpp:class` and :rst:dir:`cpp:struct` is - only cosmetic: the prefix rendered in the output, and the specifier shown - in the index. - - The class can be directly declared inside a nested scope, e.g.,:: - - .. cpp:class:: OuterScope::MyClass : public MyBase, MyOtherBase - - A class template can be declared:: - - .. cpp:class:: template<typename T, std::size_t N> std::array - - or with a line break:: - - .. cpp:class:: template<typename T, std::size_t N> \ - std::array - - Full and partial template specialisations can be declared:: - - .. cpp:class:: template<> \ - std::array<bool, 256> - - .. cpp:class:: template<typename T> \ - std::array<T, 42> - - .. versionadded:: 2.0 - The :rst:dir:`cpp:struct` directive. - -.. rst:directive:: .. cpp:function:: (member) function prototype - - Describe a function or member function, e.g.,:: - - .. cpp:function:: bool myMethod(int arg1, std::string arg2) - - A function with parameters and types. - - .. cpp:function:: bool myMethod(int, double) - - A function with unnamed parameters. - - .. cpp:function:: const T &MyClass::operator[](std::size_t i) const - - An overload for the indexing operator. - - .. cpp:function:: operator bool() const - - A casting operator. - - .. cpp:function:: constexpr void foo(std::string &bar[2]) noexcept - - A constexpr function. - - .. cpp:function:: MyClass::MyClass(const MyClass&) = default - - A copy constructor with default implementation. - - Function templates can also be described:: - - .. cpp:function:: template<typename U> \ - void print(U &&u) - - and function template specialisations:: - - .. cpp:function:: template<> \ - void print(int i) - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's parameters will be emitted on a single logical - line, overriding :confval:`cpp_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. cpp:member:: (member) variable declaration - .. cpp:var:: (member) variable declaration - - Describe a variable or member variable, e.g.,:: - - .. cpp:member:: std::string MyClass::myMember - - .. cpp:var:: std::string MyClass::myOtherMember[N][M] - - .. cpp:member:: int a = 42 - - Variable templates can also be described:: - - .. cpp:member:: template<class T> \ - constexpr T pi = T(3.1415926535897932385) - -.. rst:directive:: .. cpp:type:: typedef declaration - .. cpp:type:: name - .. cpp:type:: type alias declaration - - Describe a type as in a typedef declaration, a type alias declaration, or - simply the name of a type with unspecified type, e.g.,:: - - .. cpp:type:: std::vector<int> MyList - - A typedef-like declaration of a type. - - .. cpp:type:: MyContainer::const_iterator - - Declaration of a type alias with unspecified type. - - .. cpp:type:: MyType = std::unordered_map<int, std::string> - - Declaration of a type alias. - - A type alias can also be templated:: - - .. cpp:type:: template<typename T> \ - MyContainer = std::vector<T> - - The example are rendered as follows. - - .. cpp:type:: std::vector<int> MyList - :no-contents-entry: - :no-index-entry: - - A typedef-like declaration of a type. - - .. cpp:type:: MyContainer::const_iterator - :no-contents-entry: - :no-index-entry: - - Declaration of a type alias with unspecified type. - - .. cpp:type:: MyType = std::unordered_map<int, std::string> - :no-contents-entry: - :no-index-entry: - - Declaration of a type alias. - - .. cpp:type:: template<typename T> \ - MyContainer = std::vector<T> - :no-contents-entry: - :no-index-entry: - -.. rst:directive:: .. cpp:enum:: unscoped enum declaration - .. cpp:enum-struct:: scoped enum declaration - .. cpp:enum-class:: scoped enum declaration - - Describe a (scoped) enum, possibly with the underlying type specified. Any - enumerators declared inside an unscoped enum will be declared both in the - enum scope and in the parent scope. Examples:: - - .. cpp:enum:: MyEnum - - An unscoped enum. - - .. cpp:enum:: MySpecificEnum : long - - An unscoped enum with specified underlying type. - - .. cpp:enum-class:: MyScopedEnum - - A scoped enum. - - .. cpp:enum-struct:: protected MyScopedVisibilityEnum : std::underlying_type<MySpecificEnum>::type - - A scoped enum with non-default visibility, and with a specified - underlying type. - -.. rst:directive:: .. cpp:enumerator:: name - .. cpp:enumerator:: name = constant - - Describe an enumerator, optionally with its value defined, e.g.,:: - - .. cpp:enumerator:: MyEnum::myEnumerator - - .. cpp:enumerator:: MyEnum::myOtherEnumerator = 42 - -.. rst:directive:: .. cpp:union:: name - - Describe a union. - - .. versionadded:: 1.8 - -.. rst:directive:: .. cpp:concept:: template-parameter-list name - - .. warning:: The support for concepts is experimental. It is based on the - current draft standard and the Concepts Technical Specification. - The features may change as they evolve. - - Describe a concept. It must have exactly 1 template parameter list. The name - may be a nested name. Example:: - - .. cpp:concept:: template<typename It> std::Iterator - - Proxy to an element of a notional sequence that can be compared, - indirected, or incremented. - - **Notation** - - .. cpp:var:: It r - - An lvalue. - - **Valid Expressions** - - - :cpp:expr:`*r`, when :cpp:expr:`r` is dereferenceable. - - :cpp:expr:`++r`, with return type :cpp:expr:`It&`, when - :cpp:expr:`r` is incrementable. - - This will render as follows: - - .. cpp:concept:: template<typename It> std::Iterator - - Proxy to an element of a notional sequence that can be compared, - indirected, or incremented. - - **Notation** - - .. cpp:var:: It r - - An lvalue. - - **Valid Expressions** - - - :cpp:expr:`*r`, when :cpp:expr:`r` is dereferenceable. - - :cpp:expr:`++r`, with return type :cpp:expr:`It&`, when :cpp:expr:`r` - is incrementable. - - .. versionadded:: 1.5 - - -Options -^^^^^^^ - -Some directives support options: - -- ``:no-index-entry:`` and ``:no-contents-entry:``, see :ref:`basic-domain-markup`. -- ``:tparam-line-spec:``, for templated declarations. - If specified, each template parameter will be rendered on a separate line. - - .. versionadded:: 1.6 - -Anonymous Entities -~~~~~~~~~~~~~~~~~~ - -C++ supports anonymous namespaces, classes, enums, and unions. -For the sake of documentation they must be given some name that starts with -``@``, e.g., ``@42`` or ``@data``. -These names can also be used in cross-references and (type) expressions, -though nested symbols will be found even when omitted. -The ``@...`` name will always be rendered as **[anonymous]** (possibly as a -link). - -Example:: - - .. cpp:class:: Data - - .. cpp:union:: @data - - .. cpp:var:: int a - - .. cpp:var:: double b - - Explicit ref: :cpp:var:`Data::@data::a`. Short-hand ref: :cpp:var:`Data::a`. - -This will be rendered as: - -.. cpp:class:: Data - :no-contents-entry: - :no-index-entry: - - .. cpp:union:: @data - :no-contents-entry: - :no-index-entry: - - .. cpp:var:: int a - :no-contents-entry: - :no-index-entry: - - .. cpp:var:: double b - :no-contents-entry: - :no-index-entry: - -Explicit ref: :cpp:var:`Data::@data::a`. Short-hand ref: :cpp:var:`Data::a`. - -.. versionadded:: 1.8 - - -Aliasing Declarations -~~~~~~~~~~~~~~~~~~~~~ - -Sometimes it may be helpful list declarations elsewhere than their main -documentation, e.g., when creating a synopsis of a class interface. -The following directive can be used for this purpose. - -.. rst:directive:: .. cpp:alias:: name or function signature - - Insert one or more alias declarations. Each entity can be specified - as they can in the :rst:role:`cpp:any` role. - If the name of a function is given (as opposed to the complete signature), - then all overloads of the function will be listed. - - For example:: - - .. cpp:alias:: Data::a - overload_example::C::f - - becomes - - .. cpp:alias:: Data::a - overload_example::C::f - - whereas:: - - .. cpp:alias:: void overload_example::C::f(double d) const - void overload_example::C::f(double d) - - becomes - - .. cpp:alias:: void overload_example::C::f(double d) const - void overload_example::C::f(double d) - - .. versionadded:: 2.0 - - - .. rubric:: Options - - .. rst:directive:option:: maxdepth: int - - Insert nested declarations as well, up to the total depth given. - Use 0 for infinite depth and 1 for just the mentioned declaration. - Defaults to 1. - - .. versionadded:: 3.5 - - .. rst:directive:option:: noroot - - Skip the mentioned declarations and only render nested declarations. - Requires ``maxdepth`` either 0 or at least 2. - - .. versionadded:: 3.5 - - -Constrained Templates -~~~~~~~~~~~~~~~~~~~~~ - -.. warning:: The support for concepts is experimental. It is based on the - current draft standard and the Concepts Technical Specification. - The features may change as they evolve. - -.. note:: Sphinx does not currently support ``requires`` clauses. - -Placeholders -^^^^^^^^^^^^ - -Declarations may use the name of a concept to introduce constrained template -parameters, or the keyword ``auto`` to introduce unconstrained template -parameters:: - - .. cpp:function:: void f(auto &&arg) - - A function template with a single unconstrained template parameter. - - .. cpp:function:: void f(std::Iterator it) - - A function template with a single template parameter, constrained by the - Iterator concept. - -Template Introductions -^^^^^^^^^^^^^^^^^^^^^^ - -Simple constrained function or class templates can be declared with a `template -introduction` instead of a template parameter list:: - - .. cpp:function:: std::Iterator{It} void advance(It &it) - - A function template with a template parameter constrained to be an - Iterator. - - .. cpp:class:: std::LessThanComparable{T} MySortedContainer - - A class template with a template parameter constrained to be - LessThanComparable. - -They are rendered as follows. - -.. cpp:function:: std::Iterator{It} void advance(It &it) - :no-contents-entry: - :no-index-entry: - - A function template with a template parameter constrained to be an Iterator. - -.. cpp:class:: std::LessThanComparable{T} MySortedContainer - :no-contents-entry: - :no-index-entry: - - A class template with a template parameter constrained to be - LessThanComparable. - -Note however that no checking is performed with respect to parameter -compatibility. E.g., ``Iterator{A, B, C}`` will be accepted as an introduction -even though it would not be valid C++. - -Inline Expressions and Types -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. rst:role:: cpp:expr - cpp:texpr - - Insert a C++ expression or type either as inline code (``cpp:expr``) - or inline text (``cpp:texpr``). For example:: - - .. cpp:var:: int a = 42 - - .. cpp:function:: int f(int i) - - An expression: :cpp:expr:`a * f(a)` (or as text: :cpp:texpr:`a * f(a)`). - - A type: :cpp:expr:`const MySortedContainer<int>&` - (or as text :cpp:texpr:`const MySortedContainer<int>&`). - - will be rendered as follows: - - .. cpp:var:: int a = 42 - :no-contents-entry: - :no-index-entry: - - .. cpp:function:: int f(int i) - :no-contents-entry: - :no-index-entry: - - An expression: :cpp:expr:`a * f(a)` (or as text: :cpp:texpr:`a * f(a)`). - - A type: :cpp:expr:`const MySortedContainer<int>&` - (or as text :cpp:texpr:`const MySortedContainer<int>&`). - - .. versionadded:: 1.7 - The :rst:role:`cpp:expr` role. - - .. versionadded:: 1.8 - The :rst:role:`cpp:texpr` role. - -Namespacing -~~~~~~~~~~~ - -Declarations in the C++ domain are as default placed in global scope. The -current scope can be changed using three namespace directives. They manage a -stack declarations where ``cpp:namespace`` resets the stack and changes a given -scope. - -The ``cpp:namespace-push`` directive changes the scope to a given inner scope -of the current one. - -The ``cpp:namespace-pop`` directive undoes the most recent -``cpp:namespace-push`` directive. - -.. rst:directive:: .. cpp:namespace:: scope specification - - Changes the current scope for the subsequent objects to the given scope, and - resets the namespace directive stack. Note that the namespace does not need - to correspond to C++ namespaces, but can end in names of classes, e.g.,:: - - .. cpp:namespace:: Namespace1::Namespace2::SomeClass::AnInnerClass - - All subsequent objects will be defined as if their name were declared with - the scope prepended. The subsequent cross-references will be searched for - starting in the current scope. - - Using ``NULL``, ``0``, or ``nullptr`` as the scope will change to global - scope. - - A namespace declaration can also be templated, e.g.,:: - - .. cpp:class:: template<typename T> \ - std::vector - - .. cpp:namespace:: template<typename T> std::vector - - .. cpp:function:: std::size_t size() const - - declares ``size`` as a member function of the class template - ``std::vector``. Equivalently this could have been declared using:: - - .. cpp:class:: template<typename T> \ - std::vector - - .. cpp:function:: std::size_t size() const - - or:: - - .. cpp:class:: template<typename T> \ - std::vector - -.. rst:directive:: .. cpp:namespace-push:: scope specification - - Change the scope relatively to the current scope. For example, after:: - - .. cpp:namespace:: A::B - - .. cpp:namespace-push:: C::D - - the current scope will be ``A::B::C::D``. - - .. versionadded:: 1.4 - -.. rst:directive:: .. cpp:namespace-pop:: - - Undo the previous ``cpp:namespace-push`` directive (*not* just pop a scope). - For example, after:: - - .. cpp:namespace:: A::B - - .. cpp:namespace-push:: C::D - - .. cpp:namespace-pop:: - - the current scope will be ``A::B`` (*not* ``A::B::C``). - - If no previous ``cpp:namespace-push`` directive has been used, but only a - ``cpp:namespace`` directive, then the current scope will be reset to global - scope. That is, ``.. cpp:namespace:: A::B`` is equivalent to:: - - .. cpp:namespace:: nullptr - - .. cpp:namespace-push:: A::B - - .. versionadded:: 1.4 - -Info field lists -~~~~~~~~~~~~~~~~~ - -All the C++ directives for declaring entities support the following -info fields (see also :ref:`info-field-lists`): - -* ``tparam``: Description of a template parameter. - -The :rst:dir:`cpp:function` directive additionally supports the -following fields: - -* ``param``, ``parameter``, ``arg``, ``argument``: Description of a parameter. -* ``returns``, ``return``: Description of a return value. -* ``retval``, ``retvals``: An alternative to ``returns`` for describing - the result of the function. -* `throws`, `throw`, `exception`: Description of a possibly thrown exception. - -.. versionadded:: 4.3 - The ``retval`` field type. - -.. _cpp-roles: - -Cross-referencing -~~~~~~~~~~~~~~~~~ - -These roles link to the given declaration types: - -.. rst:role:: cpp:any - cpp:class - cpp:struct - cpp:func - cpp:member - cpp:var - cpp:type - cpp:concept - cpp:enum - cpp:enumerator - - Reference a C++ declaration by name (see below for details). The name must - be properly qualified relative to the position of the link. - - .. versionadded:: 2.0 - The :rst:role:`cpp:struct` role as alias for the :rst:role:`cpp:class` - role. - -.. admonition:: Note on References with Templates Parameters/Arguments - - These roles follow the Sphinx :ref:`xref-syntax` rules. This means care must - be taken when referencing a (partial) template specialization, e.g. if the - link looks like this: ``:cpp:class:`MyClass<int>```. - This is interpreted as a link to ``int`` with a title of ``MyClass``. - In this case, escape the opening angle bracket with a backslash, - like this: ``:cpp:class:`MyClass\<int>```. - - When a custom title is not needed it may be useful to use the roles for - inline expressions, :rst:role:`cpp:expr` and :rst:role:`cpp:texpr`, where - angle brackets do not need escaping. - -Declarations without template parameters and template arguments -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -For linking to non-templated declarations the name must be a nested name, e.g., -``f`` or ``MyClass::f``. - - -Overloaded (member) functions -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -When a (member) function is referenced using just its name, the reference -will point to an arbitrary matching overload. -The :rst:role:`cpp:any` and :rst:role:`cpp:func` roles use an alternative -format, which simply is a complete function declaration. -This will resolve to the exact matching overload. -As example, consider the following class declaration: - -.. cpp:namespace-push:: overload_example -.. cpp:class:: C - - .. cpp:function:: void f(double d) const - .. cpp:function:: void f(double d) - .. cpp:function:: void f(int i) - .. cpp:function:: void f() - -References using the :rst:role:`cpp:func` role: - -- Arbitrary overload: ``C::f``, :cpp:func:`C::f` -- Also arbitrary overload: ``C::f()``, :cpp:func:`C::f()` -- Specific overload: ``void C::f()``, :cpp:func:`void C::f()` -- Specific overload: ``void C::f(int)``, :cpp:func:`void C::f(int)` -- Specific overload: ``void C::f(double)``, :cpp:func:`void C::f(double)` -- Specific overload: ``void C::f(double) const``, - :cpp:func:`void C::f(double) const` - -Note that the :confval:`add_function_parentheses` configuration variable -does not influence specific overload references. - -.. cpp:namespace-pop:: - - -Templated declarations -^^^^^^^^^^^^^^^^^^^^^^ - -Assume the following declarations. - -.. cpp:class:: Wrapper - - .. cpp:class:: template<typename TOuter> \ - Outer - - .. cpp:class:: template<typename TInner> \ - Inner - -In general the reference must include the template parameter declarations, -and template arguments for the prefix of qualified names. For example: - -- ``template\<typename TOuter> Wrapper::Outer`` - (:cpp:class:`template\<typename TOuter> Wrapper::Outer`) -- ``template\<typename TOuter> template\<typename TInner> Wrapper::Outer<TOuter>::Inner`` - (:cpp:class:`template\<typename TOuter> template\<typename TInner> Wrapper::Outer<TOuter>::Inner`) - -Currently the lookup only succeed if the template parameter identifiers are -equal strings. That is, ``template\<typename UOuter> Wrapper::Outer`` will not -work. - -As a shorthand notation, if a template parameter list is omitted, -then the lookup will assume either a primary template or a non-template, -but not a partial template specialisation. -This means the following references work as well: - -- ``Wrapper::Outer`` - (:cpp:class:`Wrapper::Outer`) -- ``Wrapper::Outer::Inner`` - (:cpp:class:`Wrapper::Outer::Inner`) -- ``template\<typename TInner> Wrapper::Outer::Inner`` - (:cpp:class:`template\<typename TInner> Wrapper::Outer::Inner`) - -(Full) Template Specialisations -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Assume the following declarations. - -.. cpp:class:: template<typename TOuter> \ - Outer - - .. cpp:class:: template<typename TInner> \ - Inner - -.. cpp:class:: template<> \ - Outer<int> - - .. cpp:class:: template<typename TInner> \ - Inner - - .. cpp:class:: template<> \ - Inner<bool> - -In general the reference must include a template parameter list for each -template argument list. The full specialisation above can therefore be -referenced with ``template\<> Outer\<int>`` (:cpp:class:`template\<> -Outer\<int>`) and ``template\<> template\<> Outer\<int>::Inner\<bool>`` -(:cpp:class:`template\<> template\<> Outer\<int>::Inner\<bool>`). As a -shorthand the empty template parameter list can be omitted, e.g., -``Outer\<int>`` (:cpp:class:`Outer\<int>`) and ``Outer\<int>::Inner\<bool>`` -(:cpp:class:`Outer\<int>::Inner\<bool>`). - -Partial Template Specialisations -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Assume the following declaration. - -.. cpp:class:: template<typename T> \ - Outer<T*> - -References to partial specialisations must always include the template -parameter lists, e.g., ``template\<typename T> Outer\<T*>`` -(:cpp:class:`template\<typename T> Outer\<T*>`). Currently the lookup only -succeed if the template parameter identifiers are equal strings. - -Configuration Variables -~~~~~~~~~~~~~~~~~~~~~~~ - -See :ref:`cpp-config`. - -.. _domains-std: - -The Standard Domain +MOVED: Basic Markup ------------------- -The so-called "standard" domain collects all markup that doesn't warrant a -domain of its own. Its directives and roles are not prefixed with a domain -name. - -The standard domain is also where custom object descriptions, added using the -:func:`~sphinx.application.Sphinx.add_object_type` API, are placed. - -There is a set of directives allowing documenting command-line programs: - -.. rst:directive:: .. option:: name args, name args, ... - - Describes a command line argument or switch. Option argument names should - be enclosed in angle brackets. Examples:: - - .. option:: dest_dir - - Destination directory. - - .. option:: -m <module>, --module <module> - - Run a module as a script. - - The directive will create cross-reference targets for the given options, - referenceable by :rst:role:`option` (in the example case, you'd use something - like ``:option:`dest_dir```, ``:option:`-m```, or ``:option:`--module```). - - .. versionchanged:: 5.3 - - One can cross-reference including an option value: ``:option:`--module=foobar```, - ,``:option:`--module[=foobar]``` or ``:option:`--module foobar```. - - Use :confval:`option_emphasise_placeholders` for parsing of - "variable part" of a literal text (similarly to the :rst:role:`samp` role). - - ``cmdoption`` directive is a deprecated alias for the ``option`` directive. - -.. rst:directive:: .. envvar:: name - - Describes an environment variable that the documented code or program uses - or defines. Referenceable by :rst:role:`envvar`. - -.. rst:directive:: .. program:: name - - Like :rst:dir:`py:currentmodule`, this directive produces no output. - Instead, it serves to notify Sphinx that all following :rst:dir:`option` - directives document options for the program called *name*. - - If you use :rst:dir:`program`, you have to qualify the references in your - :rst:role:`option` roles by the program name, so if you have the following - situation :: - - .. program:: rm - - .. option:: -r - - Work recursively. - - .. program:: svn - - .. option:: -r <revision> - - Specify the revision to work upon. - - then ``:option:`rm -r``` would refer to the first option, while - ``:option:`svn -r``` would refer to the second one. - - If ``None`` is passed to the argument, the directive will reset the - current program name. - - The program name may contain spaces (in case you want to document - subcommands like ``svn add`` and ``svn commit`` separately). - - .. versionadded:: 0.5 - -There is also a very generic object description directive, which is not tied to -any domain: - -.. rst:directive:: .. describe:: text - .. object:: text - - This directive produces the same formatting as the specific ones provided by - domains, but does not create index entries or cross-referencing targets. - Example:: - - .. describe:: PAPER - - You can set this variable to select a paper size. - - -The JavaScript Domain ---------------------- - -The JavaScript domain (name **js**) provides the following directives: - -.. rst:directive:: .. js:module:: name - - This directive sets the module name for object declarations that follow - after. The module name is used in the global module index and in cross - references. This directive does not create an object heading like - :rst:dir:`py:class` would, for example. - - By default, this directive will create a linkable entity and will cause an - entry in the global module index, unless the ``no-index`` option is - specified. If this option is specified, the directive will only update the - current module name. - - .. versionadded:: 1.6 - .. versionchanged:: 5.2 - - Module directives support body content. - -.. rst:directive:: .. js:function:: name(signature) - - Describes a JavaScript function or method. If you want to describe - arguments as optional use square brackets as :ref:`documented <signatures>` - for Python signatures. - - You can use fields to give more details about arguments and their expected - types, errors which may be thrown by the function, and the value being - returned:: - - .. js:function:: $.getJSON(href, callback[, errback]) - - :param string href: An URI to the location of the resource. - :param callback: Gets called with the object. - :param errback: - Gets called in case the request fails. And a lot of other - text so we need multiple lines. - :throws SomeError: For whatever reason in that case. - :returns: Something. - - This is rendered as: - - .. js:function:: $.getJSON(href, callback[, errback]) - :no-index: - - :param string href: An URI to the location of the resource. - :param callback: Gets called with the object. - :param errback: - Gets called in case the request fails. And a lot of other - text so we need multiple lines. - :throws SomeError: For whatever reason in that case. - :returns: Something. - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's parameters will be emitted on a single logical - line, overriding :confval:`javascript_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. js:method:: name(signature) - - This directive is an alias for :rst:dir:`js:function`, however it describes - a function that is implemented as a method on a class object. - - .. versionadded:: 1.6 - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's parameters will be emitted on a single logical - line, overriding :confval:`javascript_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. js:class:: name - - Describes a constructor that creates an object. This is basically like a - function but will show up with a `class` prefix:: - - .. js:class:: MyAnimal(name[, age]) - - :param string name: The name of the animal - :param number age: an optional age for the animal - - This is rendered as: - - .. js:class:: MyAnimal(name[, age]) - :no-index: - - :param string name: The name of the animal - :param number age: an optional age for the animal - - .. rst:directive:option:: single-line-parameter-list - :type: no value - - Ensures that the function's parameters will be emitted on a single logical - line, overriding :confval:`javascript_maximum_signature_line_length` and - :confval:`maximum_signature_line_length`. - - .. versionadded:: 7.1 - -.. rst:directive:: .. js:data:: name - - Describes a global variable or constant. - -.. rst:directive:: .. js:attribute:: object.name - - Describes the attribute *name* of *object*. - -.. _js-roles: - -These roles are provided to refer to the described objects: - -.. rst:role:: js:mod - js:func - js:meth - js:class - js:data - js:attr - - -The reStructuredText domain ---------------------------- - -The reStructuredText domain (name **rst**) provides the following directives: - -.. rst:directive:: .. rst:directive:: name - - Describes a reST directive. The *name* can be a single directive name or - actual directive syntax (`..` prefix and `::` suffix) with arguments that - will be rendered differently. For example:: - - .. rst:directive:: foo - - Foo description. - - .. rst:directive:: .. bar:: baz - - Bar description. - - will be rendered as: - - .. rst:directive:: foo - :no-index: - - Foo description. - - .. rst:directive:: .. bar:: baz - :no-index: - - Bar description. - -.. rst:directive:: .. rst:directive:option:: name - - Describes an option for reST directive. The *name* can be a single option - name or option name with arguments which separated with colon (``:``). - For example:: - - .. rst:directive:: toctree - - .. rst:directive:option:: caption: caption of ToC - - .. rst:directive:option:: glob - - will be rendered as: - - .. rst:directive:: toctree - :no-index: - - .. rst:directive:option:: caption: caption of ToC - :no-index: - - .. rst:directive:option:: glob - :no-index: - - .. rubric:: options - - .. rst:directive:option:: type: description of argument - :type: text - - Describe the type of option value. - - For example:: - - .. rst:directive:: toctree - - .. rst:directive:option:: maxdepth - :type: integer or no value - - .. versionadded:: 2.1 - -.. rst:directive:: .. rst:role:: name - - Describes a reST role. For example:: - - .. rst:role:: foo - - Foo description. - - will be rendered as: - - .. rst:role:: foo - :no-index: - - Foo description. - -.. _rst-roles: - -These roles are provided to refer to the described objects: - -.. rst:role:: rst:dir - rst:role - -.. _math-domain: - -The Math Domain +.. raw:: html + + <span id="basic-markup"> + <span id="basic-domain-markup"> + <span id="directive-default-domain"> + <span id="cross-referencing-syntax"> + +See :doc:`/usage/domains/index`. + + +MOVED: Python Domain +-------------------- + +.. raw:: html + + <span id="the-python-domain"> + <span id="python-domain"> + <span id="directive-py-module"> + <span id="directive-option-py-module-platform"> + <span id="directive-option-py-module-synopsis"> + <span id="directive-option-py-module-deprecated"> + <span id="directive-py-currentmodule"> + <span id="directive-py-function"> + <span id="directive-option-py-function-async"> + <span id="directive-option-py-function-canonical"> + <span id="directive-option-py-function-single-line-parameter-list"> + <span id="directive-option-py-function-single-line-type-parameter-list"> + <span id="directive-py-data"> + <span id="directive-option-py-data-type"> + <span id="directive-option-py-data-value"> + <span id="directive-option-py-data-canonical"> + <span id="directive-py-exception"> + <span id="index-0"> + <span id="directive-option-py-exception-final"> + <span id="directive-option-py-exception-single-line-parameter-list"> + <span id="directive-option-py-exception-single-line-type-parameter-list"> + <span id="directive-py-class"> + <span id="index-1"> + <span id="directive-option-py-class-canonical"> + <span id="directive-option-py-class-final"> + <span id="directive-option-py-class-single-line-parameter-list"> + <span id="directive-option-py-class-single-line-type-parameter-list"> + <span id="directive-py-attribute"> + <span id="directive-option-py-attribute-type"> + <span id="directive-option-py-attribute-value"> + <span id="directive-option-py-attribute-canonical"> + <span id="directive-py-property"> + <span id="directive-option-py-property-abstractmethod"> + <span id="directive-option-py-property-classmethod"> + <span id="directive-option-py-property-type"> + <span id="directive-py-method"> + <span id="directive-option-py-method-abstractmethod"> + <span id="directive-option-py-method-async"> + <span id="directive-option-py-method-canonical"> + <span id="directive-option-py-method-classmethod"> + <span id="directive-option-py-method-final"> + <span id="directive-option-py-method-single-line-parameter-list"> + <span id="directive-option-py-method-single-line-type-parameter-list"> + <span id="directive-option-py-method-staticmethod"> + <span id="directive-py-staticmethod"> + <span id="directive-py-classmethod"> + <span id="directive-py-decorator"> + <span id="directive-option-py-decorator-single-line-parameter-list"> + <span id="directive-option-py-decorator-single-line-type-parameter-list"> + <span id="directive-py-decoratormethod"> + <span id="python-signatures"> + <span id="signatures"> + <span id="index-2"> + <span id="index-3"> + <span id="info-field-lists"> + <span id="id1"> + <span id="cross-referencing-python-objects"> + <span id="python-roles"> + <span id="role-py-mod"> + <span id="role-py-func"> + <span id="role-py-data"> + <span id="role-py-const"> + <span id="role-py-class"> + <span id="role-py-meth"> + <span id="role-py-attr"> + <span id="role-py-exc"> + <span id="role-py-obj"> + +See :doc:`/usage/domains/python`. + + +MOVED: C Domain --------------- -The math domain (name **math**) provides the following roles: - -.. rst:role:: math:numref - - Role for cross-referencing equations defined by :rst:dir:`math` directive - via their label. Example:: - - .. math:: e^{i\pi} + 1 = 0 - :label: euler - - Euler's identity, equation :math:numref:`euler`, was elected one of the - most beautiful mathematical formulas. - - .. versionadded:: 1.8 +.. raw:: html + + <span id="the-c-domain"> + <span id="c-domain"> + <span id="directive-c-member"> + <span id="directive-c-var"> + <span id="directive-c-function"> + <span id="directive-option-c-function-single-line-parameter-list"> + <span id="directive-c-macro"> + <span id="directive-option-c-macro-single-line-parameter-list"> + <span id="directive-c-struct"> + <span id="directive-c-union"> + <span id="directive-c-enum"> + <span id="directive-c-enumerator"> + <span id="directive-c-type"> + <span id="cross-referencing-c-constructs"> + <span id="c-roles"> + <span id="role-c-member"> + <span id="role-c-data"> + <span id="role-c-var"> + <span id="role-c-func"> + <span id="role-c-macro"> + <span id="role-c-struct"> + <span id="role-c-union"> + <span id="role-c-enum"> + <span id="role-c-enumerator"> + <span id="role-c-type"> + <span id="anonymous-entities"> + <span id="aliasing-declarations"> + <span id="directive-c-alias"> + <span id="directive-option-c-alias-maxdepth"> + <span id="directive-option-c-alias-noroot"> + <span id="inline-expressions-and-types"> + <span id="role-c-expr"> + <span id="role-c-texpr"> + <span id="namespacing"> + <span id="directive-c-namespace"> + <span id="directive-c-namespace-push"> + <span id="directive-c-namespace-pop"> + <span id="configuration-variables"> + +See :doc:`/usage/domains/c`. + + +MOVED: C++ Domain +----------------- -More domains ------------- +.. raw:: html + + <span id="cpp-domain"> + <span id="id2"> + <span id="directives-for-declaring-entities"> + <span id="directive-cpp-class"> + <span id="directive-cpp-struct"> + <span id="directive-cpp-function"> + <span id="directive-option-cpp-function-single-line-parameter-list"> + <span id="directive-cpp-member"> + <span id="directive-cpp-var"> + <span id="directive-cpp-type"> + <span id="directive-cpp-enum"> + <span id="directive-cpp-enum-struct"> + <span id="directive-cpp-enum-class"> + <span id="directive-cpp-enumerator"> + <span id="directive-cpp-union"> + <span id="directive-cpp-concept"> + <span id="options"> + <span id="id3"> + <span id="id4"> + <span id="directive-cpp-alias"> + <span id="directive-option-cpp-alias-maxdepth"> + <span id="directive-option-cpp-alias-noroot"> + <span id="constrained-templates"> + <span id="placeholders"> + <span id="template-introductions"> + <span id="id5"> + <span id="role-cpp-expr"> + <span id="role-cpp-texpr"> + <span id="id6"> + <span id="directive-cpp-namespace"> + <span id="directive-cpp-namespace-push"> + <span id="directive-cpp-namespace-pop"> + <span id="id7"> + <span id="cross-referencing"> + <span id="cpp-roles"> + <span id="role-cpp-any"> + <span id="role-cpp-class"> + <span id="role-cpp-struct"> + <span id="role-cpp-func"> + <span id="role-cpp-member"> + <span id="role-cpp-var"> + <span id="role-cpp-type"> + <span id="role-cpp-concept"> + <span id="role-cpp-enum"> + <span id="role-cpp-enumerator"> + <span id="declarations-without-template-parameters-and-template-arguments"> + <span id="overloaded-member-functions"> + <span id="templated-declarations"> + <span id="full-template-specialisations"> + <span id="partial-template-specialisations"> + <span id="id8"> + +See :doc:`/usage/domains/cpp`. + + +MOVED: Standard Domain +---------------------- + +.. raw:: html + + <span id="the-standard-domain"> + <span id="domains-std"> + <span id="directive-option"> + <span id="directive-envvar"> + <span id="directive-program"> + <span id="directive-describe"> + <span id="directive-object"> + +See :doc:`/usage/domains/standard`. + + +MOVED: JavaScript Domain +------------------------ + +.. raw:: html + + <span id="the-javascript-domain"> + <span id="directive-js-module"> + <span id="directive-js-function"> + <span id="directive-option-js-function-single-line-parameter-list"> + <span id="directive-js-method"> + <span id="directive-option-js-method-single-line-parameter-list"> + <span id="directive-js-class"> + <span id="directive-option-js-class-single-line-parameter-list"> + <span id="directive-js-data"> + <span id="directive-js-attribute"> + <span id="js-roles"> + <span id="role-js-mod"> + <span id="role-js-func"> + <span id="role-js-meth"> + <span id="role-js-class"> + <span id="role-js-data"> + <span id="role-js-attr"> + +See :doc:`/usage/domains/javascript`. + + +MOVED: reStructuredText Domain +------------------------------ + +.. raw:: html + + <span id="the-restructuredtext-domain"> + <span id="directive-rst-directive"> + <span id="directive-rst-directive-option"> + <span id="directive-option-rst-directive-option-type"> + <span id="directive-rst-role"> + <span id="rst-roles"> + <span id="role-rst-dir"> + <span id="role-rst-role"> + +See :doc:`/usage/domains/restructuredtext`. + + +MOVED: Math Domain +------------------ + +.. raw:: html + + <span id="the-math-domain"> + <span id="math-domain"> + <span id="role-math-numref"> + +See :doc:`/usage/domains/mathematics`. + +MOVED: More domains +------------------- -The sphinx-contrib_ repository contains more domains available as extensions; -currently Ada_, CoffeeScript_, Erlang_, HTTP_, Lasso_, MATLAB_, PHP_, and Ruby_ -domains. Also available are domains for `Chapel`_, `Common Lisp`_, dqn_, Go_, -Jinja_, Operation_, and Scala_. +.. raw:: html -.. _sphinx-contrib: https://github.com/sphinx-contrib + <span id="more-domains"> -.. _Ada: https://pypi.org/project/sphinxcontrib-adadomain/ -.. _Chapel: https://pypi.org/project/sphinxcontrib-chapeldomain/ -.. _CoffeeScript: https://pypi.org/project/sphinxcontrib-coffee/ -.. _Common Lisp: https://pypi.org/project/sphinxcontrib-cldomain/ -.. _dqn: https://pypi.org/project/sphinxcontrib-dqndomain/ -.. _Erlang: https://pypi.org/project/sphinxcontrib-erlangdomain/ -.. _Go: https://pypi.org/project/sphinxcontrib-golangdomain/ -.. _HTTP: https://pypi.org/project/sphinxcontrib-httpdomain/ -.. _Jinja: https://pypi.org/project/sphinxcontrib-jinjadomain/ -.. _Lasso: https://pypi.org/project/sphinxcontrib-lassodomain/ -.. _MATLAB: https://pypi.org/project/sphinxcontrib-matlabdomain/ -.. _Operation: https://pypi.org/project/sphinxcontrib-operationdomain/ -.. _PHP: https://pypi.org/project/sphinxcontrib-phpdomain/ -.. _Ruby: https://github.com/sphinx-contrib/rubydomain -.. _Scala: https://pypi.org/project/sphinxcontrib-scaladomain/ +See :doc:`/usage/domains/index`. diff --git a/doc/usage/restructuredtext/field-lists.rst b/doc/usage/restructuredtext/field-lists.rst index 5fc897d..62dad5c 100644 --- a/doc/usage/restructuredtext/field-lists.rst +++ b/doc/usage/restructuredtext/field-lists.rst @@ -73,6 +73,6 @@ At the moment, these metadata fields are recognized: :nosearch: - .. note:: object search is still available even if `nosearch` option is set. + .. note:: object search is still available even if ``nosearch`` option is set. .. versionadded:: 3.0 diff --git a/doc/usage/restructuredtext/index.rst b/doc/usage/restructuredtext/index.rst index 87b6ed6..0fe311e 100644 --- a/doc/usage/restructuredtext/index.rst +++ b/doc/usage/restructuredtext/index.rst @@ -21,4 +21,8 @@ __ https://docutils.sourceforge.io/rst.html roles directives field-lists + +.. toctree:: + :hidden: + domains diff --git a/doc/usage/restructuredtext/roles.rst b/doc/usage/restructuredtext/roles.rst index e468de9..b21a2b7 100644 --- a/doc/usage/restructuredtext/roles.rst +++ b/doc/usage/restructuredtext/roles.rst @@ -15,267 +15,28 @@ They are written as ``:rolename:`content```. :rst:role:`any` role to find anything or the :rst:role:`py:obj` role to find Python objects are very useful for this. -See :doc:`/usage/restructuredtext/domains` for roles added by domains. +See :doc:`/usage/domains/index` for roles added by domains. -.. _xref-syntax: - Cross-referencing syntax ------------------------ -Cross-references are generated by many semantic interpreted text roles. -Basically, you only need to write ``:role:`target```, and a link will be -created to the item named *target* of the type indicated by *role*. The link's -text will be the same as *target*. - -There are some additional facilities, however, that make cross-referencing -roles more versatile: - -* You may supply an explicit title and reference target, like in reST direct - hyperlinks: ``:role:`title <target>``` will refer to *target*, but the link - text will be *title*. - -* If you prefix the content with ``!``, no reference/hyperlink will be created. - -* If you prefix the content with ``~``, the link text will only be the last - component of the target. For example, ``:py:meth:`~Queue.Queue.get``` will - refer to ``Queue.Queue.get`` but only display ``get`` as the link text. This - does not work with all cross-reference roles, but is domain specific. - - In HTML output, the link's ``title`` attribute (that is e.g. shown as a - tool-tip on mouse-hover) will always be the full target name. - - -.. _any-role: - -Cross-referencing anything -^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. rst:role:: any - - .. versionadded:: 1.3 - - This convenience role tries to do its best to find a valid target for its - reference text. - - * First, it tries standard cross-reference targets that would be referenced - by :rst:role:`doc`, :rst:role:`ref` or :rst:role:`option`. - - Custom objects added to the standard domain by extensions (see - :meth:`.Sphinx.add_object_type`) are also searched. - - * Then, it looks for objects (targets) in all loaded domains. It is up to - the domains how specific a match must be. For example, in the Python - domain a reference of ``:any:`Builder``` would match the - ``sphinx.builders.Builder`` class. - - If none or multiple targets are found, a warning will be emitted. In the - case of multiple targets, you can change "any" to a specific role. - - This role is a good candidate for setting :confval:`default_role`. If you - do, you can write cross-references without a lot of markup overhead. For - example, in this Python function documentation:: - - .. function:: install() - - This function installs a `handler` for every signal known by the - `signal` module. See the section `about-signals` for more information. - - there could be references to a glossary term (usually ``:term:`handler```), a - Python module (usually ``:py:mod:`signal``` or ``:mod:`signal```) and a - section (usually ``:ref:`about-signals```). - - The :rst:role:`any` role also works together with the - :mod:`~sphinx.ext.intersphinx` extension: when no local cross-reference is - found, all object types of intersphinx inventories are also searched. - -Cross-referencing objects -^^^^^^^^^^^^^^^^^^^^^^^^^ - -These roles are described with their respective domains: - -* :ref:`Python <python-roles>` -* :ref:`C <c-roles>` -* :ref:`C++ <cpp-roles>` -* :ref:`JavaScript <js-roles>` -* :ref:`ReST <rst-roles>` - - -.. _ref-role: - -Cross-referencing arbitrary locations -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. rst:role:: ref - - To support cross-referencing to arbitrary locations in any document, the - standard reST labels are used. For this to work label names must be unique - throughout the entire documentation. There are two ways in which you can - refer to labels: - - * If you place a label directly before a section title, you can reference to - it with ``:ref:`label-name```. For example:: - - .. _my-reference-label: - - Section to cross-reference - -------------------------- - - This is the text of the section. - - It refers to the section itself, see :ref:`my-reference-label`. - - The ``:ref:`` role would then generate a link to the section, with the - link title being "Section to cross-reference". This works just as well - when section and reference are in different source files. - - Automatic labels also work with figures. For example:: - - .. _my-figure: - - .. figure:: whatever - - Figure caption - - In this case, a reference ``:ref:`my-figure``` would insert a reference - to the figure with link text "Figure caption". - - The same works for tables that are given an explicit caption using the - :dudir:`table` directive. - - * Labels that aren't placed before a section title can still be referenced, - but you must give the link an explicit title, using this syntax: - ``:ref:`Link title <label-name>```. - - .. note:: +See :doc:`/usage/referencing/`. - Reference labels must start with an underscore. When referencing a label, - the underscore must be omitted (see examples above). +Cross-reference roles include: - Using :rst:role:`ref` is advised over standard reStructuredText links to - sections (like ```Section title`_``) because it works across files, when - section headings are changed, will raise warnings if incorrect, and works - for all builders that support cross-references. +* :rst:role:`any` +* :rst:role:`doc` +* :rst:role:`download` +* :rst:role:`envvar` +* :rst:role:`keyword` +* :rst:role:`numref` +* :rst:role:`option` (and the deprecated :rst:role:`!cmdoption`) +* :rst:role:`ref` +* :rst:role:`term` +* :rst:role:`token` -Cross-referencing documents -^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. versionadded:: 0.6 - -There is also a way to directly link to documents: - -.. rst:role:: doc - - Link to the specified document; the document name can be specified in - absolute or relative fashion. For example, if the reference - ``:doc:`parrot``` occurs in the document ``sketches/index``, then the link - refers to ``sketches/parrot``. If the reference is ``:doc:`/people``` or - ``:doc:`../people```, the link refers to ``people``. - - If no explicit link text is given (like usual: ``:doc:`Monty Python members - </people>```), the link caption will be the title of the given document. - - -Referencing downloadable files -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. versionadded:: 0.6 - -.. rst:role:: download - - This role lets you link to files within your source tree that are not reST - documents that can be viewed, but files that can be downloaded. - - When you use this role, the referenced file is automatically marked for - inclusion in the output when building (obviously, for HTML output only). - All downloadable files are put into a ``_downloads/<unique hash>/`` - subdirectory of the output directory; duplicate filenames are handled. - - An example:: - - See :download:`this example script <../example.py>`. - - The given filename is usually relative to the directory the current source - file is contained in, but if it absolute (starting with ``/``), it is taken - as relative to the top source directory. - - The ``example.py`` file will be copied to the output directory, and a - suitable link generated to it. - - Not to show unavailable download links, you should wrap whole paragraphs that - have this role:: - - .. only:: builder_html - - See :download:`this example script <../example.py>`. - -Cross-referencing figures by figure number -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. versionadded:: 1.3 - -.. versionchanged:: 1.5 - `numref` role can also refer sections. - And `numref` allows `{name}` for the link text. - -.. rst:role:: numref - - Link to the specified figures, tables, code-blocks and sections; the standard - reST labels are used. When you use this role, it will insert a reference to - the figure with link text by its figure number like "Fig. 1.1". - - If an explicit link text is given (as usual: ``:numref:`Image of Sphinx (Fig. - %s) <my-figure>```), the link caption will serve as title of the reference. - As placeholders, `%s` and `{number}` get replaced by the figure - number and `{name}` by the figure caption. - If no explicit link text is given, the :confval:`numfig_format` setting is - used as fall-back default. - - If :confval:`numfig` is ``False``, figures are not numbered, - so this role inserts not a reference but the label or the link text. - -Cross-referencing other items of interest -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -The following roles do possibly create a cross-reference, but do not refer to -objects: - -.. rst:role:: envvar - - An environment variable. Index entries are generated. Also generates a link - to the matching :rst:dir:`envvar` directive, if it exists. - -.. rst:role:: token - - The name of a grammar token (used to create links between - :rst:dir:`productionlist` directives). - -.. rst:role:: keyword - - The name of a keyword in Python. This creates a link to a reference label - with that name, if it exists. - -.. rst:role:: option - - A command-line option to an executable program. This generates a link to - a :rst:dir:`option` directive, if it exists. - - -The following role creates a cross-reference to a term in a -:ref:`glossary <glossary-directive>`: - -.. rst:role:: term - - Reference to a term in a glossary. A glossary is created using the - ``glossary`` directive containing a definition list with terms and - definitions. It does not have to be in the same file as the ``term`` markup, - for example the Python docs have one global glossary in the ``glossary.rst`` - file. - - If you use a term that's not explained in a glossary, you'll get a warning - during build. - Inline code highlighting ------------------------ @@ -414,6 +175,10 @@ different style: ``:manpage:`ls(1)``` displays :manpage:`ls(1)`. Creates a hyperlink to an external site rendering the manpage if :confval:`manpages_url` is defined. + .. versionchanged:: 7.3 + Allow specifying a target with ``<>``, like hyperlinks. + For example, ``:manpage:`blah <ls(1)>``` displays :manpage:`blah <ls(1)>`. + .. rst:role:: menuselection Menu selections should be marked using the ``menuselection`` role. This is @@ -468,14 +233,17 @@ different style: A piece of literal text, such as code. Within the contents, you can use curly braces to indicate a "variable" part, as in :rst:role:`file`. For - example, in ``:samp:`print 1+{variable}```, the part ``variable`` would be - emphasized: :samp:`print 1+{variable}` + example, in ``:samp:`print(1+{variable})```, the part ``variable`` would be + emphasized: :samp:`print(1+{variable})` If you don't need the "variable part" indication, use the standard :rst:role:`code` role instead. .. versionchanged:: 1.8 - Allowed to escape curly braces with backslash + Allowed to escape curly braces with double backslash. For example, in + ``:samp:`print(f"answer=\\{1+{variable}*2\\}")```, the part ``variable`` + would be emphasized and the escaped curly braces would be displayed: + :samp:`print(f"answer=\\{1+{variable}*2\\}")` There is also an :rst:role:`index` role to generate index entries. @@ -508,7 +276,7 @@ the standard reST markup for that purpose. Substitutions ------------- -The documentation system provides three substitutions that are defined by +The documentation system provides some substitutions that are defined by default. They are set in the build configuration file. .. describe:: |release| @@ -532,5 +300,5 @@ default. They are set in the build configuration file. .. describe:: |translation progress| Replaced by the translation progress of the document. - This substitution is intented for use by document translators + This substitution is intended for use by document translators as a marker for the translation progress of the document. diff --git a/doc/usage/theming.rst b/doc/usage/theming.rst index c33c7d4..be46cab 100644 --- a/doc/usage/theming.rst +++ b/doc/usage/theming.rst @@ -56,7 +56,7 @@ page's top and bottom), add the following :file:`conf.py`:: If the theme does not come with Sphinx, it can be in two static forms or as a Python package. For the static forms, either a directory (containing -:file:`theme.conf` and other needed files), or a zip file with the same +:file:`theme.toml` and other needed files), or a zip file with the same contents is supported. The directory or zipfile must be put where Sphinx can find it; for this there is the config value :confval:`html_theme_path`. This can be a list of directories, relative to the directory containing @@ -325,10 +325,10 @@ These themes are: are supported: - **relbar1** (true or false, default ``True``): If this is true, the - `relbar1` block is inserted in the epub output, otherwise it is omitted. + ``relbar1`` block is inserted in the epub output, otherwise it is omitted. - **footer** (true or false, default ``True``): If this is true, the - `footer` block is inserted in the epub output, otherwise it is omitted. + ``footer`` block is inserted in the epub output, otherwise it is omitted. **bizstyle** A simple bluish theme. The following options are supported |