Remove the "autoedit_syntax" feature.

IPython used to (a long time ago, in a galaxy far far away) have the
ability to automatically open an editor in case a wild syntax error
appears. The configuration option to enable that was not working for a
few years, and apparently we by mistake re enabled it, to discover that
the feature is actually broken.

So this plainly remove the code to support this feature, at the
exception of the `fix_error_editor` hook. Indeed it is public API, so
for now  as it seem to be used only for this feature, we'll just raise a
UserWarning (there is roughly 0 chance of this being tested as it's used
mostly interactively, so DeprecationWarnings would be unseen).

We'll remove later if no complaints

Closes  #9603

IPython/core/hooks.py

@@ -1,214 +1,226 b''
 """Hooks for IPython.
 
 In Python, it is possible to overwrite any method of any object if you really
 want to.  But IPython exposes a few 'hooks', methods which are *designed* to
 be overwritten by users for customization purposes.  This module defines the
 default versions of all such hooks, which get used by IPython if not
 overridden by the user.
 
 Hooks are simple functions, but they should be declared with ``self`` as their
 first argument, because when activated they are registered into IPython as
 instance methods. The self argument will be the IPython running instance
 itself, so hooks have full access to the entire IPython object.
 
 If you wish to define a new hook and activate it, you can make an :doc:`extension
 </config/extensions/index>` or a :ref:`startup script <startup_files>`. For
 example, you could use a startup file like this::
 
     import os
 
     def calljed(self,filename, linenum):
         "My editor hook calls the jed editor directly."
         print "Calling my own editor, jed ..."
         if os.system('jed +%d %s' % (linenum,filename)) != 0:
             raise TryNext()
 
     def load_ipython_extension(ip):
         ip.set_hook('editor', calljed)
 
 """
 
 #*****************************************************************************
 #       Copyright (C) 2005 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 import os
 import subprocess
+import warnings
 import sys
 
 from IPython.core.error import TryNext
 
 # List here all the default hooks.  For now it's just the editor functions
 # but over time we'll move here all the public API for user-accessible things.
 
 __all__ = ['editor', 'fix_error_editor', 'synchronize_with_editor',
            'shutdown_hook', 'late_startup_hook',
            'show_in_pager','pre_prompt_hook',
            'pre_run_code_hook', 'clipboard_get']
 
 deprecated = {'pre_run_code_hook': "a callback for the 'pre_execute' or 'pre_run_cell' event",
               'late_startup_hook': "a callback for the 'shell_initialized' event",
               'shutdown_hook': "the atexit module",
              }
 
 def editor(self, filename, linenum=None, wait=True):
     """Open the default editor at the given filename and linenumber.
 
     This is IPython's default editor hook, you can use it as an example to
     write your own modified one.  To set your own editor function as the
     new editor hook, call ip.set_hook('editor',yourfunc)."""
 
     # IPython configures a default editor at startup by reading $EDITOR from
     # the environment, and falling back on vi (unix) or notepad (win32).
     editor = self.editor
 
     # marker for at which line to open the file (for existing objects)
     if linenum is None or editor=='notepad':
         linemark = ''
     else:
         linemark = '+%d' % int(linenum)
 
     # Enclose in quotes if necessary and legal
     if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
         editor = '"%s"' % editor
 
     # Call the actual editor
     proc = subprocess.Popen('%s %s %s' % (editor, linemark, filename),
                             shell=True)
     if wait and proc.wait() != 0:
         raise TryNext()
 
 import tempfile
 def fix_error_editor(self,filename,linenum,column,msg):
-    """Open the editor at the given filename, linenumber, column and
+    """DEPRECATED
+
+    Open the editor at the given filename, linenumber, column and
     show an error message. This is used for correcting syntax errors.
     The current implementation only has special support for the VIM editor,
     and falls back on the 'editor' hook if VIM is not used.
 
