Mechanism for testing terminal interact loop in-process.

While this is complex, I much prefer it to starting a separate process
and piping commands in.

IPython/terminal/tests/test_interactivshell.py

@@ -1,203 +1,295 b''
 # -*- coding: utf-8 -*-
 """Tests for the key interactiveshell module.
 
 Authors
 -------
 * Julian Taylor
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 # stdlib
 import sys
+import types
 import unittest
 
+from IPython.core.inputtransformer import InputTransformer
 from IPython.testing.decorators import skipif
 from IPython.utils import py3compat
 from IPython.testing import tools as tt
 
+# Decorator for interaction loop tests -----------------------------------------
+
+class mock_input_helper(object):
+    """Machinery for tests of the main interact loop.
+
+    Used by the mock_input decorator.
+    """
+    def __init__(self, testgen):
+        self.testgen = testgen
+        self.exception = None
+        self.ip = get_ipython()
+
+    def __enter__(self):
+        self.orig_raw_input = self.ip.raw_input
+        self.ip.raw_input = self.fake_input
+        return self
+
+    def __exit__(self, etype, value, tb):
+        self.ip.raw_input = self.orig_raw_input
+
+    def fake_input(self, prompt):
+        try:
+            return next(self.testgen)
+        except StopIteration:
+            self.ip.exit_now = True
+            return u''
+        except:
+            self.exception = sys.exc_info()
+            self.ip.exit_now = True
+            return u''
+
+def mock_input(testfunc):
+    """Decorator for tests of the main interact loop.
+
+    Write the test as a generator, yield-ing the input strings, which IPython
+    will see as if they were typed in at the prompt.
+    """
+    def test_method(self):
+        testgen = testfunc(self)
+        with mock_input_helper(testgen) as mih:
+            mih.ip.interact(display_banner=False)
+
+        if mih.exception is not None:
+            # Re-raise captured exception
+            etype, value, tb = mih.exception
+            import traceback
+            traceback.print_tb(tb, file=sys.stdout)
+            del tb  # Avoid reference loop
+            raise value
+
+    return test_method
+
+# Test classes -----------------------------------------------------------------
+
 class InteractiveShellTestCase(unittest.TestCase):
     def rl_hist_entries(self, rl, n):
         """Get last n readline history entries as a list"""
         return [rl.get_history_item(rl.get_current_history_length() - x)
                 for x in range(n - 1, -1, -1)]
 
     def test_runs_without_rl(self):
         """Test that function does not throw without readline"""
         ip = get_ipython()
         ip.has_readline = False
         ip.readline = None
         ip._replace_rlhist_multiline(u'source', 0)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     def test_runs_without_remove_history_item(self):
         """Test that function does not throw on windows without
            remove_history_item"""
         ip = get_ipython()
         if hasattr(ip.readline, 'remove_history_item'):
             del ip.readline.remove_history_item
         ip._replace_rlhist_multiline(u'source', 0)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_disabled(self):
         """Test that multiline replace does nothing if disabled"""
         ip = get_ipython()
         ip.multiline_history = False
 
         ghist = [u'line1', u'line2']
         for h in ghist:
            ip.readline.add_history(h)
         hlen_b4_cell = ip.readline.get_current_history_length()
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€\nsource2',
                                                     hlen_b4_cell)
 
         self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 2)
         self.assertEqual(hist, ghist)
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_adds(self):
         """Test that multiline replace function adds history"""
         ip = get_ipython()
 
         hlen_b4_cell = ip.readline.get_current_history_length()
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€', hlen_b4_cell)
 
         self.assertEqual(hlen_b4_cell,
                           ip.readline.get_current_history_length())
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_keeps_history(self):
         """Test that multiline replace does not delete history"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ghist = [u'line1', u'line2']
         for h in ghist:
            ip.readline.add_history(h)
 
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
 		# nothing added to rl history, should do nothing
         hlen_b4_cell = ip._replace_rlhist_multiline(u'sourc€\nsource2',
                                                     hlen_b4_cell)
 
         self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 2)
         self.assertEqual(hist, ghist)
 
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_replaces_twice(self):
         """Test that multiline entries are replaced twice"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ip.readline.add_history(u'line0')
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
         ip.readline.add_history('l€ne1')
         ip.readline.add_history('line2')
         #replace cell with single line
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne1\nline2',
                                                     hlen_b4_cell)
         ip.readline.add_history('l€ne3')
         ip.readline.add_history('line4')
         #replace cell with single line
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne3\nline4',
                                                     hlen_b4_cell)
 
         self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 3)
         expected = [u'line0', u'l€ne1\nline2', u'l€ne3\nline4']
         # perform encoding, in case of casting due to ASCII locale
         enc = sys.stdin.encoding or "utf-8"
         expected = [ py3compat.unicode_to_str(e, enc) for e in expected ]
         self.assertEqual(hist, expected)
 
 
     @skipif(not get_ipython().has_readline, 'no readline')
     @skipif(not hasattr(get_ipython().readline, 'remove_history_item'),
             'no remove_history_item')
     def test_replace_multiline_hist_replaces_empty_line(self):
         """Test that multiline history skips empty line cells"""
         ip = get_ipython()
         ip.multiline_history = True
 
         ip.readline.add_history(u'line0')
         #start cell
         hlen_b4_cell = ip.readline.get_current_history_length()
         ip.readline.add_history('l€ne1')
         ip.readline.add_history('line2')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne1\nline2',
                                                     hlen_b4_cell)
         ip.readline.add_history('')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'', hlen_b4_cell)
         ip.readline.add_history('l€ne3')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'l€ne3', hlen_b4_cell)
         ip.readline.add_history('  ')
         hlen_b4_cell = ip._replace_rlhist_multiline('  ', hlen_b4_cell)
         ip.readline.add_history('\t')
         ip.readline.add_history('\t ')
         hlen_b4_cell = ip._replace_rlhist_multiline('\t', hlen_b4_cell)
         ip.readline.add_history('line4')
         hlen_b4_cell = ip._replace_rlhist_multiline(u'line4', hlen_b4_cell)
 
         self.assertEqual(ip.readline.get_current_history_length(),
                           hlen_b4_cell)
         hist = self.rl_hist_entries(ip.readline, 4)
         # expect no empty cells in history
         expected = [u'line0', u'l€ne1\nline2', u'l€ne3', u'line4']
         # perform encoding, in case of casting due to ASCII locale
         enc = sys.stdin.encoding or "utf-8"
         expected = [ py3compat.unicode_to_str(e, enc) for e in expected ]
         self.assertEqual(hist, expected)
     
+    @mock_input
+    def test_inputtransformer_syntaxerror(self):
+        ip = get_ipython()
+        transformer = SyntaxErrorTransformer()
+        ip.input_splitter.python_line_transforms.append(transformer)
+        ip.input_transformer_manager.python_line_transforms.append(transformer)
+
+        try:
+            #raise Exception
+            with tt.AssertPrints('4', suppress=False):
+                yield u'print(2*2)'
+
+            with tt.AssertPrints('SyntaxError: input contains', suppress=False):
+                yield u'print(2345) # syntaxerror'
+
+            with tt.AssertPrints('16', suppress=False):
+                yield u'print(4*4)'
+
+        finally:
+            ip.input_splitter.python_line_transforms.remove(transformer)
+            ip.input_transformer_manager.python_line_transforms.remove(transformer)
+
+
+class SyntaxErrorTransformer(InputTransformer):
+    def push(self, line):
+        pos = line.find('syntaxerror')
+        if pos >= 0:
+            e = SyntaxError('input contains "syntaxerror"')
+            e.text = line
+            e.offset = pos + 1
+            raise e
+        return line
+
+    def reset(self):
+        pass
+
 class TerminalMagicsTestCase(unittest.TestCase):
     def test_paste_magics_message(self):
         """Test that an IndentationError while using paste magics doesn't
         trigger a message about paste magics and also the opposite."""
 
         ip = get_ipython()
         s = ('for a in range(5):\n'
              'print(a)')
 
         tm = ip.magics_manager.registry['TerminalMagics']
         with tt.AssertPrints("If you want to paste code into IPython, try the "
                 "%paste and %cpaste magic functions."):
             ip.run_cell(s)
 
         with tt.AssertNotPrints("If you want to paste code into IPython, try the "
                 "%paste and %cpaste magic functions."):
             tm.store_or_execute(s, name=None)
 
     def test_paste_magics_blankline(self):
         """Test that code with a blank line doesn't get split (gh-3246)."""
         ip = get_ipython()
         s = ('def pasted_func(a):\n'
              '    b = a+1\n'
              '\n'
              '    return b')
         
         tm = ip.magics_manager.registry['TerminalMagics']
         tm.store_or_execute(s, name=None)
         
         self.assertEqual(ip.user_ns['pasted_func'](54), 55)

