ENH: extensions: port autoreload to current API

IPython/extensions/autoreload.py

@@ -219,39 +219,39 b' def superreload(module, reload=reload, old_objects={}):'
 
     return module
 
-reloader = ModuleReloader()
-
 #------------------------------------------------------------------------------
 # IPython connectivity
 #------------------------------------------------------------------------------
-from IPython.core import ipapi
-from IPython.core.error import TryNext
 
-ip = ipapi.get()
+from IPython.core.plugin import Plugin
+from IPython.core.hooks import TryNext
+
+class Autoreload(Plugin):
+    def __init__(self, shell=None, config=None):
+        super(Autoreload, self).__init__(shell=shell, config=config)
+
+        self.shell.define_magic('autoreload', self.magic_autoreload)
+        self.shell.define_magic('aimport', self.magic_aimport)
+        self.shell.set_hook('pre_run_code_hook', self.pre_run_code_hook)
 
-autoreload_enabled = False
+        self._enabled = False
+        self._reloader = ModuleReloader()
+        self._reloader.check_all = False
 
-def runcode_hook(self):
-    if not autoreload_enabled:
+    def pre_run_code_hook(self, ipself):
+        if not self._enabled:
         raise TryNext
     try:
-        reloader.check()
+            self._reloader.check()
     except:
         pass
 
-def enable_autoreload():
-    global autoreload_enabled
-    autoreload_enabled = True
-
-def disable_autoreload():
-    global autoreload_enabled
-    autoreload_enabled = False
-
-def autoreload_f(self, parameter_s=''):
+    def magic_autoreload(self, ipself, parameter_s=''):
     r""" %autoreload => Reload modules automatically
 
     %autoreload
-    Reload all modules (except those excluded by %aimport) automatically now.
+        Reload all modules (except those excluded by %aimport) automatically
+        now.
 
     %autoreload 0
     Disable automatic reloading.
@@ -291,17 +291,17 b" def autoreload_f(self, parameter_s=''):"
 
     """
     if parameter_s == '':
-        reloader.check(True)
+            self._reloader.check(True)
     elif parameter_s == '0':
-        disable_autoreload()
+            self._enabled = False
     elif parameter_s == '1':
-        reloader.check_all = False
-        enable_autoreload()
+            self._reloader.check_all = False
+            self._enabled = True
     elif parameter_s == '2':
-        reloader.check_all = True
-        enable_autoreload()
+            self._reloader.check_all = True
+            self._enabled = True
 
-def aimport_f(self, parameter_s=''):
+    def magic_aimport(self, ipself, parameter_s=''):
     """%aimport => Import modules for automatic reloading.
 
     %aimport
@@ -317,34 +317,42 b" def aimport_f(self, parameter_s=''):"
 
     modname = parameter_s
     if not modname:
-        to_reload = reloader.modules.keys()
+            to_reload = self._reloader.modules.keys()
         to_reload.sort()
-        to_skip = reloader.skip_modules.keys()
+            to_skip = self._reloader.skip_modules.keys()
         to_skip.sort()
-        if reloader.check_all:
+            if self._reloader.check_all:
             print "Modules to reload:\nall-expect-skipped"
         else:
             print "Modules to reload:\n%s" % ' '.join(to_reload)
         print "\nModules to skip:\n%s" % ' '.join(to_skip)
     elif modname.startswith('-'):
         modname = modname[1:]
-        try: del reloader.modules[modname]
-        except KeyError: pass
-        reloader.skip_modules[modname] = True
+            try:
+                del self._reloader.modules[modname]
+            except KeyError:
+                pass
+            self._reloader.skip_modules[modname] = True
     else:
-        try: del reloader.skip_modules[modname]
-        except KeyError: pass
-        reloader.modules[modname] = True
+            try:
+                del self._reloader.skip_modules[modname]
+            except KeyError:
+                pass
+            self._reloader.modules[modname] = True
 
         # Inject module to user namespace; handle also submodules properly
         __import__(modname)
         basename = modname.split('.')[0]
         mod = sys.modules[basename]
-        ip.push({basename: mod})
+            ipself.push({basename: mod})
+
 
-def init():
-    ip.define_magic('autoreload', autoreload_f)
-    ip.define_magic('aimport', aimport_f)
-    ip.set_hook('pre_runcode_hook', runcode_hook)
+_loaded = False
 
-init()
+def load_ipython_extension(ip):
+    """Load the extension in IPython."""
+    global _loaded
+    if not _loaded:
+        plugin = Autoreload(shell=ip, config=ip.config)
+        ip.plugin_manager.register_plugin('autoreload', plugin)
+        _loaded = True