Fix magic directive and role.

We were directly modifying state instead of using blessed API (also some
api will change so be future proof with sphinx master).

This should restore some ability of the :magic: and :cellmagic:
directive to both support link to magics name when the text in the
directive contains (or not) leading % and %%, it will also automatically
prepend the right number of % for magics and cell magics.

A couple of other related fixes.

docs/source/config/extensions/autoreload.rst

@@ -1,7 +1,9 b''
 .. _extensions_autoreload:
 
 ==========
 autoreload
 ==========
 
+.. magic:: autoreload
+
 .. automodule:: IPython.extensions.autoreload

docs/source/interactive/autoawait.rst

@@ -1,316 +1,317 b''
 .. _autoawait:
 
 Asynchronous in REPL: Autoawait
 ===============================
 
 .. note::
 
    This feature is experimental and behavior can change between python and
    IPython version without prior deprecation.
 
 Starting with IPython 7.0, and when user Python 3.6 and above, IPython offer the
 ability to run asynchronous code from the REPL. Constructs which are
 :exc:`SyntaxError` s in the Python REPL can be used seamlessly in IPython.
 
 The examples given here are for terminal IPython, running async code in a
 notebook interface or any other frontend using the Jupyter protocol needs
 IPykernel version 5.0 or above. The details of how async code runs in IPykernel
 will differ between IPython, IPykernel and their versions.
 
 When a supported library is used, IPython will automatically allow Futures and
 Coroutines in the REPL to be ``await`` ed. This will happen if an :ref:`await
 <await>` (or any other async constructs like async-with, async-for) is use at
 top level scope, or if any structure valid only in `async def
 <https://docs.python.org/3/reference/compound_stmts.html#async-def>`_ function
 context are present. For example, the following being a syntax error in the
 Python REPL::
 
     Python 3.6.0 
     [GCC 4.2.1]
     Type "help", "copyright", "credits" or "license" for more information.
     >>> import aiohttp
     >>> result = aiohttp.get('https://api.github.com')
     >>> response = await result
       File "<stdin>", line 1
         response = await result
                               ^
     SyntaxError: invalid syntax
 
 Should behave as expected in the IPython REPL::
 
     Python 3.6.0
     Type 'copyright', 'credits' or 'license' for more information
     IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
 
     In [1]: import aiohttp
        ...: result = aiohttp.get('https://api.github.com')
 
     In [2]: response = await result
     <pause for a few 100s ms>
 
     In [3]: await response.json()
     Out[3]:
     {'authorizations_url': 'https://api.github.com/authorizations',
      'code_search_url': 'https://api.github.com/search/code?q={query}...',
     ...
     }
 
 
 You can use the ``c.InteractiveShell.autoawait`` configuration option and set it
 to :any:`False` to deactivate automatic wrapping of asynchronous code. You can
-also use the :magic:`%autoawait` magic to toggle the behavior at runtime::
+also use the :magic:`autoawait` magic to toggle the behavior at runtime::
 
     In [1]: %autoawait False
 
     In [2]: %autoawait
     IPython autoawait is `Off`, and set to use `asyncio`
 
 
 
 By default IPython will assume integration with Python's provided
 :mod:`asyncio`, but integration with other libraries is provided. In particular
 we provide experimental integration with the ``curio`` and ``trio`` library.
 
 You can switch current integration by using the
 ``c.InteractiveShell.loop_runner`` option or the ``autoawait <name
 integration>`` magic.
 
 For example::
 
     In [1]: %autoawait trio
 
     In [2]: import trio
 
     In [3]: async def child(i):
        ...:     print("   child %s goes to sleep"%i)
        ...:     await trio.sleep(2)
        ...:     print("   child %s wakes up"%i)
 
     In [4]: print('parent start')
        ...: async with trio.open_nursery() as n:
        ...:     for i in range(5):
        ...:         n.spawn(child, i)
        ...: print('parent end')
     parent start
        child 2 goes to sleep
        child 0 goes to sleep
        child 3 goes to sleep
        child 1 goes to sleep
        child 4 goes to sleep
        <about 2 seconds pause>
        child 2 wakes up
        child 1 wakes up
        child 0 wakes up
        child 3 wakes up
        child 4 wakes up
     parent end
 
 
 In the above example, ``async with`` at top level scope is a syntax error in
 Python.
 
 Using this mode can have unexpected consequences if used in interaction with
 other features of IPython and various registered extensions. In particular if
 you are a direct or indirect user of the AST transformers, these may not apply
 to your code.
 
 When using command line IPython, the default loop (or runner) does not process
 in the background, so top level asynchronous code must finish for the REPL to
 allow you to enter more code. As with usual Python semantic, the awaitables are
 started only when awaited for the first time. That is to say, in first example,
 no network request is done between ``In[1]`` and ``In[2]``.
 
 
 Effects on IPython.embed()
 --------------------------
 
 IPython core being asynchronous, the use of ``IPython.embed()`` will now require
 a loop to run. By default IPython will use a fake coroutine runner which should
 allow ``IPython.embed()`` to be nested. Though this will prevent usage of the