IPython/testing/tools.py

@@ -1,451 +1,444 b''
 """Generic testing tools.
 
 Authors
 -------
 - Fernando Perez <[e-mail]>
 """
 
 from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import re
 import sys
 import tempfile
 
 from contextlib import contextmanager
 from io import StringIO
 from subprocess import Popen, PIPE
 
 try:
     # These tools are used by parts of the runtime, so we make the nose
     # dependency optional at this point.  Nose is a hard dependency to run the
     # test suite, but NOT to use ipython itself.
     import nose.tools as nt
     has_nose = True
 except ImportError:
     has_nose = False
 
 from IPython.config.loader import Config
 from IPython.utils.process import get_output_error_code
 from IPython.utils.text import list_strings
 from IPython.utils.io import temp_pyfile, Tee
 from IPython.utils import py3compat
 from IPython.utils.encoding import DEFAULT_ENCODING
 
 from . import decorators as dec
 from . import skipdoctest
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 # The docstring for full_path doctests differently on win32 (different path
 # separator) so just skip the doctest there.  The example remains informative.
 doctest_deco = skipdoctest.skip_doctest if sys.platform == 'win32' else dec.null_deco
 
 @doctest_deco
 def full_path(startPath,files):
     """Make full paths for all the listed files, based on startPath.
 
     Only the base part of startPath is kept, since this routine is typically
     used with a script's __file__ variable as startPath.  The base of startPath
     is then prepended to all the listed files, forming the output list.
 
     Parameters
     ----------
       startPath : string
         Initial path to use as the base for the results.  This path is split
       using os.path.split() and only its first component is kept.
 
       files : string or list
         One or more files.
 
     Examples
     --------
 
     >>> full_path('/foo/bar.py',['a.txt','b.txt'])
     ['/foo/a.txt', '/foo/b.txt']
 
     >>> full_path('/foo',['a.txt','b.txt'])
     ['/a.txt', '/b.txt']
 
     If a single file is given, the output is still a list:
     >>> full_path('/foo','a.txt')
     ['/a.txt']
     """
 
     files = list_strings(files)
     base = os.path.split(startPath)[0]
     return [ os.path.join(base,f) for f in files ]
 
 
 def parse_test_output(txt):
     """Parse the output of a test run and return errors, failures.
 
     Parameters
     ----------
     txt : str
       Text output of a test run, assumed to contain a line of one of the
       following forms::
       
         'FAILED (errors=1)'
         'FAILED (failures=1)'
         'FAILED (errors=1, failures=1)'
 
     Returns
     -------
     nerr, nfail: number of errors and failures.
     """
 
     err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
     if err_m:
         nerr = int(err_m.group(1))
         nfail = 0
         return  nerr, nfail
 
     fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
     if fail_m:
         nerr = 0
         nfail = int(fail_m.group(1))
         return  nerr, nfail
 
     both_m = re.search(r'^FAILED \(errors=(\d+), failures=(\d+)\)', txt,
                        re.MULTILINE)
     if both_m:
         nerr = int(both_m.group(1))
         nfail = int(both_m.group(2))
         return  nerr, nfail
 
     # If the input didn't match any of these forms, assume no error/failures
     return 0, 0
 
 
 # So nose doesn't think this is a test
 parse_test_output.__test__ = False
 
 
 def default_argv():
     """Return a valid default argv for creating testing instances of ipython"""
 
     return ['--quick', # so no config file is loaded
             # Other defaults to minimize side effects on stdout
             '--colors=NoColor', '--no-term-title','--no-banner',
             '--autocall=0']
 
 
 def default_config():
     """Return a config object with good defaults for testing."""
     config = Config()
     config.TerminalInteractiveShell.colors = 'NoColor'
     config.TerminalTerminalInteractiveShell.term_title = False,
     config.TerminalInteractiveShell.autocall = 0
     config.HistoryManager.hist_file = tempfile.mktemp(u'test_hist.sqlite')
     config.HistoryManager.db_cache_size = 10000
     return config
 
 
 def get_ipython_cmd(as_string=False):
     """
     Return appropriate IPython command line name. By default, this will return
     a list that can be used with subprocess.Popen, for example, but passing
     `as_string=True` allows for returning the IPython command as a string.
 
     Parameters
     ----------
     as_string: bool
         Flag to allow to return the command as a string.
     """
     ipython_cmd = [sys.executable, "-m", "IPython"]
 
     if as_string:
         ipython_cmd = " ".join(ipython_cmd)
 
     return ipython_cmd
 
