Completed first pass of inputsplitter with IPython syntax.

Code is now mostly ready for use.  Upon review we'll probably
restructure a few things, and there will likely be a few more classes
created for extensibility.  But for now, this is ready for the various
frontends to start using.

IPython/core/inputsplitter.py

@@ -1,521 +1,798 b''
 """Analysis of text input into executable blocks.
 
 The main class in this module, :class:`InputSplitter`, is designed to break
 input from either interactive, line-by-line environments or block-based ones,
 into standalone blocks that can be executed by Python as 'single' statements
 (thus triggering sys.displayhook).
 
 For more details, see the class docstring below.
+
+Authors
+
+* Fernando Perez
+* Brian Granger
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010  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 codeop
 import re
 import sys
 
 # IPython modules
 from IPython.utils.text import make_quoted_expr
 
 #-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+
+# The escape sequences that define the syntax transformations IPython will
+# apply to user input.  These can NOT be just changed here: many regular
+# expressions and other parts of the code may use their hardcoded values, and
+# for all intents and purposes they constitute the 'IPython syntax', so they
+# should be considered fixed.
+
+ESC_SHELL  = '!'
+ESC_SH_CAP = '!!'
+ESC_HELP   = '?'
+ESC_HELP2  = '??'
+ESC_MAGIC  = '%'
+ESC_QUOTE  = ','
+ESC_QUOTE2 = ';'
+ESC_PAREN  = '/'
+
+#-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
-# FIXME: move these utilities to the general ward...
+# FIXME: These are general-purpose utilities that later can be moved to the
+# general ward.  Kept here for now because we're being very strict about test
+# coverage with this code, and this lets us ensure that we keep 100% coverage
+# while developing.
 
 # compiled regexps for autoindent management
 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
 ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)')
 
 
 def num_ini_spaces(s):
     """Return the number of initial spaces in a string.
 
     Note that tabs are counted as a single space.  For now, we do *not* support
     mixing of tabs and spaces in the user's input.
 
     Parameters
     ----------
     s : string
 
     Returns
     -------
     n : int
     """
 
     ini_spaces = ini_spaces_re.match(s)
     if ini_spaces:
         return ini_spaces.end()
     else:
         return 0
 
 
 def remove_comments(src):
     """Remove all comments from input source.
 
     Note: comments are NOT recognized inside of strings!
 
     Parameters
     ----------
     src : string
       A single or multiline input string.
 
     Returns
     -------
     String with all Python comments removed.
     """
 
     return re.sub('#.*', '', src)
 
 
 def get_input_encoding():
     """Return the default standard input encoding.
 
     If sys.stdin has no encoding, 'ascii' is returned."""
     # There are strange environments for which sys.stdin.encoding is None. We
     # ensure that a valid encoding is returned.
     encoding = getattr(sys.stdin, 'encoding', None)
     if encoding is None:
         encoding = 'ascii'
     return encoding
 
 #-----------------------------------------------------------------------------
-# Classes and functions
+# Classes and functions for normal Python syntax handling
 #-----------------------------------------------------------------------------
 
 class InputSplitter(object):
     """An object that can split Python source input in executable blocks.
 
     This object is designed to be used in one of two basic modes:
 
     1. By feeding it python source line-by-line, using :meth:`push`.  In this
        mode, it will return on each push whether the currently pushed code
        could be executed already.  In addition, it provides a method called
        :meth:`push_accepts_more` that can be used to query whether more input
        can be pushed into a single interactive block.
 
     2. By calling :meth:`split_blocks` with a single, multiline Python string,
        that is then split into blocks each of which can be executed
        interactively as a single statement.
 
     This is a simple example of how an interactive terminal-based client can use
     this tool::
 
         isp = InputSplitter()
         while isp.push_accepts_more():
             indent = ' '*isp.indent_spaces
             prompt = '>>> ' + indent
             line = indent + raw_input(prompt)
             isp.push(line)
         print 'Input source was:\n', isp.source_reset(),
     """
     # Number of spaces of indentation computed from input that has been pushed
     # so far.  This is the attributes callers should query to get the current
     # indentation level, in order to provide auto-indent facilities.
     indent_spaces = 0
     # String, indicating the default input encoding.  It is computed by default
     # at initialization time via get_input_encoding(), but it can be reset by a
     # client with specific knowledge of the encoding.
     encoding = ''
     # String where the current full source input is stored, properly encoded.
     # Reading this attribute is the normal way of querying the currently pushed
     # source code, that has been properly encoded.
     source = ''
     # Code object corresponding to the current source.  It is automatically
     # synced to the source, so it can be queried at any time to obtain the code
     # object; it will be None if the source doesn't compile to valid Python.
     code = None
     # Input mode
     input_mode = 'append'
     
     # Private attributes
     
     # List with lines of input accumulated so far
     _buffer = None
     # Command compiler
     _compile = None
     # Mark when input has changed indentation all the way back to flush-left
     _full_dedent = False
     # Boolean indicating whether the current block is complete
     _is_complete = None
     
     def __init__(self, input_mode=None):
         """Create a new InputSplitter instance.
 
         Parameters
         ----------
         input_mode : str
 
           One of 'append', 'replace', default is 'append'.  This controls how
           new inputs are used: in 'append' mode, they are appended to the
           existing buffer and the whole buffer is compiled; in 'replace' mode,
           each new input completely replaces all prior inputs.  Replace mode is
           thus equivalent to prepending a full reset() to every push() call.
 
           In practice, line-oriented clients likely want to use 'append' mode
           while block-oriented ones will want to use 'replace'.
         """
         self._buffer = []
         self._compile = codeop.CommandCompiler()
         self.encoding = get_input_encoding()
         self.input_mode = InputSplitter.input_mode if input_mode is None \
                           else input_mode
 
     def reset(self):
         """Reset the input buffer and associated state."""
         self.indent_spaces = 0
         self._buffer[:] = []
         self.source = ''
         self.code = None
         self._is_complete = False
         self._full_dedent = False
 
     def source_reset(self):
         """Return the input source and perform a full reset.
         """
         out = self.source
         self.reset()
         return out
 
     def push(self, lines):
         """Push one ore more lines of input.
 
         This stores the given lines and returns a status code indicating
         whether the code forms a complete Python block or not.
 
         Any exceptions generated in compilation are swallowed, but if an
         exception was produced, the method returns True.
 
         Parameters
         ----------
         lines : string
           One or more lines of Python input.
         
         Returns
         -------
         is_complete : boolean
           True if the current input source (the result of the current input
         plus prior inputs) forms a complete Python execution block.  Note that
         this value is also stored as a private attribute (_is_complete), so it
         can be queried at any time.
         """
         if self.input_mode == 'replace':
             self.reset()
         
         # If the source code has leading blanks, add 'if 1:\n' to it
         # this allows execution of indented pasted code. It is tempting
         # to add '\n' at the end of source to run commands like ' a=1'
         # directly, but this fails for more complicated scenarios
         if not self._buffer and lines[:1] in [' ', '\t']:
             lines = 'if 1:\n%s' % lines
         
         self._store(lines)
         source = self.source
 
         # Before calling _compile(), reset the code object to None so that if an
         # exception is raised in compilation, we don't mislead by having
         # inconsistent code/source attributes.
         self.code, self._is_complete = None, None
 
         self._update_indent(lines)
         try:
             self.code = self._compile(source)
         # Invalid syntax can produce any of a number of different errors from
         # inside the compiler, so we have to catch them all.  Syntax errors
         # immediately produce a 'ready' block, so the invalid Python can be
         # sent to the kernel for evaluation with possible ipython
         # special-syntax conversion.
         except (SyntaxError, OverflowError, ValueError, TypeError,
                 MemoryError):
             self._is_complete = True
         else:
             # Compilation didn't produce any exceptions (though it may not have
             # given a complete code object)
             self._is_complete = self.code is not None
 
         return self._is_complete
 
     def push_accepts_more(self):
         """Return whether a block of interactive input can accept more input.
 
         This method is meant to be used by line-oriented frontends, who need to
         guess whether a block is complete or not based solely on prior and
         current input lines.  The InputSplitter considers it has a complete
         interactive block and will not accept more input only when either a
         SyntaxError is raised, or *all* of the following are true:
 
         1. The input compiles to a complete statement.
         
         2. The indentation level is flush-left (because if we are indented,
            like inside a function definition or for loop, we need to keep
            reading new input).
           
         3. There is one extra line consisting only of whitespace.
 
         Because of condition #3, this method should be used only by
         *line-oriented* frontends, since it means that intermediate blank lines
         are not allowed in function definitions (or any other indented block).
 
         Block-oriented frontends that have a separate keyboard event to
         indicate execution should use the :meth:`split_blocks` method instead.
 
         If the current input produces a syntax error, this method immediately
         returns False but does *not* raise the syntax error exception, as
         typically clients will want to send invalid syntax to an execution
         backend which might convert the invalid syntax into valid Python via
         one of the dynamic IPython mechanisms.
         """
             
         if not self._is_complete:
             return True
 
         if self.indent_spaces==0:
             return False
         
         last_line = self.source.splitlines()[-1]
         return bool(last_line and not last_line.isspace())
         
     def split_blocks(self, lines):
         """Split a multiline string into multiple input blocks.
 
         Note: this method starts by performing a full reset().
         
         Parameters
         ----------
         lines : str
           A possibly multiline string.
 
         Returns
         -------
         blocks : list
           A list of strings, each possibly multiline.  Each string corresponds
           to a single block that can be compiled in 'single' mode (unless it
           has a syntax error)."""
 
         # This code is fairly delicate.  If you make any changes here, make
         # absolutely sure that you do run the full test suite and ALL tests
         # pass.
 
         self.reset()
         blocks = []
         
         # Reversed copy so we can use pop() efficiently and consume the input
         # as a stack
         lines = lines.splitlines()[::-1]
         # Outer loop over all input
         while lines:
             # Inner loop to build each block
             while True:
                 # Safety exit from inner loop
                 if not lines:
                     break
                 # Grab next line but don't push it yet
                 next_line = lines.pop()
                 # Blank/empty lines are pushed as-is
                 if not next_line or next_line.isspace():
                     self.push(next_line)
                     continue
 
                 # Check indentation changes caused by the *next* line
                 indent_spaces, _full_dedent = self._find_indent(next_line)
 
                 # If the next line causes a dedent, it can be for two differnt
                 # reasons: either an explicit de-dent by the user or a
                 # return/raise/pass statement.  These MUST be handled
                 # separately:
                 #
                 # 1. the first case is only detected when the actual explicit
                 # dedent happens, and that would be the *first* line of a *new*
                 # block.  Thus, we must put the line back into the input buffer
                 # so that it starts a new block on the next pass.
                 #
                 # 2. the second case is detected in the line before the actual
                 # dedent happens, so , we consume the line and we can break out
                 # to start a new block.
 
                 # Case 1, explicit dedent causes a break
                 if _full_dedent and not next_line.startswith(' '):
                     lines.append(next_line)
                     break
                 
                 # Otherwise any line is pushed
                 self.push(next_line)
 
                 # Case 2, full dedent with full block ready:
                 if _full_dedent or \
                        self.indent_spaces==0 and not self.push_accepts_more():
                     break
             # Form the new block with the current source input
             blocks.append(self.source_reset())
             
         return blocks
 
     #------------------------------------------------------------------------
     # Private interface
     #------------------------------------------------------------------------
 
     def _find_indent(self, line):
         """Compute the new indentation level for a single line.
 
         Parameters
         ----------
         line : str
           A single new line of non-whitespace, non-comment Python input.
           
         Returns
         -------
         indent_spaces : int
           New value for the indent level (it may be equal to self.indent_spaces
         if indentation doesn't change.
 
         full_dedent : boolean
           Whether the new line causes a full flush-left dedent.
         """
         indent_spaces = self.indent_spaces
         full_dedent = self._full_dedent
         
         inisp = num_ini_spaces(line)
         if inisp < indent_spaces:
             indent_spaces = inisp
             if indent_spaces <= 0:
                 #print 'Full dedent in text',self.source # dbg
                 full_dedent = True
 
         if line[-1] == ':':
             indent_spaces += 4
         elif dedent_re.match(line):
             indent_spaces -= 4
             if indent_spaces <= 0:
                 full_dedent = True
 
         # Safety
         if indent_spaces < 0:
             indent_spaces = 0
             #print 'safety' # dbg
             
         return indent_spaces, full_dedent
         
     def _update_indent(self, lines):
         for line in remove_comments(lines).splitlines():
             if line and not line.isspace():
                 self.indent_spaces, self._full_dedent = self._find_indent(line)
 
     def _store(self, lines):
         """Store one or more lines of input.
 
         If input lines are not newline-terminated, a newline is automatically
         appended."""
 
         if lines.endswith('\n'):
             self._buffer.append(lines)
         else:
             self._buffer.append(lines+'\n')
         self._set_source()
 
     def _set_source(self):
         self.source = ''.join(self._buffer).encode(self.encoding)
 
 
 #-----------------------------------------------------------------------------
-# IPython-specific syntactic support
+# Functions and classes for IPython-specific syntactic support
 #-----------------------------------------------------------------------------
 
-# We implement things, as much as possible, as standalone functions that can be
-# tested and validated in isolation.
+# RegExp for splitting line contents into pre-char//first word-method//rest.
+# For clarity, each group in on one line.
+
+line_split = re.compile("""
+             ^(\s*)              # any leading space
+             ([,;/%]|!!?|\?\??)  # escape character or characters
+             \s*([\w\.]*)        # function/method part (mix of \w and '.')
+             (\s+.*$|$)          # rest of line
+             """, re.VERBOSE)
+
+
+def split_user_input(line):
+    """Split user input into early whitespace, esc-char, function part and rest.
+
+    This is currently handles lines with '=' in them in a very inconsistent
+    manner.
+
+    Examples
+    ========
+    >>> split_user_input('x=1')
+    ('', '', 'x=1', '')
+    >>> split_user_input('?')
+    ('', '?', '', '')
+    >>> split_user_input('??')
+    ('', '??', '', '')
+    >>> split_user_input(' ?')
+    (' ', '?', '', '')
+    >>> split_user_input(' ??')
+    (' ', '??', '', '')
+    >>> split_user_input('??x')
+    ('', '??', 'x', '')
+    >>> split_user_input('?x=1')
+    ('', '', '?x=1', '')
+    >>> split_user_input('!ls')
+    ('', '!', 'ls', '')
+    >>> split_user_input('  !ls')
+    ('  ', '!', 'ls', '')
+    >>> split_user_input('!!ls')
+    ('', '!!', 'ls', '')
+    >>> split_user_input('  !!ls')
+    ('  ', '!!', 'ls', '')
+    >>> split_user_input(',ls')
+    ('', ',', 'ls', '')
+    >>> split_user_input(';ls')
+    ('', ';', 'ls', '')
+    >>> split_user_input('  ;ls')
+    ('  ', ';', 'ls', '')
+    >>> split_user_input('f.g(x)')
+    ('', '', 'f.g(x)', '')
+    >>> split_user_input('f.g (x)')
+    ('', '', 'f.g', '(x)')
+    """
+    match = line_split.match(line)
+    if match:
+        lspace, esc, fpart, rest = match.groups()
+    else:
+        # print "match failed for line '%s'" % line
+        try:
+            fpart, rest = line.split(None,1)
+        except ValueError:
+            # print "split failed for line '%s'" % line
+            fpart, rest = line,''
+        lspace = re.match('^(\s*)(.*)',line).groups()[0]
+        esc = ''
+
+    # fpart has to be a valid python identifier, so it better be only pure
+    # ascii, no unicode:
+    try:
+        fpart = fpart.encode('ascii')
+    except UnicodeEncodeError:
+        lspace = unicode(lspace)
+        rest = fpart + u' ' + rest
+        fpart = u''
+
+    #print 'line:<%s>' % line # dbg
+    #print 'esc <%s> fpart <%s> rest <%s>' % (esc,fpart.strip(),rest) # dbg
+    return lspace, esc, fpart.strip(), rest.lstrip()
+
+
+# The escaped translators ALL receive a line where their own escape has been
+# stripped.  Only '?' is valid at the end of the line, all others can only be
+# placed at the start.
+
+class LineInfo(object):
+    """A single line of input and associated info.
+
+    This is a utility class that mostly wraps the output of
+    :func:`split_user_input` into a convenient object to be passed around
+    during input transformations.
+
+    Includes the following as properties: 
+
+    line
+      The original, raw line
+
+    lspace
+      Any early whitespace before actual text starts.
+
+    esc
+      The initial esc character (or characters, for double-char escapes like
+      '??' or '!!').
+    
+    pre_char
+      The escape character(s) in esc or the empty string if there isn't one.
+    
+    fpart
+      The 'function part', which is basically the maximal initial sequence
+      of valid python identifiers and the '.' character.  This is what is
+      checked for alias and magic transformations, used for auto-calling,
+      etc.
+    
+    rest
+      Everything else on the line.
+    """
+    def __init__(self, line):
+        self.line = line
+        self.lspace, self.esc, self.fpart, self.rest = \
+                             split_user_input(line)
+
+    def __str__(self):                                                         
+        return "LineInfo [%s|%s|%s|%s]" % (self.lspace, self.esc,
+                                           self.fpart, self.rest)
+
+
+# Transformations of the special syntaxes that don't rely on an explicit escape
+# character but instead on patterns on the input line
+
+# The core transformations are implemented as standalone functions that can be
+# tested and validated in isolation.  Each of these uses a regexp, we
+# pre-compile these and keep them close to each function definition for clarity
 
-# Each of these uses a regexp, we pre-compile these and keep them close to each
-# function definition for clarity
 _assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
                                r'\s*=\s*!\s*(?P<cmd>.*)')
 
 def transform_assign_system(line):
     """Handle the `files = !ls` syntax."""
     # FIXME: This transforms the line to use %sc, but we've listed that magic
     # as deprecated.  We should then implement this functionality in a
     # standalone api that we can transform to, without going through a
     # deprecated magic.
     m = _assign_system_re.match(line)
     if m is not None:
         cmd = m.group('cmd')
         lhs = m.group('lhs')
         expr = make_quoted_expr("sc -l = %s" % cmd)
         new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
         return new_line
     return line
 
 
 _assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
                                r'\s*=\s*%\s*(?P<cmd>.*)')
 
 def transform_assign_magic(line):
     """Handle the `a = %who` syntax."""
     m = _assign_magic_re.match(line)
     if m is not None:
         cmd = m.group('cmd')
         lhs = m.group('lhs')
         expr = make_quoted_expr(cmd)
         new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
         return new_line
     return line
 
 
-_classic_prompt_re = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
+_classic_prompt_re = re.compile(r'^([ \t]*>>> |^[ \t]*\.\.\. )')
 
 def transform_classic_prompt(line):
     """Handle inputs that start with '>>> ' syntax."""
 
-    if not line or line.isspace() or line.strip() == '...':
-        # This allows us to recognize multiple input prompts separated by
-        # blank lines and pasted in a single chunk, very common when
-        # pasting doctests or long tutorial passages.
-        return ''
+    if not line or line.isspace():
+        return line
     m = _classic_prompt_re.match(line)
     if m:
         return line[len(m.group(0)):]
     else:
         return line
 
 
-_ipy_prompt_re = re.compile(r'(^[ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
+_ipy_prompt_re = re.compile(r'^([ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
 
 def transform_ipy_prompt(line):
     """Handle inputs that start classic IPython prompt syntax."""
 
-    if not line or line.isspace() or line.strip() == '...':
-        # This allows us to recognize multiple input prompts separated by
-        # blank lines and pasted in a single chunk, very common when
-        # pasting doctests or long tutorial passages.
-        return ''
+    if not line or line.isspace():
+        return line
     m = _ipy_prompt_re.match(line)
     if m:
         return line[len(m.group(0)):]
     else:
         return line
 
 
-# Warning, these cannot be changed unless various regular expressions
-# are updated in a number of places.  Not great, but at least we told you.
-ESC_SHELL  = '!'
-ESC_SH_CAP = '!!'
-ESC_HELP   = '?'
-ESC_MAGIC  = '%'
-ESC_QUOTE  = ','
-ESC_QUOTE2 = ';'
-ESC_PAREN  = '/'
+def transform_unescaped(line):
+    """Transform lines that are explicitly escaped out.
+
+    This calls to the above transform_* functions for the actual line
+    translations.
+
+    Parameters
+    ----------
+    line : str
+      A single line of input to be transformed.
+
+    Returns
+    -------
+    new_line : str
+      Transformed line, which may be identical to the original."""
+
+    if not line or line.isspace():
+        return line
+
+    new_line = line
+    for f in [transform_assign_system, transform_assign_magic,
+             transform_classic_prompt, transform_ipy_prompt ] :
+        new_line = f(new_line)
+    return new_line
+        
+# Support for syntax transformations that use explicit escapes typed by the
+# user at the beginning of a line
+
+def tr_system(line_info):
+    "Translate lines escaped with: !"
+    cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
+    return '%sget_ipython().system(%s)' % (line_info.lspace,
+                                           make_quoted_expr(cmd))
+
+
+def tr_system2(line_info):
+    "Translate lines escaped with: !!"
+    cmd = line_info.line.lstrip()[2:]
+    return '%sget_ipython().getoutput(%s)' % (line_info.lspace,
+                                              make_quoted_expr(cmd))
+                                         
+
+def tr_help(line_info):
+    "Translate lines escaped with: ?/??"
+    # A naked help line should just fire the intro help screen
+    if not line_info.line[1:]:
+        return 'get_ipython().show_usage()'
+
+    # There may be one or two '?' at the end, move them to the front so that
+    # the rest of the logic can assume escapes are at the start
+    line = line_info.line
+    if line.endswith('?'):
+        line = line[-1] + line[:-1]
+    if line.endswith('?'):
+        line = line[-1] + line[:-1]
+    line_info = LineInfo(line)
+
+    # From here on, simply choose which level of detail to get.
+    if line_info.esc == '?':
+        pinfo = 'pinfo'
+    elif line_info.esc == '??':
+        pinfo = 'pinfo2'
+
+    tpl = '%sget_ipython().magic("%s %s")'
+    return tpl % (line_info.lspace, pinfo,
+                  ' '.join([line_info.fpart, line_info.rest]).strip())
+
+
+def tr_magic(line_info):
+    "Translate lines escaped with: %"
+    tpl = '%sget_ipython().magic(%s)'
+    cmd = make_quoted_expr(' '.join([line_info.fpart,
+                                     line_info.rest])).strip()
+    return tpl % (line_info.lspace, cmd)
+
+
+def tr_quote(line_info):
+    "Translate lines escaped with: ,"
+    return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
+                         '", "'.join(line_info.rest.split()) )
+
+
+def tr_quote2(line_info):
+    "Translate lines escaped with: ;"
+    return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
+                           line_info.rest)
+
+
+def tr_paren(line_info):
+    "Translate lines escaped with: /"
+    return '%s%s(%s)' % (line_info.lspace, line_info.fpart,
+                         ", ".join(line_info.rest.split()))
+
+
+def transform_escaped(line):
+    """Transform lines that are explicitly escaped out.
+
+    This calls to the above tr_* functions for the actual line translations."""
+
+    tr = { ESC_SHELL  : tr_system,
+           ESC_SH_CAP : tr_system2,
+           ESC_HELP   : tr_help,
+           ESC_HELP2  : tr_help,
+           ESC_MAGIC  : tr_magic,
+           ESC_QUOTE  : tr_quote,
+           ESC_QUOTE2 : tr_quote2,
+           ESC_PAREN  : tr_paren }
+
+    # Empty lines just get returned unmodified
+    if not line or line.isspace():
+        return line
+
+    # Get line endpoints, where the escapes can be
+    line_info = LineInfo(line)
+
+    # If the escape is not at the start, only '?' needs to be special-cased.
+    # All other escapes are only valid at the start
+    if not line_info.esc in tr:
+        if line.endswith(ESC_HELP):
+            return tr_help(line_info)
+        else:
+            # If we don't recognize the escape, don't modify the line
+            return line
+    
+    return tr[line_info.esc](line_info)
+
 
 class IPythonInputSplitter(InputSplitter):
     """An input splitter that recognizes all of IPython's special syntax."""
 
-
     def push(self, lines):
         """Push one or more lines of IPython input.
         """
-        return super(IPythonInputSplitter, self).push(lines)
+        # We only apply the line transformers to the input if we have either no
+        # input yet, or complete input.  This prevents the accidental
+        # transformation of escapes inside multiline expressions like
+        # triple-quoted strings or parenthesized expressions.
+        lines_list = lines.splitlines()
+        if self._is_complete or not self._buffer:
+                
+            new_list = map(transform_escaped, lines_list)
+        else:
+            new_list = lines_list
+
+        # Now apply the unescaped transformations to each input line
+        new_list = map(transform_unescaped, new_list)
+        newlines = '\n'.join(new_list)
+        return super(IPythonInputSplitter, self).push(newlines)

IPython/core/tests/test_inputsplitter.py

@@ -1,411 +1,623 b''
+# -*- coding: utf-8 -*-
 """Tests for the inputsplitter module.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010  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 unittest
 import sys
 
 # Third party
 import nose.tools as nt
 
 # Our own
 from IPython.core import inputsplitter as isp
 
 #-----------------------------------------------------------------------------
 # Semi-complete examples (also used as tests)
 #-----------------------------------------------------------------------------
+
+# Note: at the bottom, there's a slightly more complete version of this that
+# can be useful during development of code here.
+
 def mini_interactive_loop(raw_input):
     """Minimal example of the logic of an interactive interpreter loop.
 
     This serves as an example, and it is used by the test system with a fake
     raw_input that simulates interactive input."""
 
     from IPython.core.inputsplitter import InputSplitter
     
     isp = InputSplitter()
     # In practice, this input loop would be wrapped in an outside loop to read
     # input indefinitely, until some exit/quit command was issued.  Here we
     # only illustrate the basic inner loop.
     while isp.push_accepts_more():
         indent = ' '*isp.indent_spaces
         prompt = '>>> ' + indent
         line = indent + raw_input(prompt)
         isp.push(line)
 
     # Here we just return input so we can use it in a test suite, but a real
     # interpreter would instead send it for execution somewhere.
     src = isp.source_reset()
-    print 'Input source was:\n', src
+    #print 'Input source was:\n', src  # dbg
     return src
 
 #-----------------------------------------------------------------------------
 # Test utilities, just for local use
 #-----------------------------------------------------------------------------
 
 def assemble(block):
     """Assemble a block into multi-line sub-blocks."""
     return ['\n'.join(sub_block)+'\n' for sub_block in block]
 
 
 def pseudo_input(lines):
     """Return a function that acts like raw_input but feeds the input list."""
     ilines = iter(lines)
     def raw_in(prompt):
         try:
             return next(ilines)
         except StopIteration:
             return ''
     return raw_in
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 def test_spaces():
     tests = [('', 0),
              (' ', 1),
              ('\n', 0),
              (' \n', 1),
              ('x', 0),
              (' x', 1),
              ('  x',2),
              ('    x',4),
              # Note: tabs are counted as a single whitespace!
              ('\tx', 1),
              ('\t x', 2),
              ]
     
     for s, nsp in tests:
         nt.assert_equal(isp.num_ini_spaces(s), nsp)
 
 
 def test_remove_comments():
     tests = [('text', 'text'),
              ('text # comment', 'text '),
              ('text # comment\n', 'text \n'),
              ('text # comment \n', 'text \n'),
              ('line # c \nline\n','line \nline\n'),
              ('line # c \nline#c2  \nline\nline #c\n\n',
               'line \nline\nline\nline \n\n'),
              ]
 
     for inp, out in tests:
         nt.assert_equal(isp.remove_comments(inp), out)
 
 
 def test_get_input_encoding():
     encoding = isp.get_input_encoding()
     nt.assert_true(isinstance(encoding, basestring))
     # simple-minded check that at least encoding a simple string works with the
     # encoding we got.
     nt.assert_equal('test'.encode(encoding), 'test')
 
 
 class NoInputEncodingTestCase(unittest.TestCase):
     def setUp(self):
         self.old_stdin = sys.stdin
         class X: pass
         fake_stdin = X()
         sys.stdin = fake_stdin
         
     def test(self):
         # Verify that if sys.stdin has no 'encoding' attribute we do the right
         # thing
         enc = isp.get_input_encoding()
         self.assertEqual(enc, 'ascii')
         
     def tearDown(self):
         sys.stdin = self.old_stdin
 
 
 class InputSplitterTestCase(unittest.TestCase):
     def setUp(self):
         self.isp = isp.InputSplitter()
 
     def test_reset(self):
         isp = self.isp
         isp.push('x=1')
         isp.reset()
         self.assertEqual(isp._buffer, [])
         self.assertEqual(isp.indent_spaces, 0)
         self.assertEqual(isp.source, '')
         self.assertEqual(isp.code, None)
         self.assertEqual(isp._is_complete, False)
 
     def test_source(self):
         self.isp._store('1')
         self.isp._store('2')
         self.assertEqual(self.isp.source, '1\n2\n')
         self.assertTrue(len(self.isp._buffer)>0)
         self.assertEqual(self.isp.source_reset(), '1\n2\n')
         self.assertEqual(self.isp._buffer, [])
         self.assertEqual(self.isp.source, '')
         
     def test_indent(self):
         isp = self.isp # shorthand
         isp.push('x=1')
         self.assertEqual(isp.indent_spaces, 0)
         isp.push('if 1:\n    x=1')
         self.assertEqual(isp.indent_spaces, 4)
         isp.push('y=2\n')
         self.assertEqual(isp.indent_spaces, 0)
         isp.push('if 1:')
         self.assertEqual(isp.indent_spaces, 4)
         isp.push('    x=1')
         self.assertEqual(isp.indent_spaces, 4)
         # Blank lines shouldn't change the indent level
         isp.push(' '*2)
         self.assertEqual(isp.indent_spaces, 4)
 
     def test_indent2(self):
         isp = self.isp
         # When a multiline statement contains parens or multiline strings, we
         # shouldn't get confused.
         isp.push("if 1:")
         isp.push("    x = (1+\n    2)")
         self.assertEqual(isp.indent_spaces, 4)
 
     def test_dedent(self):
         isp = self.isp # shorthand
         isp.push('if 1:')
         self.assertEqual(isp.indent_spaces, 4)
         isp.push('    pass')
         self.assertEqual(isp.indent_spaces, 0)
         
     def test_push(self):
         isp = self.isp
         self.assertTrue(isp.push('x=1'))
 
     def test_push2(self):
         isp = self.isp
         self.assertFalse(isp.push('if 1:'))
         for line in ['  x=1', '# a comment', '  y=2']:
             self.assertTrue(isp.push(line))
             
     def test_push3(self):
         """Test input with leading whitespace"""
         isp = self.isp
         isp.push('  x=1')
         isp.push('  y=2')
         self.assertEqual(isp.source, 'if 1:\n  x=1\n  y=2\n')
 
     def test_replace_mode(self):
         isp = self.isp
         isp.input_mode = 'replace'
         isp.push('x=1')
         self.assertEqual(isp.source, 'x=1\n')
         isp.push('x=2')
         self.assertEqual(isp.source, 'x=2\n')
 
     def test_push_accepts_more(self):
         isp = self.isp
         isp.push('x=1')
         self.assertFalse(isp.push_accepts_more())
 
     def test_push_accepts_more2(self):
         isp = self.isp
         isp.push('if 1:')
         self.assertTrue(isp.push_accepts_more())
         isp.push('  x=1')
         self.assertTrue(isp.push_accepts_more())
         isp.push('')
         self.assertFalse(isp.push_accepts_more())
         
     def test_push_accepts_more3(self):
         isp = self.isp
         isp.push("x = (2+\n3)")
         self.assertFalse(isp.push_accepts_more())
 
     def test_push_accepts_more4(self):
         isp = self.isp
         # When a multiline statement contains parens or multiline strings, we
         # shouldn't get confused.
         # FIXME: we should be able to better handle de-dents in statements like
         # multiline strings and multiline expressions (continued with \ or
         # parens).  Right now we aren't handling the indentation tracking quite
         # correctly with this, though in practice it may not be too much of a
         # problem.  We'll need to see.
         isp.push("if 1:")
         isp.push("    x = (2+")
         isp.push("    3)")
         self.assertTrue(isp.push_accepts_more())
         isp.push("    y = 3")
         self.assertTrue(isp.push_accepts_more())
         isp.push('')
         self.assertFalse(isp.push_accepts_more())
 
     def test_syntax_error(self):
         isp = self.isp
         # Syntax errors immediately produce a 'ready' block, so the invalid
         # Python can be sent to the kernel for evaluation with possible ipython
         # special-syntax conversion.
         isp.push('run foo')
         self.assertFalse(isp.push_accepts_more())
 
     def check_split(self, block_lines, compile=True):
         blocks = assemble(block_lines)
         lines = ''.join(blocks)
         oblock = self.isp.split_blocks(lines)
         self.assertEqual(oblock, blocks)
         if compile:
             for block in blocks:
                 self.isp._compile(block)
 
     def test_split(self):
         # All blocks of input we want to test in a list.  The format for each
         # block is a list of lists, with each inner lists consisting of all the
         # lines (as single-lines) that should make up a sub-block.
 
         # Note: do NOT put here sub-blocks that don't compile, as the
         # check_split() routine makes a final verification pass to check that
         # each sub_block, as returned by split_blocks(), does compile
         # correctly.
         all_blocks = [ [['x=1']],
 
                        [['x=1'],
                         ['y=2']],
 
                        [['x=1'],
                         ['# a comment'],
                         ['y=11']],
 
                        [['if 1:',
                          '  x=1'],
                         ['y=3']],
 
                        [['def f(x):',
                          '  return x'],
                         ['x=1']],
 
                        [['def f(x):',
                          '  x+=1',
                          '  ',
                          '  return x'],
                         ['x=1']],
 
                        [['def f(x):',
                          '  if x>0:',
                          '    y=1',
                          '  # a comment',
                          '  else:',
                          '    y=4',
                          ' ',
                          '  return y'],
                         ['x=1'],
                         ['if 1:',
                          '  y=11'] ],
                        
                        [['for i in range(10):'
                          '  x=i**2']],
 
                        [['for i in range(10):'
                          '  x=i**2'],
                         ['z = 1']],
                        ]
         for block_lines in all_blocks:
             self.check_split(block_lines)
         
     def test_split_syntax_errors(self):
         # Block splitting with invalid syntax
         all_blocks = [ [['a syntax error']],
             
                        [['x=1'],
                         ['a syntax error']],
 
                        [['for i in range(10):'
                          '  an error']],
                        
                        ]
         for block_lines in all_blocks:
             self.check_split(block_lines, compile=False)
 
 
 class InteractiveLoopTestCase(unittest.TestCase):
     """Tests for an interactive loop like a python shell.
     """
     def check_ns(self, lines, ns):
         """Validate that the given input lines produce the resulting namespace.
 
         Note: the input lines are given exactly as they would be typed in an
         auto-indenting environment, as mini_interactive_loop above already does
         auto-indenting and prepends spaces to the input.
         """
         src = mini_interactive_loop(pseudo_input(lines))
         test_ns = {}
         exec src in test_ns
         # We can't check that the provided ns is identical to the test_ns,
         # because Python fills test_ns with extra keys (copyright, etc).  But
         # we can check that the given dict is *contained* in test_ns
         for k,v in ns.items():
             self.assertEqual(test_ns[k], v)
         
     def test_simple(self):
         self.check_ns(['x=1'], dict(x=1))
 
     def test_simple2(self):
         self.check_ns(['if 1:', 'x=2'], dict(x=2))
 
     def test_xy(self):
         self.check_ns(['x=1; y=2'], dict(x=1, y=2))
 
     def test_abc(self):
         self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
     
     def test_multi(self):
         self.check_ns(['x =(1+','1+','2)'], dict(x=4))
     
 
-class IPythonInputTestCase(InputSplitterTestCase):
-    def setUp(self):
-        self.isp = isp.IPythonInputSplitter()
+def test_LineInfo():
+    """Simple test for LineInfo construction and str()"""
+    linfo = isp.LineInfo('  %cd /home')
+    nt.assert_equals(str(linfo), 'LineInfo [  |%|cd|/home]')
+
+
+def test_split_user_input():
+    """Unicode test - split_user_input already has good doctests"""
+    line = u"Pérez Fernando"
+    parts = isp.split_user_input(line)
+    parts_expected = (u'', u'', u'', line)
+    nt.assert_equal(parts, parts_expected)
 
 
 # Transformer tests
 def transform_checker(tests, func):
     """Utility to loop over test inputs"""
     for inp, tr in tests:
         nt.assert_equals(func(inp), tr)
     
+# Data for all the syntax tests in the form of lists of pairs of
+# raw/transformed input.  We store it here as a global dict so that we can use
+# it both within single-function tests and also to validate the behavior of the
+# larger objects
 
-def test_assign_system():
-    tests = [('a =! ls', 'a = get_ipython().magic("sc -l = ls")'),
+syntax = \
+  dict(assign_system =
+       [('a =! ls', 'a = get_ipython().magic("sc -l = ls")'),
              ('b = !ls', 'b = get_ipython().magic("sc -l = ls")'),
-             ('x=1','x=1')]
-    transform_checker(tests, isp.transform_assign_system)
-
+        ('x=1', 'x=1'), # normal input is unmodified
+        ('    ','    '),  # blank lines are kept intact
+        ],
     
-def test_assign_magic():
-    tests = [('a =% who', 'a = get_ipython().magic("who")'),
+       assign_magic =
+       [('a =% who', 'a = get_ipython().magic("who")'),
              ('b = %who', 'b = get_ipython().magic("who")'),
-             ('x=1','x=1')]
-    transform_checker(tests, isp.transform_assign_magic)
+        ('x=1', 'x=1'), # normal input is unmodified
+        ('    ','    '),  # blank lines are kept intact
+        ],
 
+       classic_prompt =
+       [('>>> x=1', 'x=1'),
+        ('x=1', 'x=1'), # normal input is unmodified
+        ('    ','    '),  # blank lines are kept intact
+        ],
 
-def test_classic_prompt():
-    tests = [('>>> x=1', 'x=1'),
-             ('>>> for i in range(10):','for i in range(10):'),
+       ipy_prompt =
+       [('In [1]: x=1', 'x=1'),
+        ('x=1', 'x=1'), # normal input is unmodified
+        ('    ','    '),  # blank lines are kept intact
+        ],
+
+       # Tests for the escape transformer to leave normal code alone
+       escaped_noesc =
+       [ ('    ', '    '),
+         ('x=1', 'x=1'),
+         ],
+
+       # System calls
+       escaped_shell =
+       [ ('!ls', 'get_ipython().system("ls")'),
+         # Double-escape shell, this means to capture the output of the
+         # subprocess and return it
+         ('!!ls', 'get_ipython().getoutput("ls")'),
+         ],
+
+       # Help/object info
+       escaped_help =
+       [ ('?', 'get_ipython().show_usage()'),
+         ('?x1', 'get_ipython().magic("pinfo x1")'),
+         ('??x2', 'get_ipython().magic("pinfo2 x2")'),
+         ('x3?', 'get_ipython().magic("pinfo x3")'),
+         ('x4??', 'get_ipython().magic("pinfo2 x4")'),
+         ],
+
+       # Explicit magic calls
+       escaped_magic =
+       [ ('%cd', 'get_ipython().magic("cd")'),
+         ('%cd /home', 'get_ipython().magic("cd /home")'),
+         ('    %magic', '    get_ipython().magic("magic")'),
+         ],
+       
+       # Quoting with separate arguments
+       escaped_quote =
+       [ (',f', 'f("")'),
+         (',f x', 'f("x")'),
+         ('  ,f y', '  f("y")'),
+         (',f a b', 'f("a", "b")'),
+         ],
+       
+       # Quoting with single argument
+       escaped_quote2 = 
+       [ (';f', 'f("")'),
+         (';f x', 'f("x")'),
+         ('  ;f y', '  f("y")'),
+         (';f a b', 'f("a b")'),
+         ],
+       
+       # Simply apply parens
+       escaped_paren = 
+       [ ('/f', 'f()'),
+         ('/f x', 'f(x)'),
+         ('  /f y', '  f(y)'),
+         ('/f a b', 'f(a, b)'),
+         ],
+
+       # More complex multiline tests
+       ## escaped_multiline =
+       ## [()],
+       )
+
+# multiline syntax examples.  Each of these should be a list of lists, with
+# each entry itself having pairs of raw/transformed input.  The union (with
+# '\n'.join() of the transformed inputs is what the splitter should produce
+# when fed the raw lines one at a time via push.
+syntax_ml = \
+  dict(classic_prompt =
+       [ [('>>> for i in range(10):','for i in range(10):'),
              ('...     print i','    print i'),
              ('...', ''),
-             ('x=1','x=1')
-             ]
-    transform_checker(tests, isp.transform_classic_prompt)
-    
+          ],
+        ],
 
-def test_ipy_prompt():
-    tests = [('In [1]: x=1', 'x=1'),
-             ('In [24]: for i in range(10):','for i in range(10):'),
+       ipy_prompt =
+       [ [('In [24]: for i in range(10):','for i in range(10):'),
              ('   ....:     print i','    print i'),
              ('   ....: ', ''),
-             ('x=1', 'x=1'), # normal input is unmodified
-             ('   ','')  # blank lines are just collapsed
-             ]
-    transform_checker(tests, isp.transform_ipy_prompt)
+          ],
+         ],
+       )
+
+
+def test_assign_system():
+    transform_checker(syntax['assign_system'], isp.transform_assign_system)
+
+    
+def test_assign_magic():
+    transform_checker(syntax['assign_magic'], isp.transform_assign_magic)
+
+
+def test_classic_prompt():
+    transform_checker(syntax['classic_prompt'], isp.transform_classic_prompt)
+    for example in syntax_ml['classic_prompt']:
+        transform_checker(example, isp.transform_classic_prompt)
+    
+
+def test_ipy_prompt():
+    transform_checker(syntax['ipy_prompt'], isp.transform_ipy_prompt)
+    for example in syntax_ml['ipy_prompt']:
+        transform_checker(example, isp.transform_ipy_prompt)
+    
+
+def test_escaped_noesc():
+    transform_checker(syntax['escaped_noesc'], isp.transform_escaped)
+
+
+def test_escaped_shell():
+    transform_checker(syntax['escaped_shell'], isp.transform_escaped)
+
+
+def test_escaped_help():
+    transform_checker(syntax['escaped_help'], isp.transform_escaped)
     
+
+def test_escaped_magic():
+    transform_checker(syntax['escaped_magic'], isp.transform_escaped)
+
+
+def test_escaped_quote():
+    transform_checker(syntax['escaped_quote'], isp.transform_escaped)
+
+
+def test_escaped_quote2():
+    transform_checker(syntax['escaped_quote2'], isp.transform_escaped)
+
+
+def test_escaped_paren():
+    transform_checker(syntax['escaped_paren'], isp.transform_escaped)
+
+
+class IPythonInputTestCase(InputSplitterTestCase):
+    """By just creating a new class whose .isp is a different instance, we
+    re-run the same test battery on the new input splitter.
+
+    In addition, this runs the tests over the syntax and syntax_ml dicts that
+    were tested by individual functions, as part of the OO interface.
+    """
+    def setUp(self):
+        self.isp = isp.IPythonInputSplitter()
+
+    def test_syntax(self):
+        """Call all single-line syntax tests from the main object"""
+        isp = self.isp
+        for example in syntax.itervalues():
+            for raw, out_t in example:
+                if raw.startswith(' '):
+                    continue
+                
+                isp.push(raw)
+                out = isp.source_reset().rstrip()
+                self.assertEqual(out, out_t)
+        
+    def test_syntax_multiline(self):
+        isp = self.isp
+        for example in syntax_ml.itervalues():
+            out_t_parts = []
+            for line_pairs in example:
+                for raw, out_t_part in line_pairs:
+                    isp.push(raw)
+                    out_t_parts.append(out_t_part)
+
+                out = isp.source_reset().rstrip()
+                out_t = '\n'.join(out_t_parts).rstrip()
+                self.assertEqual(out, out_t)
+                
+
+#-----------------------------------------------------------------------------
+# Main - use as a script
+#-----------------------------------------------------------------------------
+
+if __name__ == '__main__':
+    # A simple demo for interactive experimentation.  This code will not get
+    # picked up by any test suite.  Useful mostly for illustration and during
+    # development.
+    from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
+    
+    #isp, start_prompt = InputSplitter(), '>>> '
+    isp, start_prompt = IPythonInputSplitter(), 'In> '
+
+    autoindent = True
+    #autoindent = False
+    
+    # In practice, this input loop would be wrapped in an outside loop to read
+    # input indefinitely, until some exit/quit command was issued.  Here we
+    # only illustrate the basic inner loop.
+    try:
+        while True:
+            prompt = start_prompt
+            while isp.push_accepts_more():
+                indent = ' '*isp.indent_spaces
+                if autoindent:
+                    line = indent + raw_input(prompt+indent)
+                else:
+                    line = raw_input(prompt)
+                isp.push(line)
+                prompt = '... '
+
+            # Here we just return input so we can use it in a test suite, but a
+            # real interpreter would instead send it for execution somewhere.
+            src = isp.source_reset()
+            print 'Input source was:\n', src  # dbg
+    except EOFError:
+        print 'Bye'

IPython/utils/text.py

@@ -1,473 +1,474 b''
 # encoding: utf-8
 """
 Utilities for working with strings and text.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-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 __main__
 
 import os
 import re
 import shutil
 import types
 
 from IPython.external.path import path
 
 from IPython.utils.generics import result_display
 from IPython.utils.io import nlprint
 from IPython.utils.data import flatten
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 StringTypes = types.StringTypes
 
 
 def unquote_ends(istr):
     """Remove a single pair of quotes from the endpoints of a string."""
 
     if not istr:
         return istr
     if (istr[0]=="'" and istr[-1]=="'") or \
        (istr[0]=='"' and istr[-1]=='"'):
         return istr[1:-1]
     else:
         return istr
 
 
 class LSString(str):
     """String derivative with a special access attributes.
 
     These are normal strings, but with the special attributes:
 
         .l (or .list) : value as list (split on newlines).
         .n (or .nlstr): original value (the string itself).
         .s (or .spstr): value as whitespace-separated string.
         .p (or .paths): list of path objects
 
     Any values which require transformations are computed only once and
     cached.
 
     Such strings are very useful to efficiently interact with the shell, which
     typically only understands whitespace-separated options for commands."""
 
     def get_list(self):
         try:
             return self.__list
         except AttributeError:
             self.__list = self.split('\n')
             return self.__list
 
     l = list = property(get_list)
 
     def get_spstr(self):
         try:
             return self.__spstr
         except AttributeError:
             self.__spstr = self.replace('\n',' ')
             return self.__spstr
 
     s = spstr = property(get_spstr)
 
     def get_nlstr(self):
         return self
 
     n = nlstr = property(get_nlstr)
 
     def get_paths(self):
         try:
             return self.__paths
         except AttributeError:
             self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
 
 
 def print_lsstring(arg):
     """ Prettier (non-repr-like) and more informative printer for LSString """
     print "LSString (.p, .n, .l, .s available). Value:"
     print arg
 
 
 print_lsstring = result_display.when_type(LSString)(print_lsstring)
 
 
 class SList(list):
     """List derivative with a special access attributes.
 
     These are normal lists, but with the special attributes:
 
         .l (or .list) : value as list (the list itself).
         .n (or .nlstr): value as a string, joined on newlines.
         .s (or .spstr): value as a string, joined on spaces.
         .p (or .paths): list of path objects
 
     Any values which require transformations are computed only once and
     cached."""
 
     def get_list(self):
         return self
 
     l = list = property(get_list)
 
     def get_spstr(self):
         try:
             return self.__spstr
         except AttributeError:
             self.__spstr = ' '.join(self)
             return self.__spstr
 
     s = spstr = property(get_spstr)
 
     def get_nlstr(self):
         try:
             return self.__nlstr
         except AttributeError:
             self.__nlstr = '\n'.join(self)
             return self.__nlstr
 
     n = nlstr = property(get_nlstr)
 
     def get_paths(self):
         try:
             return self.__paths
         except AttributeError:
             self.__paths = [path(p) for p in self if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
 
     def grep(self, pattern, prune = False, field = None):
         """ Return all strings matching 'pattern' (a regex or callable)
 
         This is case-insensitive. If prune is true, return all items
         NOT matching the pattern.
 
         If field is specified, the match must occur in the specified
         whitespace-separated field.
 
         Examples::
 
             a.grep( lambda x: x.startswith('C') )
             a.grep('Cha.*log', prune=1)
             a.grep('chm', field=-1)
         """
 
         def match_target(s):
             if field is None:
                 return s
             parts = s.split()
             try:
                 tgt = parts[field]
                 return tgt
             except IndexError:
                 return ""
 
         if isinstance(pattern, basestring):
             pred = lambda x : re.search(pattern, x, re.IGNORECASE)
         else:
             pred = pattern
         if not prune:
             return SList([el for el in self if pred(match_target(el))])
         else:
             return SList([el for el in self if not pred(match_target(el))])
 
     def fields(self, *fields):
         """ Collect whitespace-separated fields from string list
 
         Allows quick awk-like usage of string lists.
 
         Example data (in var a, created by 'a = !ls -l')::
             -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
             drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
 
         a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
         a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
         (note the joining by space).
         a.fields(-1) is ['ChangeLog', 'IPython']
 
         IndexErrors are ignored.
 
         Without args, fields() just split()'s the strings.
         """
         if len(fields) == 0:
             return [el.split() for el in self]
 
         res = SList()
         for el in [f.split() for f in self]:
             lineparts = []
 
             for fd in fields:
                 try:
                     lineparts.append(el[fd])
                 except IndexError:
                     pass
             if lineparts:
                 res.append(" ".join(lineparts))
 
         return res
 
     def sort(self,field= None,  nums = False):
         """ sort by specified fields (see fields())
 
         Example::
             a.sort(1, nums = True)
 
         Sorts a by second field, in numerical order (so that 21 > 3)
 
         """
 
         #decorate, sort, undecorate
         if field is not None:
             dsu = [[SList([line]).fields(field),  line] for line in self]
         else:
             dsu = [[line,  line] for line in self]
         if nums:
             for i in range(len(dsu)):
                 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
                 try:
                     n = int(numstr)
                 except ValueError:
                     n = 0;
                 dsu[i][0] = n
 
 
         dsu.sort()
         return SList([t[1] for t in dsu])
 
 
 def print_slist(arg):
     """ Prettier (non-repr-like) and more informative printer for SList """
     print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
     if hasattr(arg,  'hideonce') and arg.hideonce:
         arg.hideonce = False
         return
 
     nlprint(arg)
 
 
 print_slist = result_display.when_type(SList)(print_slist)
 
 
 def esc_quotes(strng):
     """Return the input string with single and double quotes escaped out"""
 
     return strng.replace('"','\\"').replace("'","\\'")
 
 
 def make_quoted_expr(s):
     """Return string s in appropriate quotes, using raw string if possible.
 
     XXX - example removed because it caused encoding errors in documentation
     generation.  We need a new example that doesn't contain invalid chars.
 
     Note the use of raw string and padding at the end to allow trailing
     backslash.
     """
 
     tail = ''
     tailpadding = ''
     raw  = ''
     if "\\" in s:
         raw = 'r'
         if s.endswith('\\'):
             tail = '[:-1]'
             tailpadding = '_'
     if '"' not in s:
         quote = '"'
     elif "'" not in s:
         quote = "'"
     elif '"""' not in s and not s.endswith('"'):
         quote = '"""'
     elif "'''" not in s and not s.endswith("'"):
         quote = "'''"
     else:
         # give up, backslash-escaped string will do
-        return '"%s"' % esc_quotes(s)
-    res = raw + quote + s + tailpadding + quote + tail
+        return '"%s"' % esc_quotes(s).strip()
+    txt = (s + tailpadding).strip()
+    res = raw + quote + txt + quote + tail
     return res
 
 
 def qw(words,flat=0,sep=None,maxsplit=-1):
     """Similar to Perl's qw() operator, but with some more options.
 
     qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
 
     words can also be a list itself, and with flat=1, the output will be
     recursively flattened.
 
     Examples:
 
     >>> qw('1 2')
     ['1', '2']
 
     >>> qw(['a b','1 2',['m n','p q']])
     [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
 
     >>> qw(['a b','1 2',['m n','p q']],flat=1)
     ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
     """
 
     if type(words) in StringTypes:
         return [word.strip() for word in words.split(sep,maxsplit)
                 if word and not word.isspace() ]
     if flat:
         return flatten(map(qw,words,[1]*len(words)))
     return map(qw,words)
 
 
 def qwflat(words,sep=None,maxsplit=-1):
     """Calls qw(words) in flat mode. It's just a convenient shorthand."""
     return qw(words,1,sep,maxsplit)
 
 
 def qw_lol(indata):
     """qw_lol('a b') -> [['a','b']],
     otherwise it's just a call to qw().
 
     We need this to make sure the modules_some keys *always* end up as a
     list of lists."""
 
     if type(indata) in StringTypes:
         return [qw(indata)]
     else:
         return qw(indata)
 
 
 def grep(pat,list,case=1):
     """Simple minded grep-like function.
     grep(pat,list) returns occurrences of pat in list, None on failure.
 
     It only does simple string matching, with no support for regexps. Use the
     option case=0 for case-insensitive matching."""
 
     # This is pretty crude. At least it should implement copying only references
     # to the original data in case it's big. Now it copies the data for output.
     out=[]
     if case:
         for term in list:
             if term.find(pat)>-1: out.append(term)
     else:
         lpat=pat.lower()
         for term in list:
             if term.lower().find(lpat)>-1: out.append(term)
 
     if len(out): return out
     else: return None
 
 
 def dgrep(pat,*opts):
     """Return grep() on dir()+dir(__builtins__).
 
     A very common use of grep() when working interactively."""
 
     return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
 
 
 def idgrep(pat):
     """Case-insensitive dgrep()"""
 
     return dgrep(pat,0)
 
 
 def igrep(pat,list):
     """Synonym for case-insensitive grep."""
 
     return grep(pat,list,case=0)
 
 
 def indent(str,nspaces=4,ntabs=0):
     """Indent a string a given number of spaces or tabstops.
 
     indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
     """
     if str is None:
         return
     ind = '\t'*ntabs+' '*nspaces
     outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
     if outstr.endswith(os.linesep+ind):
         return outstr[:-len(ind)]
     else:
         return outstr
 
 def native_line_ends(filename,backup=1):
     """Convert (in-place) a file to line-ends native to the current OS.
 
     If the optional backup argument is given as false, no backup of the
     original file is left.  """
 
     backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
 
     bak_filename = filename + backup_suffixes[os.name]
 
     original = open(filename).read()
     shutil.copy2(filename,bak_filename)
     try:
         new = open(filename,'wb')
         new.write(os.linesep.join(original.splitlines()))
         new.write(os.linesep) # ALWAYS put an eol at the end of the file
         new.close()
     except:
         os.rename(bak_filename,filename)
     if not backup:
         try:
             os.remove(bak_filename)
         except:
             pass
 
 
 def list_strings(arg):
     """Always return a list of strings, given a string or list of strings
     as input.
 
     :Examples:
 
         In [7]: list_strings('A single string')
         Out[7]: ['A single string']
 
         In [8]: list_strings(['A single string in a list'])
         Out[8]: ['A single string in a list']
 
         In [9]: list_strings(['A','list','of','strings'])
         Out[9]: ['A', 'list', 'of', 'strings']
     """
 
     if isinstance(arg,basestring): return [arg]
     else: return arg
 
 
 def marquee(txt='',width=78,mark='*'):
     """Return the input string centered in a 'marquee'.
 
     :Examples:
 
         In [16]: marquee('A test',40)
         Out[16]: '**************** A test ****************'
 
         In [17]: marquee('A test',40,'-')
         Out[17]: '---------------- A test ----------------'
 
         In [18]: marquee('A test',40,' ')
         Out[18]: '                 A test                 '
 
     """
     if not txt:
         return (mark*width)[:width]
     nmark = (width-len(txt)-2)/len(mark)/2
     if nmark < 0: nmark =0
     marks = mark*nmark
     return '%s %s %s' % (marks,txt,marks)