-    Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
+    Call ip.set_hook('fix_error_editor',yourfunc) to use your own function,
     """
+
+    warnings.warn("""
+`fix_error_editor` is pending deprecation as of IPython 5.0 and will be removed
+in future versions. It appears to be used only for automatically fixing syntax
+error that has been broken for a few years and has thus been removed. If you
+happend to use this function and still need it please make your voice heard on
+the mailing list [e-mail] , or on the GitHub Issue tracker:
+https://github.com/ipython/ipython/issues/9649 """, UserWarning)
+
     def vim_quickfix_file():
         t = tempfile.NamedTemporaryFile()
         t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
         t.flush()
         return t
     if os.path.basename(self.editor) != 'vim':
         self.hooks.editor(filename,linenum)
         return
     t = vim_quickfix_file()
     try:
         if os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name):
             raise TryNext()
     finally:
         t.close()
 
 
 def synchronize_with_editor(self, filename, linenum, column):
         pass
 
 
 class CommandChainDispatcher:
     """ Dispatch calls to a chain of commands until some func can handle it
 
     Usage: instantiate, execute "add" to add commands (with optional
     priority), execute normally via f() calling mechanism.
 
     """
     def __init__(self,commands=None):
         if commands is None:
             self.chain = []
         else:
             self.chain = commands
 
 
     def __call__(self,*args, **kw):
         """ Command chain is called just like normal func.
 
         This will call all funcs in chain with the same args as were given to
         this function, and return the result of first func that didn't raise
         TryNext"""
         last_exc = TryNext()
         for prio,cmd in self.chain:
             #print "prio",prio,"cmd",cmd #dbg
             try:
                 return cmd(*args, **kw)
             except TryNext as exc:
                 last_exc = exc
         # if no function will accept it, raise TryNext up to the caller
         raise last_exc
 
     def __str__(self):
         return str(self.chain)
 
     def add(self, func, priority=0):
         """ Add a func to the cmd chain with given priority """
         self.chain.append((priority, func))
         self.chain.sort(key=lambda x: x[0])
 
     def __iter__(self):
         """ Return all objects in chain.
 
         Handy if the objects are not callable.
         """
         return iter(self.chain)
 
 
 def shutdown_hook(self):
     """ default shutdown hook
 
     Typically, shotdown hooks should raise TryNext so all shutdown ops are done
     """
 
     #print "default shutdown hook ok" # dbg
     return
 
 
 def late_startup_hook(self):
     """ Executed after ipython has been constructed and configured
 
     """
     #print "default startup hook ok" # dbg
 
 
 def show_in_pager(self, data, start, screen_lines):
     """ Run a string through pager """
     # raising TryNext here will use the default paging functionality
     raise TryNext
 
 
 def pre_prompt_hook(self):
     """ Run before displaying the next prompt
 
     Use this e.g. to display output from asynchronous operations (in order
     to not mess up text entry)
     """
 
     return None
 
 
 def pre_run_code_hook(self):
     """ Executed before running the (prefiltered) code in IPython """
     return None
 
 
 def clipboard_get(self):
     """ Get text from the clipboard.
     """
     from IPython.lib.clipboard import (
         osx_clipboard_get, tkinter_clipboard_get,
         win32_clipboard_get
     )
     if sys.platform == 'win32':
         chain = [win32_clipboard_get, tkinter_clipboard_get]
     elif sys.platform == 'darwin':
         chain = [osx_clipboard_get, tkinter_clipboard_get]
     else:
         chain = [tkinter_clipboard_get]
     dispatcher = CommandChainDispatcher()
     for func in chain:
         dispatcher.add(func)
     text = dispatcher()
     return text

IPython/terminal/interactiveshell.py