-def ipexec(fname, options=None, pipe=False):
+def ipexec(fname, options=None):
     """Utility to call 'ipython filename'.
 
     Starts IPython with a minimal and safe configuration to make startup as fast
     as possible.
 
     Note that this starts IPython in a subprocess!
 
     Parameters
     ----------
     fname : str
       Name of file to be executed (should have .py or .ipy extension).
 
     options : optional, list
       Extra command-line flags to be passed to IPython.
 
-    pipe : optional, boolean
-      Pipe fname into IPython as stdin instead of calling it as external file
-
     Returns
     -------
     (stdout, stderr) of ipython subprocess.
     """
     if options is None: options = []
 
     # For these subprocess calls, eliminate all prompt printing so we only see
     # output from script execution
     prompt_opts = [ '--PromptManager.in_template=""',
                     '--PromptManager.in2_template=""',
                     '--PromptManager.out_template=""'
     ]
     cmdargs = default_argv() + prompt_opts + options
 
     test_dir = os.path.dirname(__file__)
 
     ipython_cmd = get_ipython_cmd()
     # Absolute path for filename
     full_fname = os.path.join(test_dir, fname)
-    if pipe:
-        full_cmd = ipython_cmd + cmdargs
-        p = Popen(full_cmd, stdin=open(full_fname), stdout=PIPE, stderr=PIPE)
-    else:
-        full_cmd = ipython_cmd + cmdargs + [full_fname]
-        p = Popen(full_cmd, stdout=PIPE, stderr=PIPE)
+    full_cmd = ipython_cmd + cmdargs + [full_fname]
+    p = Popen(full_cmd, stdout=PIPE, stderr=PIPE)
     out, err = p.communicate()
     out, err = py3compat.bytes_to_str(out), py3compat.bytes_to_str(err)
     # `import readline` causes 'ESC[?1034h' to be output sometimes,
     # so strip that out before doing comparisons
     if out:
         out = re.sub(r'\x1b\[[^h]+h', '', out)
     return out, err
 
 
 def ipexec_validate(fname, expected_out, expected_err='',
                     options=None):
     """Utility to call 'ipython filename' and validate output/error.
 
     This function raises an AssertionError if the validation fails.
 
     Note that this starts IPython in a subprocess!
 
     Parameters
     ----------
     fname : str
       Name of the file to be executed (should have .py or .ipy extension).
 
     expected_out : str
       Expected stdout of the process.
 
     expected_err : optional, str
       Expected stderr of the process.
 
     options : optional, list
       Extra command-line flags to be passed to IPython.
 
     Returns
     -------
     None
     """
 
     import nose.tools as nt
 
     out, err = ipexec(fname, options)
     #print 'OUT', out  # dbg
     #print 'ERR', err  # dbg
     # If there are any errors, we must check those befor stdout, as they may be
     # more informative than simply having an empty stdout.
     if err:
         if expected_err:
             nt.assert_equal("\n".join(err.strip().splitlines()), "\n".join(expected_err.strip().splitlines()))
         else:
             raise ValueError('Running file %r produced error: %r' %
                              (fname, err))
     # If no errors or output on stderr was expected, match stdout
     nt.assert_equal("\n".join(out.strip().splitlines()), "\n".join(expected_out.strip().splitlines()))
 
 
 class TempFileMixin(object):
     """Utility class to create temporary Python/IPython files.
 
     Meant as a mixin class for test cases."""
 
     def mktmp(self, src, ext='.py'):
         """Make a valid python temp file."""
         fname, f = temp_pyfile(src, ext)
         self.tmpfile = f
         self.fname = fname
 
     def tearDown(self):
         if hasattr(self, 'tmpfile'):
             # If the tmpfile wasn't made because of skipped tests, like in
             # win32, there's nothing to cleanup.
             self.tmpfile.close()
             try:
                 os.unlink(self.fname)
             except:
                 # On Windows, even though we close the file, we still can't
                 # delete it.  I have no clue why
                 pass
 
 pair_fail_msg = ("Testing {0}\n\n"
                 "In:\n"
                 "  {1!r}\n"
                 "Expected:\n"
                 "  {2!r}\n"
                 "Got:\n"
                 "  {3!r}\n")
 def check_pairs(func, pairs):
     """Utility function for the common case of checking a function with a
     sequence of input/output pairs.
 
     Parameters
     ----------
     func : callable
       The function to be tested. Should accept a single argument.
     pairs : iterable
       A list of (input, expected_output) tuples.
 
     Returns
     -------
     None. Raises an AssertionError if any output does not match the expected
     value.
     """
     name = getattr(func, "func_name", getattr(func, "__name__", "<unknown>"))
     for inp, expected in pairs:
         out = func(inp)
         assert out == expected, pair_fail_msg.format(name, inp, expected, out)
 
 
 if py3compat.PY3:
     MyStringIO = StringIO
 else:
     # In Python 2, stdout/stderr can have either bytes or unicode written to them,
     # so we need a class that can handle both.
     class MyStringIO(StringIO):
         def write(self, s):
             s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
             super(MyStringIO, self).write(s)
 
 notprinted_msg = """Did not find {0!r} in printed output (on {1}):
 -------
 {2!s}
 -------
 """
 
 class AssertPrints(object):
     """Context manager for testing that code prints certain text.
     
     Examples
     --------
     >>> with AssertPrints("abc", suppress=False):
     ...     print("abcd")
     ...     print("def")
     ... 
     abcd
     def
     """
     def __init__(self, s, channel='stdout', suppress=True):
         self.s = s
         if isinstance(self.s, py3compat.string_types):
             self.s = [self.s]
         self.channel = channel
         self.suppress = suppress
     
     def __enter__(self):
         self.orig_stream = getattr(sys, self.channel)
         self.buffer = MyStringIO()
         self.tee = Tee(self.buffer, channel=self.channel)
         setattr(sys, self.channel, self.buffer if self.suppress else self.tee)
     
     def __exit__(self, etype, value, traceback):
         if value is not None:
             # If an error was raised, don't check anything else
             return False
         self.tee.flush()
         setattr(sys, self.channel, self.orig_stream)
         printed = self.buffer.getvalue()
         for s in self.s:
             assert s in printed, notprinted_msg.format(s, self.channel, printed)
         return False
 
 printed_msg = """Found {0!r} in printed output (on {1}):
 -------
 {2!s}
 -------
 """
 
 class AssertNotPrints(AssertPrints):
     """Context manager for checking that certain output *isn't* produced.
     
     Counterpart of AssertPrints"""
     def __exit__(self, etype, value, traceback):
         if value is not None:
             # If an error was raised, don't check anything else
             return False
         self.tee.flush()
         setattr(sys, self.channel, self.orig_stream)
         printed = self.buffer.getvalue()
         for s in self.s:
             assert s not in printed, printed_msg.format(s, self.channel, printed)
         return False
 
 @contextmanager
 def mute_warn():
     from IPython.utils import warn
     save_warn = warn.warn
     warn.warn = lambda *a, **kw: None
     try:
         yield
     finally:
         warn.warn = save_warn
 
 @contextmanager
 def make_tempfile(name):
     """ Create an empty, named, temporary file for the duration of the context.
     """
     f = open(name, 'w')
     f.close()
     try:
         yield
     finally:
         os.unlink(name)
 
 
 @contextmanager
 def monkeypatch(obj, name, attr):
     """
     Context manager to replace attribute named `name` in `obj` with `attr`.
     """
     orig = getattr(obj, name)
     setattr(obj, name, attr)
     yield
     setattr(obj, name, orig)
 
 
 def help_output_test(subcommand=''):
     """test that `ipython [subcommand] -h` works"""
     cmd = ' '.join(get_ipython_cmd() + [subcommand, '-h'])
     out, err, rc = get_output_error_code(cmd)
     nt.assert_equal(rc, 0, err)
     nt.assert_not_in("Traceback", err)
     nt.assert_in("Options", out)
     nt.assert_in("--help-all", out)
     return out, err
 
 
 def help_all_output_test(subcommand=''):
     """test that `ipython [subcommand] --help-all` works"""
     cmd = ' '.join(get_ipython_cmd() + [subcommand, '--help-all'])
     out, err, rc = get_output_error_code(cmd)
     nt.assert_equal(rc, 0, err)
     nt.assert_not_in("Traceback", err)
     nt.assert_in("Options", out)
     nt.assert_in("Class parameters", out)
     return out, err
 