-``autoawait`` feature when using IPython embed. 
+:magic:`autoawait` feature when using IPython embed. 
 
 You can set explicitly a coroutine runner for ``embed()`` if you desire to run
 asynchronous code, the exact behavior is though undefined.
 
 Effects on Magics
 -----------------
 
 A couple of magics (``%%timeit``, ``%timeit``, ``%%time``, ``%%prun``) have not
 yet been updated to work with asynchronous code and will raise syntax errors
 when trying to use top-level ``await``. We welcome any contribution to help fix
 those, and extra cases we haven't caught yet. We hope for better support in Cor
 Python for top-level Async code.
 
 Internals
 ---------
 
 As running asynchronous code is not supported in interactive REPL (as of Python
 3.7) we have to rely to a number of complex workaround and heuristic to allow
 this to happen. It is interesting to understand how this works in order to
 comprehend potential bugs, or provide a custom runner.
 
 Among the many approaches that are at our disposition, we find only one that
 suited out need. Under the hood we use the code object from a async-def function
 and run it in global namespace after modifying it to not create a new
 ``locals()`` scope::
 
     async def inner_async():
         locals().update(**global_namespace)
         #
         # here is user code
         #
         return last_user_statement
     codeobj = modify(inner_async.__code__)
     coroutine = eval(codeobj, user_ns)
     display(loop_runner(coroutine))
 
 
 
 The first thing you'll notice is that unlike classical ``exec``, there is only
 one namespace. Second, user code runs in a function scope, and not a module
 scope.
 
 On top of the above there are significant modification to the AST of
 ``function``, and ``loop_runner`` can be arbitrary complex. So there is a
 significant overhead to this kind of code.
 
 By default the generated coroutine function will be consumed by Asyncio's
 ``loop_runner = asyncio.get_evenloop().run_until_complete()`` method if
 ``async`` mode is deemed necessary, otherwise the coroutine will just be
 exhausted in a simple runner. It is though possible to change the default
 runner.
 
 A loop runner is a *synchronous*  function responsible from running a coroutine
 object.
 
 The runner is responsible from ensuring that ``coroutine`` run to completion,
 and should return the result of executing the coroutine. Let's write a
 runner for ``trio`` that print a message when used as an exercise, ``trio`` is
 special as it usually prefer to run a function object and make a coroutine by
 itself, we can get around this limitation by wrapping it in an async-def without
 parameters and passing this value to ``trio``::
 
 
     In [1]: import trio
        ...: from types import CoroutineType
        ...:
        ...: def trio_runner(coro:CoroutineType):
        ...:     print('running asynchronous code')
        ...:     async def corowrap(coro):
        ...:         return await coro
        ...:     return trio.run(corowrap, coro)
 
 We can set it up by passing it to ``%autoawait``::
 
     In [2]: %autoawait trio_runner
 
     In [3]: async def async_hello(name):
        ...:     await trio.sleep(1)
        ...:     print(f'Hello {name} world !')
        ...:     await trio.sleep(1)
 
     In [4]: await async_hello('async')
     running asynchronous code
     Hello async world !
 
 
 Asynchronous programming in python (and in particular in the REPL) is still a
 relatively young subject. We expect some code to not behave as you expect, so
 feel free to contribute improvements to this codebase and give us feedback.
 
 We invite you to thoroughly test this feature and report any unexpected behavior
 as well as propose any improvement.
 
 Using Autoawait in a notebook (IPykernel)
 -----------------------------------------
 
 Update ipykernel to version 5.0 or greater::
 
    pip install ipykernel ipython --upgrade
    # or
    conda install ipykernel ipython --upgrade
 
