Merge pull request #12127 from meeseeksmachine/auto-backport-of-pr-12122-on-7.x

Backport PR  #12122 on branch 7.x (Pop the last if path ends with slash)

IPython/terminal/ptutils.py

@@ -1,166 +1,168 b''
 """prompt-toolkit utilities
 
 Everything in this module is a private API,
 not to be used outside IPython.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import unicodedata
 from wcwidth import wcwidth
 
 from IPython.core.completer import (
     provisionalcompleter, cursor_to_position,
     _deduplicate_completions)
 from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.lexers import Lexer
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.patch_stdout import patch_stdout
 
 import pygments.lexers as pygments_lexers
 import os
 
 _completion_sentinel = object()
 
 def _elide(string, *, min_elide=30):
     """
     If a string is long enough, and has at least 3 dots,
     replace the middle part with ellipses.
 
     If a string naming a file is long enough, and has at least 3 slashes,
     replace the middle part with ellipses.
 
     If three consecutive dots, or two consecutive dots are encountered these are
     replaced by the equivalents HORIZONTAL ELLIPSIS or TWO DOT LEADER unicode
     equivalents
     """
     string = string.replace('...','\N{HORIZONTAL ELLIPSIS}')
     string = string.replace('..','\N{TWO DOT LEADER}')
     if len(string) < min_elide:
         return string
 
     object_parts = string.split('.')
     file_parts = string.split(os.sep)
+    if file_parts[-1] == '':
+        file_parts.pop()
 
     if len(object_parts) > 3:
         return '{}.{}\N{HORIZONTAL ELLIPSIS}{}.{}'.format(object_parts[0], object_parts[1][0], object_parts[-2][-1], object_parts[-1])
 
     elif len(file_parts) > 3:
         return ('{}' + os.sep + '{}\N{HORIZONTAL ELLIPSIS}{}' + os.sep + '{}').format(file_parts[0], file_parts[1][0], file_parts[-2][-1], file_parts[-1])
 
     return string
 
 
 def _adjust_completion_text_based_on_context(text, body, offset):
     if text.endswith('=') and len(body) > offset and body[offset] == '=':
         return text[:-1]
     else:
         return text
 
 
 class IPythonPTCompleter(Completer):
     """Adaptor to provide IPython completions to prompt_toolkit"""
     def __init__(self, ipy_completer=None, shell=None):
         if shell is None and ipy_completer is None:
             raise TypeError("Please pass shell=an InteractiveShell instance.")
         self._ipy_completer = ipy_completer
         self.shell = shell
 
     @property
     def ipy_completer(self):
         if self._ipy_completer:
             return self._ipy_completer
         else:
             return self.shell.Completer
 
     def get_completions(self, document, complete_event):
         if not document.current_line.strip():
             return
         # Some bits of our completion system may print stuff (e.g. if a module
         # is imported). This context manager ensures that doesn't interfere with
         # the prompt.
 
         with patch_stdout(), provisionalcompleter():
             body = document.text
             cursor_row = document.cursor_position_row
             cursor_col = document.cursor_position_col
             cursor_position = document.cursor_position
             offset = cursor_to_position(body, cursor_row, cursor_col)
             yield from self._get_completions(body, offset, cursor_position, self.ipy_completer)
 
     @staticmethod
     def _get_completions(body, offset, cursor_position, ipyc):
         """
         Private equivalent of get_completions() use only for unit_testing.
         """
         debug = getattr(ipyc, 'debug', False)
         completions = _deduplicate_completions(
             body, ipyc.completions(body, offset))
         for c in completions:
             if not c.text:
                 # Guard against completion machinery giving us an empty string.
                 continue
             text = unicodedata.normalize('NFC', c.text)
             # When the first character of the completion has a zero length,
             # then it's probably a decomposed unicode character. E.g. caused by
             # the "\dot" completion. Try to compose again with the previous
             # character.
             if wcwidth(text[0]) == 0:
                 if cursor_position + c.start > 0:
                     char_before = body[c.start - 1]
                     fixed_text = unicodedata.normalize(
                         'NFC', char_before + text)
 
                     # Yield the modified completion instead, if this worked.
                     if wcwidth(text[0:1]) == 1:
                         yield Completion(fixed_text, start_position=c.start - offset - 1)
                         continue
 
             # TODO: Use Jedi to determine meta_text
             # (Jedi currently has a bug that results in incorrect information.)
             # meta_text = ''
             # yield Completion(m, start_position=start_pos,
             #                  display_meta=meta_text)
             display_text = c.text
 
             adjusted_text = _adjust_completion_text_based_on_context(c.text, body, offset)
             if c.type == 'function':
                 yield Completion(adjusted_text, start_position=c.start - offset, display=_elide(display_text+'()'), display_meta=c.type+c.signature)
             else:
                 yield Completion(adjusted_text, start_position=c.start - offset, display=_elide(display_text), display_meta=c.type)
 
 class IPythonPTLexer(Lexer):
     """
     Wrapper around PythonLexer and BashLexer.
     """
     def __init__(self):
         l = pygments_lexers
         self.python_lexer = PygmentsLexer(l.Python3Lexer)
         self.shell_lexer = PygmentsLexer(l.BashLexer)
 
         self.magic_lexers = {
             'HTML': PygmentsLexer(l.HtmlLexer),
             'html': PygmentsLexer(l.HtmlLexer),
             'javascript': PygmentsLexer(l.JavascriptLexer),
             'js': PygmentsLexer(l.JavascriptLexer),
             'perl': PygmentsLexer(l.PerlLexer),
             'ruby': PygmentsLexer(l.RubyLexer),
             'latex': PygmentsLexer(l.TexLexer),
         }
 
     def lex_document(self, document):
         text = document.text.lstrip()
 
         lexer = self.python_lexer
 
         if text.startswith('!') or text.startswith('%%bash'):
             lexer = self.shell_lexer
 
         elif text.startswith('%%'):
             for magic, l in self.magic_lexers.items():
                 if text.startswith('%%' + magic):
                     lexer = l
                     break
 
         return lexer.lex_document(document)

IPython/terminal/tests/test_interactivshell.py

@@ -1,170 +1,175 b''
 # -*- coding: utf-8 -*-
 """Tests for the TerminalInteractiveShell and related pieces."""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import sys
 import unittest
+import os
 
 from IPython.core.inputtransformer import InputTransformer
 from IPython.testing import tools as tt
 from IPython.utils.capture import capture_output
 
 from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
 import nose.tools as nt
 
 class TestElide(unittest.TestCase):
 
     def test_elide(self):
         _elide('concatenate((a1, a2, ...), axis') # do not raise
         _elide('concatenate((a1, a2, ..), . axis') # do not raise
         nt.assert_equal(_elide('aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh'), 'aaaa.b…g.hhhhhh')
 
+        test_string = os.sep.join(['', 10*'a', 10*'b', 10*'c', ''])
+        expect_stirng = os.sep + 'a' + '\N{HORIZONTAL ELLIPSIS}' + 'b' + os.sep + 10*'c'
+        nt.assert_equal(_elide(test_string), expect_stirng)
+
 
 class TestContextAwareCompletion(unittest.TestCase):
 
     def test_adjust_completion_text_based_on_context(self):
         # Adjusted case
         nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a=)', 7), 'arg1')
 
         # Untouched cases
         nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a)', 7), 'arg1=')
         nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a', 7), 'arg1=')
         nt.assert_equal(_adjust_completion_text_based_on_context('%magic', 'func1(a=)', 7), '%magic')
         nt.assert_equal(_adjust_completion_text_based_on_context('func2', 'func1(a=)', 7), 'func2')
 
 # 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_prompt_for_code = self.ip.prompt_for_code
         self.ip.prompt_for_code = self.fake_input
         return self
 
     def __exit__(self, etype, value, tb):
         self.ip.prompt_for_code = self.orig_prompt_for_code
 
     def fake_input(self):
         try:
             return next(self.testgen)
         except StopIteration:
             self.ip.keep_running = False
             return u''
         except:
             self.exception = sys.exc_info()
             self.ip.keep_running = False
             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()
 
         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)]
     
     @mock_input
     def test_inputtransformer_syntaxerror(self):
         ip = get_ipython()
         ip.input_transformers_post.append(syntax_error_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_transformers_post.remove(syntax_error_transformer)
 
     def test_plain_text_only(self):
         ip = get_ipython()
         formatter = ip.display_formatter
         assert formatter.active_types == ['text/plain']
         assert not formatter.ipython_display_formatter.enabled
 
         class Test(object):
             def __repr__(self):
                 return "<Test %i>" % id(self)
 
             def _repr_html_(self):
                 return '<html>'
 
         # verify that HTML repr isn't computed
         obj = Test()
         data, _ = formatter.format(obj)
         self.assertEqual(data, {'text/plain': repr(obj)})
 
         class Test2(Test):
             def _ipython_display_(self):
                 from IPython.display import display
                 display('<custom>')
 
         # verify that _ipython_display_ shortcut isn't called
         obj = Test2()
         with capture_output() as captured:
             data, _ = formatter.format(obj)
 
         self.assertEqual(data, {'text/plain': repr(obj)})
         assert captured.stdout == ''
 
 def syntax_error_transformer(lines):
     """Transformer that throws SyntaxError if 'syntaxerror' is in the code."""
     for line in lines:
         pos = line.find('syntaxerror')
         if pos >= 0:
             e = SyntaxError('input contains "syntaxerror"')
             e.text = line
             e.offset = pos + 1
             raise e
     return lines
 
 
 class TerminalMagicsTestCase(unittest.TestCase):
     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)