@@ -1,598 +1,532 b''
 """IPython terminal interface using prompt_toolkit"""
 from __future__ import print_function
 
 import os
 import sys
 import signal
 from warnings import warn
 
 from IPython.core.error import TryNext
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
 from IPython.utils.py3compat import PY3, cast_unicode_py2, input
 from IPython.utils.terminal import toggle_set_term_title, set_term_title
 from IPython.utils.process import abbrev_cwd
 from traitlets import Bool, Unicode, Dict, Integer, observe, Instance, Type, default, Enum
 
 from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER, EditingMode
 from prompt_toolkit.filters import (HasFocus, HasSelection, Condition,
     ViInsertMode, EmacsInsertMode, IsDone, HasCompletions)
 from prompt_toolkit.filters.cli import ViMode
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.shortcuts import create_prompt_application, create_eventloop, create_prompt_layout
 from prompt_toolkit.interface import CommandLineInterface
 from prompt_toolkit.key_binding.manager import KeyBindingManager
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor
 from prompt_toolkit.styles import PygmentsStyle, DynamicStyle
 from prompt_toolkit.key_binding.bindings.completion import display_completions_like_readline
 
 from pygments.styles import get_style_by_name, get_all_styles
 from pygments.token import Token
 
 from .debugger import TerminalPdb, Pdb
 from .magics import TerminalMagics
 from .pt_inputhooks import get_inputhook_func
 from .prompts import Prompts, ClassicPrompts, RichPromptDisplayHook
 from .ptutils import IPythonPTCompleter, IPythonPTLexer
 
 DISPLAY_BANNER_DEPRECATED = object()
 
 
 def get_default_editor():
     try:
         ed = os.environ['EDITOR']
         if not PY3:
             ed = ed.decode()
         return ed
     except KeyError:
         pass
     except UnicodeError:
         warn("$EDITOR environment variable is not pure ASCII. Using platform "
              "default editor.")
 
     if os.name == 'posix':
         return 'vi'  # the only one guaranteed to be there!
     else:
         return 'notepad' # same in Windows!
 
 
 if sys.stdin and sys.stdout and sys.stderr:
     _is_tty = (sys.stdin.isatty()) and (sys.stdout.isatty()) and  (sys.stderr.isatty())
 else:
     _is_tty = False
 
 
 _use_simple_prompt = ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or (not _is_tty)
 
 class TerminalInteractiveShell(InteractiveShell):
     colors_force = True
 
     space_for_menu = Integer(6, help='Number of line at the bottom of the screen '
                                                   'to reserve for the completion menu'
                             ).tag(config=True)
 
     def _space_for_menu_changed(self, old, new):
         self._update_layout()
 
     pt_cli = None
     debugger_history = None
 
     simple_prompt = Bool(_use_simple_prompt,
         help="""Use `raw_input` for the REPL, without completion, multiline input, and prompt colors.
 
             Useful when controlling IPython as a subprocess, and piping STDIN/OUT/ERR. Known usage are:
             IPython own testing machinery, and emacs inferior-shell integration through elpy.
 
             This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT`
             environment variable is set, or the current terminal is not a tty.
 
             """
             ).tag(config=True)
 
     @property
     def debugger_cls(self):
         return Pdb if self.simple_prompt else TerminalPdb
 