-This should automatically enable ``autoawait`` integration. Unlike terminal
-IPython, all code runs on ``asyncio`` eventloop, so creating a loop by hand will
-not work, including with magics like ``%run`` or other frameworks that create
-the eventloop themselves. In cases like these you can try to use projects like
-`nest_asyncio <https://github.com/erdewit/nest_asyncio>`_ and follow `this discussion
+This should automatically enable :magic:`autoawait` integration. Unlike
+terminal IPython, all code runs on ``asyncio`` eventloop, so creating a loop by
+hand will not work, including with magics like :magic:`%run` or other
+frameworks that create the eventloop themselves. In cases like these you can
+try to use projects like `nest_asyncio
+<https://github.com/erdewit/nest_asyncio>`_ and follow `this discussion
 <https://github.com/jupyter/notebook/issues/3397#issuecomment-419386811>`_
 
 Difference between terminal IPython and IPykernel
 -------------------------------------------------
 
 The exact asynchronous code running behavior varies between Terminal IPython and
 IPykernel. The root cause of this behavior is due to IPykernel having a
-*persistent* ``asyncio`` loop running, while Terminal IPython starts and stops a
+*persistent* `asyncio` loop running, while Terminal IPython starts and stops a
 loop for each code block. This can lead to surprising behavior in some case if
 you are used to manipulate asyncio loop yourself, see for example
 :ghissue:`11303` for a longer discussion but here are some of the astonishing
 cases.
 
 This behavior is an implementation detail, and should not be relied upon. It can
 change without warnings in future versions of IPython.
 
 In terminal IPython a loop is started for each code blocks only if there is top
 level async code::
 
    $ ipython
    In [1]: import asyncio
       ...: asyncio.get_event_loop()
    Out[1]: <_UnixSelectorEventLoop running=False closed=False debug=False>
 
    In [2]:
 
    In [2]: import asyncio
       ...: await asyncio.sleep(0)
       ...: asyncio.get_event_loop()
    Out[2]: <_UnixSelectorEventLoop running=True closed=False debug=False>
 
 See that ``running`` is ``True`` only in the case were we ``await sleep()``
 
 In a Notebook, with ipykernel the asyncio eventloop is always running::
 
    $ jupyter notebook
    In [1]: import asyncio
       ...: loop1 = asyncio.get_event_loop()
       ...: loop1
    Out[1]: <_UnixSelectorEventLoop running=True closed=False debug=False>
 
    In [2]: loop2 = asyncio.get_event_loop()
       ...: loop2
    Out[2]: <_UnixSelectorEventLoop running=True closed=False debug=False>
 
    In [3]: loop1 is loop2
    Out[3]: True
 
 In Terminal IPython background tasks are only processed while the foreground
 task is running, if and only if the foreground task is async::
 
    $ ipython
    In [1]: import asyncio
       ...:
       ...: async def repeat(msg, n):
       ...:     for i in range(n):
       ...:         print(f"{msg} {i}")
       ...:         await asyncio.sleep(1)
       ...:     return f"{msg} done"
       ...:
       ...: asyncio.ensure_future(repeat("background", 10))
    Out[1]: <Task pending coro=<repeat() running at <ipython-input-1-02d0ef250fe7>:3>>
 
    In [2]: await asyncio.sleep(3)
    background 0
    background 1
    background 2
    background 3
 
    In [3]: import time
    ...: time.sleep(5)
 
    In [4]: await asyncio.sleep(3)
    background 4
    background 5
    background 6g
 
 In a Notebook, QtConsole, or any other frontend using IPykernel, background
 tasks should behave as expected.

docs/source/whatsnew/version7.rst