IPython/utils/io.py

@@ -1,229 +1,234 b''
 # encoding: utf-8
 """
 IO related utilities.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import os
 import sys
 import tempfile
 from .capture import CapturedIO, capture_output
 from .py3compat import string_types, input
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class IOStream:
 
     def __init__(self,stream, fallback=None):
         if not hasattr(stream,'write') or not hasattr(stream,'flush'):
             if fallback is not None:
                 stream = fallback
             else:
                 raise ValueError("fallback required, but not specified")
         self.stream = stream
         self._swrite = stream.write
 
         # clone all methods not overridden:
         def clone(meth):
             return not hasattr(self, meth) and not meth.startswith('_')
         for meth in filter(clone, dir(stream)):
             setattr(self, meth, getattr(stream, meth))
 
+    def __repr__(self):
+        cls = self.__class__
+        tpl = '{mod}.{cls}({args})'
+        return tpl.format(mod=cls.__module__, cls=cls.__name__, args=self.stream)
+
     def write(self,data):
         try:
             self._swrite(data)
         except:
             try:
                 # print handles some unicode issues which may trip a plain
                 # write() call.  Emulate write() by using an empty end
                 # argument.
                 print(data, end='', file=self.stream)
             except:
                 # if we get here, something is seriously broken.
                 print('ERROR - failed to write data to stream:', self.stream,
                       file=sys.stderr)
 
     def writelines(self, lines):
         if isinstance(lines, string_types):
             lines = [lines]
         for line in lines:
             self.write(line)
 
     # This class used to have a writeln method, but regular files and streams
     # in Python don't have this method. We need to keep this completely
     # compatible so we removed it.
 
     @property
     def closed(self):
         return self.stream.closed
 
     def close(self):
         pass
 
 # setup stdin/stdout/stderr to sys.stdin/sys.stdout/sys.stderr
 devnull = open(os.devnull, 'a')
 stdin = IOStream(sys.stdin, fallback=devnull)
 stdout = IOStream(sys.stdout, fallback=devnull)
 stderr = IOStream(sys.stderr, fallback=devnull)
 
 class IOTerm:
     """ Term holds the file or file-like objects for handling I/O operations.
 
     These are normally just sys.stdin, sys.stdout and sys.stderr but for
     Windows they can can replaced to allow editing the strings before they are
     displayed."""
 
     # In the future, having IPython channel all its I/O operations through
     # this class will make it easier to embed it into other environments which
     # are not a normal terminal (such as a GUI-based shell)
     def __init__(self, stdin=None, stdout=None, stderr=None):
         mymodule = sys.modules[__name__]
         self.stdin  = IOStream(stdin, mymodule.stdin)
         self.stdout = IOStream(stdout, mymodule.stdout)
         self.stderr = IOStream(stderr, mymodule.stderr)
 
 
 class Tee(object):
     """A class to duplicate an output stream to stdout/err.
 
     This works in a manner very similar to the Unix 'tee' command.
 
     When the object is closed or deleted, it closes the original file given to
     it for duplication.
     """
     # Inspired by:
     # http://mail.python.org/pipermail/python-list/2007-May/442737.html
 
     def __init__(self, file_or_name, mode="w", channel='stdout'):
         """Construct a new Tee object.
 
         Parameters
         ----------
         file_or_name : filename or open filehandle (writable)
           File that will be duplicated
 
         mode : optional, valid mode for open().
           If a filename was give, open with this mode.
 
         channel : str, one of ['stdout', 'stderr']
         """
         if channel not in ['stdout', 'stderr']:
             raise ValueError('Invalid channel spec %s' % channel)
 
         if hasattr(file_or_name, 'write') and hasattr(file_or_name, 'seek'):
             self.file = file_or_name
         else:
             self.file = open(file_or_name, mode)
         self.channel = channel
         self.ostream = getattr(sys, channel)
         setattr(sys, channel, self)
         self._closed = False
 
     def close(self):
         """Close the file and restore the channel."""
         self.flush()
         setattr(sys, self.channel, self.ostream)
         self.file.close()
         self._closed = True
 
     def write(self, data):
         """Write data to both channels."""
         self.file.write(data)
         self.ostream.write(data)
         self.ostream.flush()
 
     def flush(self):
         """Flush both channels."""
         self.file.flush()
         self.ostream.flush()
 
     def __del__(self):
         if not self._closed:
             self.close()
 
 
 def ask_yes_no(prompt,default=None):
     """Asks a question and returns a boolean (y/n) answer.
 
     If default is given (one of 'y','n'), it is used if the user input is
     empty. Otherwise the question is repeated until an answer is given.
 
     An EOF is treated as the default answer.  If there is no default, an
     exception is raised to prevent infinite loops.
 
     Valid answers are: y/yes/n/no (match is not case sensitive)."""
 
     answers = {'y':True,'n':False,'yes':True,'no':False}
     ans = None
     while ans not in answers.keys():
         try:
             ans = input(prompt+' ').lower()
             if not ans:  # response was an empty string
                 ans = default
         except KeyboardInterrupt:
             pass
         except EOFError:
             if default in answers.keys():
                 ans = default
                 print()
             else:
                 raise
 
     return answers[ans]
 
 
 def temp_pyfile(src, ext='.py'):
     """Make a temporary python file, return filename and filehandle.
 
     Parameters
     ----------
     src : string or list of strings (no need for ending newlines if list)
       Source code to be written to the file.
 
     ext : optional, string
       Extension for the generated file.
 
     Returns
     -------
     (filename, open filehandle)
       It is the caller's responsibility to close the open file and unlink it.
     """
     fname = tempfile.mkstemp(ext)[1]
     f = open(fname,'w')
     f.write(src)
     f.flush()
     return fname, f
 
 
 def raw_print(*args, **kw):
     """Raw print to sys.__stdout__, otherwise identical interface to print()."""
 
     print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
           file=sys.__stdout__)
     sys.__stdout__.flush()
 
 
 def raw_print_err(*args, **kw):
     """Raw print to sys.__stderr__, otherwise identical interface to print()."""
 
     print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
           file=sys.__stderr__)
     sys.__stderr__.flush()
 
 
 # Short aliases for quick debugging, do NOT use these in production code.
 rprint = raw_print
 rprinte = raw_print_err