-    autoedit_syntax = Bool(False,
-        help="auto editing of files with syntax errors.",
-    ).tag(config=True)
-
-
     confirm_exit = Bool(True,
         help="""
         Set to confirm when you try to exit IPython with an EOF (Control-D
         in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
         you can force a direct exit without any confirmation.""",
     ).tag(config=True)
 
     editing_mode = Unicode('emacs',
         help="Shortcut style to use at the prompt. 'vi' or 'emacs'.",
     ).tag(config=True)
 
     mouse_support = Bool(False,
         help="Enable mouse support in the prompt"
     ).tag(config=True)
 
     highlighting_style = Unicode('default',
             help="The name of a Pygments style to use for syntax highlighting: \n %s" % ', '.join(get_all_styles())
     ).tag(config=True)
 
     
     @observe('highlighting_style')
     def _highlighting_style_changed(self, change):
         self._style = self._make_style_from_name(self.highlighting_style)
 
     highlighting_style_overrides = Dict(
         help="Override highlighting format for specific tokens"
     ).tag(config=True)
 
     editor = Unicode(get_default_editor(),
         help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
     ).tag(config=True)
 
     prompts_class = Type(Prompts, help='Class used to generate Prompt token for prompt_toolkit').tag(config=True)
 
     prompts = Instance(Prompts)
 
     @default('prompts')
     def _prompts_default(self):
         return self.prompts_class(self)
 
     @observe('prompts')
     def _(self, change):
         self._update_layout()
 
     @default('displayhook_class')
     def _displayhook_class_default(self):
         return RichPromptDisplayHook
 
     term_title = Bool(True,
         help="Automatically set the terminal title"
     ).tag(config=True)
 
     # Leaving that for beta/rc tester, shoudl remove for 5.0.0 final. 
     display_completions_in_columns = Bool(None,
         help="DEPRECATED", allow_none=True
     ).tag(config=True)
 
     @observe('display_completions_in_columns')
     def _display_completions_in_columns_changed(self, new):
         raise DeprecationWarning("The `display_completions_in_columns` Boolean has been replaced by the enum `display_completions`"
                                  "with the following acceptable value: 'column', 'multicolumn','readlinelike'. ")
 
     display_completions = Enum(('column', 'multicolumn','readlinelike'), default_value='multicolumn').tag(config=True)
 
     highlight_matching_brackets = Bool(True,
         help="Highlight matching brackets .",
     ).tag(config=True)
 
     @observe('term_title')
     def init_term_title(self, change=None):
         # Enable or disable the terminal title.
         if self.term_title:
             toggle_set_term_title(True)
             set_term_title('IPython: ' + abbrev_cwd())
         else:
             toggle_set_term_title(False)
 
     def init_display_formatter(self):
         super(TerminalInteractiveShell, self).init_display_formatter()
         # terminal only supports plain text
         self.display_formatter.active_types = ['text/plain']
 
     def init_prompt_toolkit_cli(self):
         self._app = None
         if self.simple_prompt:
             # Fall back to plain non-interactive output for tests.
             # This is very limited, and only accepts a single line.
             def prompt():
                 return cast_unicode_py2(input('In [%d]: ' % self.execution_count))
             self.prompt_for_code = prompt
             return
 
         kbmanager = KeyBindingManager.for_prompt()
         insert_mode = ViInsertMode() | EmacsInsertMode()
         # Ctrl+J == Enter, seemingly
         @kbmanager.registry.add_binding(Keys.ControlJ,
                             filter=(HasFocus(DEFAULT_BUFFER)
                                     & ~HasSelection()
                                     & insert_mode
                                    ))
         def _(event):
             b = event.current_buffer
             d = b.document
 
             if b.complete_state:
                 cc = b.complete_state.current_completion
                 if cc:
                     b.apply_completion(cc)
                 else:
                     b.cancel_completion()
                 return
 
             if not (d.on_last_line or d.cursor_position_row >= d.line_count
                                            - d.empty_line_count_at_the_end()):
                 b.newline()
                 return
 
             status, indent = self.input_splitter.check_complete(d.text + '\n')
 
             if (status != 'incomplete') and b.accept_action.is_returnable:
                 b.accept_action.validate_and_handle(event.cli, b)
             else:
                 b.insert_text('\n' + (' ' * (indent or 0)))
 
         @kbmanager.registry.add_binding(Keys.ControlP, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER)))
         def _previous_history_or_previous_completion(event):
             """
             Control-P in vi edit mode on readline is history next, unlike default prompt toolkit.
 
             If completer is open this still select previous completion.
             """
             event.current_buffer.auto_up()
 
         @kbmanager.registry.add_binding(Keys.ControlN, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER)))
         def _next_history_or_next_completion(event):
             """
             Control-N in vi edit mode on readline is history previous, unlike default prompt toolkit.
 
             If completer is open this still select next completion.
             """
             event.current_buffer.auto_down()
 
         @kbmanager.registry.add_binding(Keys.ControlG, filter=(
             HasFocus(DEFAULT_BUFFER) & HasCompletions()
             ))
         def _dismiss_completion(event):
             b = event.current_buffer
             if b.complete_state:
                 b.cancel_completion()
 
         @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER))
         def _reset_buffer(event):
             b = event.current_buffer
             if b.complete_state:
                 b.cancel_completion()
             else:
                 b.reset()
 
         @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER))
         def _reset_search_buffer(event):
             if event.current_buffer.document.text:
                 event.current_buffer.reset()
             else:
                 event.cli.push_focus(DEFAULT_BUFFER)
 
         supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP'))
 
         @kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend)
         def _suspend_to_bg(event):
             event.cli.suspend_to_background()
 
         @Condition
         def cursor_in_leading_ws(cli):
             before = cli.application.buffer.document.current_line_before_cursor
             return (not before) or before.isspace()
 
         # Ctrl+I == Tab
         @kbmanager.registry.add_binding(Keys.ControlI,
                             filter=(HasFocus(DEFAULT_BUFFER)
                                     & ~HasSelection()
                                     & insert_mode
                                     & cursor_in_leading_ws
                                    ))
         def _indent_buffer(event):
             event.current_buffer.insert_text(' ' * 4)
 
 
         if self.display_completions == 'readlinelike':
             @kbmanager.registry.add_binding(Keys.ControlI,
                             filter=(HasFocus(DEFAULT_BUFFER)
                                     & ~HasSelection()
                                     & insert_mode
                                     & ~cursor_in_leading_ws
                                    ))
             def _disaply_compl(ev):
                 display_completions_like_readline(ev)
 
 
         if sys.platform == 'win32':
             from IPython.lib.clipboard import (ClipboardEmpty,
                            win32_clipboard_get, tkinter_clipboard_get)
             @kbmanager.registry.add_binding(Keys.ControlV,
                                 filter=(HasFocus(DEFAULT_BUFFER) & ~ViMode()))
             def _paste(event):
                 try:
                     text = win32_clipboard_get()
                 except TryNext:
                     try:
                         text = tkinter_clipboard_get()
                     except (TryNext, ClipboardEmpty):
                         return
                 except ClipboardEmpty:
                     return
                 event.current_buffer.insert_text(text.replace('\t', ' ' * 4))
 
         # Pre-populate history from IPython's history database
         history = InMemoryHistory()
         last_cell = u""
         for __, ___, cell in self.history_manager.get_tail(self.history_load_length,
                                                         include_latest=True):
             # Ignore blank lines and consecutive duplicates
             cell = cell.rstrip()
             if cell and (cell != last_cell):
                 history.append(cell)
 
         self._style = self._make_style_from_name(self.highlighting_style)
         style = DynamicStyle(lambda: self._style)
 
         editing_mode = getattr(EditingMode, self.editing_mode.upper())
 
         self._app = create_prompt_application(
                             editing_mode=editing_mode,
                             key_bindings_registry=kbmanager.registry,
                             history=history,
                             completer=IPythonPTCompleter(self.Completer),
                             enable_history_search=True,
                             style=style,
                             mouse_support=self.mouse_support,
                             **self._layout_options()
         )
         self._eventloop = create_eventloop(self.inputhook)
         self.pt_cli = CommandLineInterface(self._app, eventloop=self._eventloop)
 
     def _make_style_from_name(self, name):
         """
         Small wrapper that make an IPython compatible style from a style name
 
         We need that to add style for prompt ... etc. 
         """
         style_cls = get_style_by_name(name)
         style_overrides = {
             Token.Prompt: '#009900',
             Token.PromptNum: '#00ff00 bold',
             Token.OutPrompt: '#990000',
             Token.OutPromptNum: '#ff0000 bold',
         }
         if name == 'default':
             style_cls = get_style_by_name('default')
             # The default theme needs to be visible on both a dark background
             # and a light background, because we can't tell what the terminal
             # looks like. These tweaks to the default theme help with that.
             style_overrides.update({
                 Token.Number: '#007700',
                 Token.Operator: 'noinherit',
                 Token.String: '#BB6622',
                 Token.Name.Function: '#2080D0',
                 Token.Name.Class: 'bold #2080D0',
                 Token.Name.Namespace: 'bold #2080D0',
             })
         style_overrides.update(self.highlighting_style_overrides)
         style = PygmentsStyle.from_defaults(pygments_style_cls=style_cls,
                                             style_dict=style_overrides)
 
         return style
 
     def _layout_options(self):
         """
         Return the current layout option for the current Terminal InteractiveShell
         """
         return {
                 'lexer':IPythonPTLexer(),
                 'reserve_space_for_menu':self.space_for_menu,
                 'get_prompt_tokens':self.prompts.in_prompt_tokens,
                 'get_continuation_tokens':self.prompts.continuation_prompt_tokens,
                 'multiline':True,
                 'display_completions_in_columns': (self.display_completions == 'multicolumn'),
 
                 # Highlight matching brackets, but only when this setting is
                 # enabled, and only when the DEFAULT_BUFFER has the focus.
                 'extra_input_processors': [ConditionalProcessor(
                         processor=HighlightMatchingBracketProcessor(chars='[](){}'),
                         filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
                             Condition(lambda cli: self.highlight_matching_brackets))],
                 }
 
     def _update_layout(self):
         """
         Ask for a re computation of the application layout, if for example ,
         some configuration options have changed.
         """
         if getattr(self, '._app', None):
             self._app.layout = create_prompt_layout(**self._layout_options())
 
     def prompt_for_code(self):
         document = self.pt_cli.run(
             pre_run=self.pre_prompt, reset_current_buffer=True)
         return document.text
 
     def init_io(self):
         if sys.platform not in {'win32', 'cli'}:
             return
 
         import win_unicode_console
         import colorama
 
         win_unicode_console.enable()
         colorama.init()
 
         # For some reason we make these wrappers around stdout/stderr.
         # For now, we need to reset them so all output gets coloured.
         # https://github.com/ipython/ipython/issues/8669
         from IPython.utils import io
         io.stdout = io.IOStream(sys.stdout)
         io.stderr = io.IOStream(sys.stderr)
 
     def init_magics(self):
         super(TerminalInteractiveShell, self).init_magics()
         self.register_magics(TerminalMagics)
 
     def init_alias(self):
         # The parent class defines aliases that can be safely used with any
         # frontend.
         super(TerminalInteractiveShell, self).init_alias()
 
         # Now define aliases that only make sense on the terminal, because they
         # need direct access to the console in a way that we can't emulate in
         # GUI or web frontend
         if os.name == 'posix':
             for cmd in ['clear', 'more', 'less', 'man']:
                 self.alias_manager.soft_define_alias(cmd, cmd)
 
 
     def __init__(self, *args, **kwargs):
         super(TerminalInteractiveShell, self).__init__(*args, **kwargs)
         self.init_prompt_toolkit_cli()
         self.init_term_title()
         self.keep_running = True
 
         self.debugger_history = InMemoryHistory()
 
     def ask_exit(self):
         self.keep_running = False
 
     rl_next_input = None
 
     def pre_prompt(self):
         if self.rl_next_input:
             self.pt_cli.application.buffer.text = cast_unicode_py2(self.rl_next_input)
             self.rl_next_input = None
 
     def interact(self, display_banner=DISPLAY_BANNER_DEPRECATED):
 
         if display_banner is not DISPLAY_BANNER_DEPRECATED:
             warn('interact `display_banner` argument is deprecated since IPython 5.0. Call `show_banner()` if needed.', DeprecationWarning, stacklevel=2)
 
         while self.keep_running:
             print(self.separate_in, end='')
 
             try:
                 code = self.prompt_for_code()
             except EOFError:
                 if (not self.confirm_exit) \
                         or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'):
                     self.ask_exit()
 
             else:
                 if code:
                     self.run_cell(code, store_history=True)