@@ -1,218 +1,225 b''
 ============
  7.x Series
 ============
 
 .. _whatsnew700:
 
 IPython 7.0.0
 =============
 
 .. warning::
 
    IPython 7.0 is currently in Beta. We welcome feedback on API/changes and
    addition/updates to this changelog.
 
 Released .... ...., 2018
 
 IPython 7 include major features improvement as you can read in the following
 changelog. This is also the second major version of IPython to support only
 Python 3 – starting at Python 3.4. Python 2 is still community supported
 on the bugfix only 5.x branch, but we remind you that Python 2 "end of life"
 is on Jan 1st 2020.
 
 We were able to backport bug fixes to the 5.x branch thanks to our backport bot which
 backported more than `70 Pull-Requests
 <https://github.com/ipython/ipython/pulls?page=3&q=is%3Apr+sort%3Aupdated-desc+author%3Aapp%2Fmeeseeksdev++5.x&utf8=%E2%9C%93>`_, but there are still many PRs that required manually work, and this is an area of the project were you can easily contribute by looking for `PRs still needed backport <https://github.com/ipython/ipython/issues?q=label%3A%22Still+Needs+Manual+Backport%22+is%3Aclosed+sort%3Aupdated-desc>`_
 
 IPython 6.x branch will likely not see any further release unless critical
 bugs are found.
 
 Make sure you have pip > 9.0 before upgrading. You should be able to update by simply running
 
 .. code::
 
     pip install ipython --upgrade
 
 Or if you have conda installed: 
 
 .. code::
    
    conda install ipython
 
 
 
 Prompt Toolkit 2.0
 ------------------
 
 IPython 7.0+ now uses ``prompt_toolkit 2.0``, if you still need to use earlier
 ``prompt_toolkit`` version you may need to pin IPython to ``<7.0``.
 
 Autowait: Asynchronous REPL
 ---------------------------
 
 Staring with IPython 7.0 and on Python 3.6+, IPython can automatically await
 code at top level, you should not need to access an event loop or runner
 yourself. To know more read the :ref:`autoawait` section of our docs, see
 :ghpull:`11265` or try the following code::
 
     Python 3.6.0
     Type 'copyright', 'credits' or 'license' for more information
     IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
 
     In [1]: import aiohttp
        ...: result = aiohttp.get('https://api.github.com')
 
     In [2]: response = await result
     <pause for a few 100s ms>
 
     In [3]: await response.json()
     Out[3]:
     {'authorizations_url': 'https://api.github.com/authorizations',
      'code_search_url': 'https://api.github.com/search/code?q={query}{&page,per_page,sort,order}',
     ...
     }
 
 .. note::
 
    Async integration is experimental code, behavior may change or be removed
    between Python and IPython versions without warnings.
 
 Integration is by default with `asyncio`, but other libraries can be configured,
 like ``curio`` or ``trio``, to improve concurrency in the REPL::
 
     In [1]: %autoawait trio
 
     In [2]: import trio
 
     In [3]: async def child(i):
        ...:     print("   child %s goes to sleep"%i)
        ...:     await trio.sleep(2)
        ...:     print("   child %s wakes up"%i)
 
     In [4]: print('parent start')
        ...: async with trio.open_nursery() as n:
        ...:     for i in range(3):
        ...:         n.spawn(child, i)
        ...: print('parent end')
     parent start
        child 2 goes to sleep
        child 0 goes to sleep
        child 1 goes to sleep
        <about 2 seconds pause>
        child 2 wakes up
        child 1 wakes up
        child 0 wakes up
     parent end
 
 See :ref:`autoawait` for more information.
 
 
 Asynchronous code in a Notebook interface or any other frontend using the
 Jupyter Protocol will need further updates of the IPykernel package.
 
 Non-Asynchronous code
 ~~~~~~~~~~~~~~~~~~~~~
 
 As the internal API of IPython are now asynchronous, IPython need to run under
-an even loop. In order to allow many workflow, (like using the ``%run`` magic,
-or copy_pasting code that explicitly starts/stop event loop), when top-level code
-is detected as not being asynchronous, IPython code is advanced via a
-pseudo-synchronous runner, and will not may not advance pending tasks.
+an even loop. In order to allow many workflow, (like using the :magic:`%run`
+magic, or copy_pasting code that explicitly starts/stop event loop), when
+top-level code is detected as not being asynchronous, IPython code is advanced
+via a pseudo-synchronous runner, and will not may not advance pending tasks.
 
 Change to Nested Embed
 ~~~~~~~~~~~~~~~~~~~~~~
 
 The introduction of the ability to run async code had some effect on the
 ``IPython.embed()`` API. By default embed will not allow you to run asynchronous
 code unless a event loop is specified.
 
 Effects on Magics
 ~~~~~~~~~~~~~~~~~
 
 Some magics will not work with Async, and will need updates. Contribution
 welcome.
 
 Expected Future changes
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 We expect more internal but public IPython function to become ``async``, and
 will likely end up having a persisting event loop while IPython is running.
 
 Thanks
 ~~~~~~
 
 This took more than a year in the making, and the code was rebased a number of
 time leading to commit authorship that may have been lost in the final
 Pull-Request. Huge thanks to many people for contribution, discussion, code,
 documentation, use-case: dalejung, danielballan, ellisonbg, fperez, gnestor,
 minrk, njsmith, pganssle, tacaswell, takluyver , vidartf ... And many others.
 
 
 Autoreload Improvement
 ----------------------
 