-                    if self.autoedit_syntax and self.SyntaxTB.last_syntax_error:
-                        self.edit_syntax_error()
 
     def mainloop(self, display_banner=DISPLAY_BANNER_DEPRECATED):
         # An extra layer of protection in case someone mashing Ctrl-C breaks
         # out of our internal code.
         if display_banner is not DISPLAY_BANNER_DEPRECATED:
             warn('mainloop `display_banner` argument is deprecated since IPython 5.0. Call `show_banner()` if needed.', DeprecationWarning, stacklevel=2)
         while True:
             try:
                 self.interact()
                 break
             except KeyboardInterrupt:
                 print("\nKeyboardInterrupt escaped interact()\n")
         
         if hasattr(self, '_eventloop'):
             self._eventloop.close()
 
     _inputhook = None
     def inputhook(self, context):
         if self._inputhook is not None:
             self._inputhook(context)
 
     def enable_gui(self, gui=None):
         if gui:
             self._inputhook = get_inputhook_func(gui)
         else:
             self._inputhook = None
 
-    # Methods to support auto-editing of SyntaxErrors:
-
-    def edit_syntax_error(self):
-        """The bottom half of the syntax error handler called in the main loop.
-
-        Loop until syntax error is fixed or user cancels.
-        """
-
-        while self.SyntaxTB.last_syntax_error:
-            # copy and clear last_syntax_error
-            err = self.SyntaxTB.clear_err_state()
-            if not self._should_recompile(err):
-                return
-            try:
-                # may set last_syntax_error again if a SyntaxError is raised
-                self.safe_execfile(err.filename, self.user_ns)
-            except:
-                self.showtraceback()
-            else:
-                try:
-                    with open(err.filename) as f:
-                        # This should be inside a display_trap block and I
-                        # think it is.
-                        sys.displayhook(f.read())
-                except:
-                    self.showtraceback()
-
-    def _should_recompile(self, e):
-        """Utility routine for edit_syntax_error"""
-
-        if e.filename in ('<ipython console>', '<input>', '<string>',
-                          '<console>', '<BackgroundJob compilation>',
-                          None):
-            return False
-        try:
-            if (self.autoedit_syntax and
-                    not self.ask_yes_no(
-                        'Return to editor to correct syntax error? '
-                        '[Y/n] ', 'y')):
-                return False
-        except EOFError:
-            return False
-
-        def int0(x):
-            try:
-                return int(x)
-            except TypeError:
-                return 0
-
-        # always pass integer line and offset values to editor hook
-        try:
-            self.hooks.fix_error_editor(e.filename,
-                                        int0(e.lineno), int0(e.offset),
-                                        e.msg)
-        except TryNext:
-            warn('Could not open editor')
-            return False
-        return True
-
     # Run !system commands directly, not through pipes, so terminal programs
     # work correctly.
     system = InteractiveShell.system_raw
 
     def auto_rewrite_input(self, cmd):
         """Overridden from the parent class to use fancy rewriting prompt"""
         if not self.show_rewritten_input:
             return
 
         tokens = self.prompts.rewrite_prompt_tokens()
         if self.pt_cli:
             self.pt_cli.print_tokens(tokens)
             print(cmd)
         else:
             prompt = ''.join(s for t, s in tokens)
             print(prompt, cmd, sep='')
 
     _prompts_before = None
     def switch_doctest_mode(self, mode):
         """Switch prompts to classic for %doctest_mode"""
         if mode:
             self._prompts_before = self.prompts
             self.prompts = ClassicPrompts(self)
         elif self._prompts_before:
             self.prompts = self._prompts_before
             self._prompts_before = None
 
 
 InteractiveShellABC.register(TerminalInteractiveShell)
 
 if __name__ == '__main__':
     TerminalInteractiveShell.instance().interact()

docs/source/whatsnew/version5.rst

@@ -1,130 +1,156 b''
 ============
  5.x Series
 ============
 
 IPython 5.0
 ===========
 
 Released June, 2016
 
 IPython 5.0 now uses `prompt-toolkit` for the command line interface, thus
 allowing real multi-line editing and syntactic coloration as you type. 
 
 
 When using IPython as a subprocess, like for emacs inferior-shell, IPython can
 be started with --simple-prompt flag, which will bypass the prompt_toolkit
 input layer. In this mode completion, prompt color and many other features are
 disabled.
 
 Backwards incompatible changes
 ------------------------------
 
 
 The `install_ext magic` function which was deprecated since 4.0 have now been deleted. 
 You can still distribute and install extension as packages on PyPI.
 
 Update IPython event triggering to ensure callback registration and
 unregistration only affects the set of callbacks the *next* time that event is
 triggered. See :ghissue:`9447` and :ghpull:`9453`.
 
 This is a change to the existing semantics, wherein one callback registering a
 second callback when triggered for an event would previously be invoked for
 that same event.
 
 Integration with pydb has been removed since pydb development has been stopped
 since 2012, and pydb is not installable from PyPI
 
 
 
 Replacement of readline in TerminalInteractiveShell and PDB
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 IPython 5.0 now uses ``prompt_toolkit``. The
 ``IPython.terminal.interactiveshell.TerminalInteractiveShell`` now uses
 ``prompt_toolkit``. It is an almost complete rewrite, so many settings have
 thus changed or disappeared. The class keep the same name to avoid breaking
 user configuration for the options which names is unchanged.
 
 The usage of ``prompt_toolkit`` is accompanied by a complete removal of all
 code, using ``readline``. A particular effect of not using `readline` anymore
 is that `.inputrc` settings are note effective anymore. Options having similar
 effects have likely been replaced by a configuration option on IPython itself
 (e.g: vi input mode).
 
 The `PromptManager` class have been removed, and the prompt machinery simplified.
 See `TerminalInteractiveShell.prompts` configurable for how to setup your prompts.
 
 .. note::
 
     During developement and beta cycle, ``TerminalInteractiveShell`` was
     temporarly moved to ``IPtyhon.terminal.ptshell``.
 
 
 Most of the above remarks also affect `IPython.core.debugger.Pdb`, the `%debug`
 and `%pdb` magic which do not use readline anymore either.
 
 