-The magic ``%autoreload 2`` now captures new methods added to classes. Earlier, only methods existing as of the initial import were being tracked and updated.  
+The magic :magic:`%autoreload 2 <autoreload>` now captures new methods added to
+classes. Earlier, only methods existing as of the initial import were being
+tracked and updated.  
 
-This new feature helps dual environment development - Jupyter+IDE - where the code gradually moves from notebook cells to package files, as it gets structured.
+This new feature helps dual environment development - Jupyter+IDE - where the
+code gradually moves from notebook cells to package files, as it gets
+structured.
 
-**Example**: An instance of the class `MyClass` will be able to access the method `cube()` after it is uncommented and the file `file1.py` saved on disk.
+**Example**: An instance of the class ``MyClass`` will be able to access the
+method ``cube()`` after it is uncommented and the file ``file1.py`` saved on
+disk.
 
 
 ..code::
 
    # notebook
 
    from mymodule import MyClass
    first = MyClass(5)
 
 .. code::
 
    # mymodule/file1.py
 
    class MyClass:
 
        def __init__(self, a=10):
            self.a = a
 
        def square(self):
            print('compute square')
            return self.a*self.a
 
        # def cube(self):
        #     print('compute cube')
        #     return self.a*self.a*self.a
 
 
 
 
 Misc
 ----
 
 The autoindent feature that was deprecated in 5.x was re-enabled and
 un-deprecated in :ghpull:`11257`
 