-
-
 Provisional Changes
 -------------------
 
 Provisional changes are in experimental functionality that may, or may not make
 it to future version of IPython, and which API may change without warnings.
 Activating these feature and using these API is at your own risk, and may have
 security implication for your system, especially if used with the Jupyter notebook,
 
 When running via the Jupyter notebook interfaces, or other compatible client,
 you can enable rich documentation experimental functionality:
 
 When the ``docrepr`` package is installed setting the boolean flag
 ``InteractiveShell.sphinxify_docstring`` to ``True``, will process the various
 object through sphinx before displaying them (see the ``docrepr`` package
 documentation for more information.
 
 You need to also enable the IPython pager display rich HTML representation
 using the ``InteractiveShell.enable_html_pager`` boolean configuration option.
 As usual you can set these configuration options globally in your configuration
 files, alternatively you can turn them on dynamically using the following
 snippet:
 
 .. code-block:: python
 
     ip = get_ipython()
     ip.sphinxify_docstring = True
     ip.enable_html_pager = True
 
 You can test the effect of various combinations of the above configuration in
 the Jupyter notebook, with things example like :
 
 .. code-block:: python
 
     import numpy as np
     np.histogram?
 
 This is part of an effort to make Documentation in Python richer and provide in
 the long term if possible dynamic examples that can contain math, images,
 widgets... As stated above this is nightly experimental feature with a lot of
 (fun) problem to solve. We would be happy to get your feedback and expertise on
 it.
 
 
+Removed Feature
+---------------
+
+ - ``TerminalInteractiveShell.autoedit_syntax`` Has been broken for many years now
+apparently. It has been removed.
+
+
+Deprecated Features
+-------------------
+
+Some deprecated feature, don't forget to enable `DeprecationWarning` as error
+of you are using IPython in Continuous Integration setup or in your testing in general:
+
+.. code::
+    :python:
+
+    import warnings
+    warnings.filterwarnings('error', '.*', DeprecationWarning, module='yourmodule.*')
+
+
+ - `hooks.fix_error_editor` seem to be unused and is pending deprecation.
+ - `IPython/core/excolors.py:ExceptionColors` is  deprecated.
+ - `IPython.core.InteractiveShell:write()` is deprecated, use `sys.stdout` instead.
+ - `IPython.core.InteractiveShell:write_err()` is deprecated, use `sys.stderr` instead.
+ - The `formatter` keyword argument to `Inspector.info` in `IPython.core.oinspec` has now no effects.
+ - The `global_ns` keyword argument of IPython Embed was deprecated, and  will now have no effect. Use `module` keyword argument instead.
+
+
 Known Issues:
 -------------
 
  - ``<Esc>`` Key does not dismiss the completer and does not clear the current
    buffer. This is an on purpose modification due to current technical
    limitation. Cf :ghpull:`9572`. Escape the control character which is used
    for other shortcut, and there is no practical way to distinguish. Use Ctr-G
    or Ctrl-C as an alternative. 
 
  - Cannot use ``Shift-Enter`` and ``Ctrl-Enter`` to submit code in terminal. cf
    :ghissue:`9587` and :ghissue:`9401`. In terminal there is no practical way to
    distinguish these key sequences from a normal new line return. 
 
  - ``PageUp`` and ``pageDown`` do not move through completion menu.
 
  - Color styles might not adapt to terminal emulator themes. This will need new
    version of Pygments to be released, and can be mitigated with custom themes.