-Make ``%run -n -i ...`` work correctly. Earlier, if ``%run`` was passed both arguments, ``-n`` would be silently ignored. See :ghpull:`10308`
+Make :magic:`%run -n -i ... <run>` work correctly. Earlier, if :magic:`%run` was
+passed both arguments, ``-n`` would be silently ignored. See :ghpull:`10308`
 
 
-The ``%%script`` (as well as ``%%bash``, ``ruby``... ) cell magics now raise
-by default if the return code of the given code is non-zero (thus halting
-execution of further cells in a notebook). The behavior can be disable by
-passing the ``--no-raise-error`` flag.
+The :cellmagic:`%%script`` (as well as :cellmagic:`%%bash``,
+:cellmagic:`%%ruby``... ) cell magics now raise by default if the return code of
+the given code is non-zero (thus halting execution of further cells in a
+notebook). The behavior can be disable by passing the ``--no-raise-error`` flag.
 
 
 Deprecations
 ------------
 
 A couple of unused function and methods have been deprecated and will be removed
 in future versions:
 
   - ``IPython.utils.io.raw_print_err``
   - ``IPython.utils.io.raw_print``
 
   
 Backwards incompatible changes
 ------------------------------
 
 * The API for transforming input before it is parsed as Python code has been
   completely redesigned, and any custom input transformations will need to be
   rewritten. See :doc:`/config/inputtransforms` for details of the new API.

docs/sphinxext/github.py

@@ -1,157 +1,160 b''
 """Define text roles for GitHub
 
 * ghissue - Issue
 * ghpull - Pull Request
 * ghuser - User
 
 Adapted from bitbucket example here:
 https://bitbucket.org/birkenfeld/sphinx-contrib/src/tip/bitbucket/sphinxcontrib/bitbucket.py
 
 Authors
 -------
 
 * Doug Hellmann
 * Min RK
 """
 #
 # Original Copyright (c) 2010 Doug Hellmann.  All rights reserved.
 #
 
 from docutils import nodes, utils
 from docutils.parsers.rst.roles import set_classes
+from sphinx.util.logging import getLogger
+
+info = getLogger(__name__).info
 
 def make_link_node(rawtext, app, type, slug, options):
     """Create a link to a github resource.
 
     :param rawtext: Text being replaced with link node.
     :param app: Sphinx application context
     :param type: Link type (issues, changeset, etc.)
     :param slug: ID of the thing to link to
     :param options: Options dictionary passed to role func.
     """
 
     try:
         base = app.config.github_project_url
         if not base:
             raise AttributeError
         if not base.endswith('/'):
             base += '/'
     except AttributeError as err:
         raise ValueError('github_project_url configuration value is not set (%s)' % str(err))
 
     ref = base + type + '/' + slug + '/'
     set_classes(options)
     prefix = "#"
     if type == 'pull':
         prefix = "PR " + prefix
     node = nodes.reference(rawtext, prefix + utils.unescape(slug), refuri=ref,
                            **options)
     return node
 
 def ghissue_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub issue.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
 
     try:
         issue_num = int(text)
         if issue_num <= 0:
             raise ValueError
     except ValueError:
         msg = inliner.reporter.error(
             'GitHub issue number must be a number greater than or equal to 1; '
             '"%s" is invalid.' % text, line=lineno)
         prb = inliner.problematic(rawtext, rawtext, msg)
         return [prb], [msg]
     app = inliner.document.settings.env.app
-    #app.info('issue %r' % text)
+    #info('issue %r' % text)
     if 'pull' in name.lower():
         category = 'pull'
     elif 'issue' in name.lower():
         category = 'issues'
     else:
         msg = inliner.reporter.error(
             'GitHub roles include "ghpull" and "ghissue", '
             '"%s" is invalid.' % name, line=lineno)
         prb = inliner.problematic(rawtext, rawtext, msg)
         return [prb], [msg]
     node = make_link_node(rawtext, app, category, str(issue_num), options)
     return [node], []
 
 def ghuser_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub user.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
     app = inliner.document.settings.env.app
-    #app.info('user link %r' % text)
+    #info('user link %r' % text)
     ref = 'https://www.github.com/' + text
     node = nodes.reference(rawtext, text, refuri=ref, **options)
     return [node], []
 
 def ghcommit_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
     """Link to a GitHub commit.
 
     Returns 2 part tuple containing list of nodes to insert into the
     document and a list of system messages.  Both are allowed to be
     empty.
 
     :param name: The role name used in the document.
     :param rawtext: The entire markup snippet, with role.
     :param text: The text marked with the role.
     :param lineno: The line number where rawtext appears in the input.
     :param inliner: The inliner instance that called us.
     :param options: Directive options for customization.
     :param content: The directive content for customization.
     """
     app = inliner.document.settings.env.app
-    #app.info('user link %r' % text)
+    #info('user link %r' % text)
     try:
         base = app.config.github_project_url
         if not base:
             raise AttributeError
         if not base.endswith('/'):
             base += '/'
     except AttributeError as err:
         raise ValueError('github_project_url configuration value is not set (%s)' % str(err))
 
     ref = base + text
     node = nodes.reference(rawtext, text[:6], refuri=ref, **options)
     return [node], []
 
 
 def setup(app):
     """Install the plugin.
 
     :param app: Sphinx application context.
     """
-    app.info('Initializing GitHub plugin')
+    info('Initializing GitHub plugin')
     app.add_role('ghissue', ghissue_role)
     app.add_role('ghpull', ghissue_role)
     app.add_role('ghuser', ghuser_role)
     app.add_role('ghcommit', ghcommit_role)
     app.add_config_value('github_project_url', None, 'env')
 
     metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
     return metadata

docs/sphinxext/magics.py

@@ -1,45 +1,46 b''
 import re
 from sphinx import addnodes
 from sphinx.domains.std import StandardDomain
 from sphinx.roles import XRefRole
 
 name_re = re.compile(r"[\w_]+")
 
 def parse_magic(env, sig, signode):
     m = name_re.match(sig)
     if not m:
         raise Exception("Invalid magic command: %s" % sig)
     name = "%" + sig
     signode += addnodes.desc_name(name, name)
     return m.group(0)
 
 class LineMagicRole(XRefRole):
     """Cross reference role displayed with a % prefix"""
     prefix = "%"
 
     def process_link(self, env, refnode, has_explicit_title, title, target):
         if not has_explicit_title:
             title = self.prefix + title.lstrip("%")
         target = target.lstrip("%")
         return title, target
 
 def parse_cell_magic(env, sig, signode):
     m = name_re.match(sig)
     if not m:
         raise ValueError("Invalid cell magic: %s" % sig)
     name = "%%" + sig
     signode += addnodes.desc_name(name, name)
     return m.group(0)
 
 class CellMagicRole(LineMagicRole):
     """Cross reference role displayed with a %% prefix"""
     prefix = "%%"
 
 def setup(app):
     app.add_object_type('magic', 'magic', 'pair: %s; magic command', parse_magic)
-    StandardDomain.roles['magic'] = LineMagicRole()
+    app.add_role_to_domain('std', 'magic', LineMagicRole(), override=True)
+
     app.add_object_type('cellmagic', 'cellmagic', 'pair: %s; cell magic', parse_cell_magic)
-    StandardDomain.roles['cellmagic'] = CellMagicRole()
+    app.add_role_to_domain('std', 'cellmagic', CellMagicRole(), override=True)
 
     metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
     return metadata