Changing input filtering to require whitespace separation between the initial command (alias, magic, autocall) and rest of line.

This fixes some subtle but nasty bugs with lines that start with,
e.g. r'a_string'.  They had been getting parsed as the magic %r followed by
the string literal 'a_string' -- now that's been fixed.

IPython/prefilter.py

@@ -1,313 +1,313 b''
 # -*- coding: utf-8 -*-
 """
 Classes and functions for prefiltering (transforming) a line of user input.
 This module is responsible, primarily, for breaking the line up into useful
 pieces and triggering the appropriate handlers in iplib to do the actual
 transforming work.
 """
 __docformat__ = "restructuredtext en"
 
 import re
 import IPython.ipapi
 
 class LineInfo(object):
     """A single line of input and associated info.
 
     Includes the following as properties: 
 
     line
       The original, raw line
     
     continue_prompt
       Is this line a continuation in a sequence of multiline input?
     
     pre
       The initial esc character or whitespace.
     
     preChar
       The escape character(s) in pre or the empty string if there isn't one.
       Note that '!!' is a possible value for preChar.  Otherwise it will
       always be a single character.
     
     preWhitespace
       The leading whitespace from pre if it exists.  If there is a preChar,
       this is just ''.
     
     iFun
       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.
     
     theRest
       Everything else on the line.
     """
     def __init__(self, line, continue_prompt):
         self.line            = line
         self.continue_prompt = continue_prompt
         self.pre, self.iFun, self.theRest = splitUserInput(line)
 
         self.preChar       = self.pre.strip()
         if self.preChar:
             self.preWhitespace = '' # No whitespace allowd before esc chars
         else:
             self.preWhitespace = self.pre
 
         self._oinfo = None
 
     def ofind(self, ip):
         """Do a full, attribute-walking lookup of the iFun in the various
         namespaces for the given IPython InteractiveShell instance.
 
         Return a dict with keys: found,obj,ospace,ismagic
 
         Note: can cause state changes because of calling getattr, but should
         only be run if autocall is on and if the line hasn't matched any
         other, less dangerous handlers.
 
         Does cache the results of the call, so can be called multiple times
         without worrying about *further* damaging state.
         """
         if not self._oinfo:
             self._oinfo = ip._ofind(self.iFun)
         return self._oinfo
 
 
 def splitUserInput(line, pattern=None):
     """Split user input into pre-char/whitespace, function part and rest.
 
     Mostly internal to this module, but also used by iplib.expand_aliases,
     which passes in a shell pattern.
     """
     # It seems to me that the shell splitting should be a separate method.
     
     if not pattern:
         pattern = line_split
     match = pattern.match(line)
     if not match:
         #print "match failed for line '%s'" % line
         try:
             iFun,theRest = line.split(None,1)
         except ValueError:
             #print "split failed for line '%s'" % line
             iFun,theRest = line,''
         pre = re.match('^(\s*)(.*)',line).groups()[0]
     else:
         pre,iFun,theRest = match.groups()
 
     # iFun has to be a valid python identifier, so it better be only pure
     # ascii, no unicode:
     try:
         iFun = iFun.encode('ascii')
     except UnicodeEncodeError:
         theRest = iFun + u' ' + theRest
         iFun = u''
 
     #print 'line:<%s>' % line # dbg
     #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
-    return pre,iFun.strip(),theRest
+    return pre,iFun.strip(),theRest.lstrip()
 
 
 # RegExp for splitting line contents into pre-char//first word-method//rest.
 # For clarity, each group in on one line.
 
 # WARNING: update the regexp if the escapes in iplib are changed, as they
 # are hardwired in.
 
 # Although it's not solely driven by the regex, note that:
 # ,;/% only trigger if they are the first character on the line
 # ! and !! trigger if they are first char(s) *or* follow an indent 
 # ? triggers as first or last char.
 
 # The three parts of the regex are:
 #  1) pre:     pre_char *or* initial whitespace 
 #  2) iFun:    first word/method (mix of \w and '.')
-#  3) theRest: rest of line
+#  3) theRest: rest of line (separated from iFun by space if non-empty)
 line_split = re.compile(r'^([,;/%?]|!!?|\s*)'
-                        r'\s*([\w\.]+)\s*'
-                        r'(.*)$')
+                        r'\s*([\w\.]+)'
+                        r'(\s+.*$|$)')
 
 shell_line_split = re.compile(r'^(\s*)(\S*\s*)(.*$)')
 
 def prefilter(line_info, ip):
     """Call one of the passed-in InteractiveShell's handler preprocessors,
     depending on the form of the line.  Return the results, which must be a
     value, even if it's a blank ('')."""
     # Note: the order of these checks does matter. 
     for check in [ checkEmacs,
                    checkIPyAutocall,
                    checkMultiLineShell,
                    checkEscChars,
                    checkAssignment,
                    checkAutomagic,
                    checkAlias,
                    checkPythonOps,
                    checkAutocall,
                    ]:
         handler = check(line_info, ip)
         if handler:
             return handler(line_info)
 
     return ip.handle_normal(line_info)
 
 # Handler checks
 #
 # All have the same interface: they take a LineInfo object and a ref to the
 # iplib.InteractiveShell object.  They check the line to see if a particular
 # handler should be called, and return either a handler or None.  The
 # handlers which they return are *bound* methods of the InteractiveShell
 # object. 
 #
 # In general, these checks should only take responsibility for their 'own'
 # handler.  If it doesn't get triggered, they should just return None and
 # let the rest of the check sequence run.
 def checkEmacs(l_info,ip):
     "Emacs ipython-mode tags certain input lines."
     if l_info.line.endswith('# PYTHON-MODE'):
         return ip.handle_emacs
     else:
         return None
 
 def checkIPyAutocall(l_info,ip):
     "Instances of IPyAutocall in user_ns get autocalled immediately"
     obj = ip.user_ns.get(l_info.iFun, None)
     if isinstance(obj, IPython.ipapi.IPyAutocall):
         obj.set_ip(ip.api)
         return ip.handle_auto
     else:
         return None
     
     
 def checkMultiLineShell(l_info,ip):
     "Allow ! and !! in multi-line statements if multi_line_specials is on"
     # Note that this one of the only places we check the first character of
     # iFun and *not* the preChar.  Also note that the below test matches
     # both ! and !!.
     if l_info.continue_prompt \
            and ip.rc.multi_line_specials \
            and l_info.iFun.startswith(ip.ESC_SHELL):
         return ip.handle_shell_escape
     else:
         return None
 
 def checkEscChars(l_info,ip):
     """Check for escape character and return either a handler to handle it,
     or None if there is no escape char."""
     if l_info.line[-1] == ip.ESC_HELP \
            and l_info.preChar != ip.ESC_SHELL \
            and l_info.preChar != ip.ESC_SH_CAP:
         # the ? can be at the end, but *not* for either kind of shell escape,
         # because a ? can be a vaild final char in a shell cmd
         return ip.handle_help
     elif l_info.preChar in ip.esc_handlers:
         return ip.esc_handlers[l_info.preChar]
     else:
         return None
 
 
 def checkAssignment(l_info,ip):
     """Check to see if user is assigning to a var for the first time, in
     which case we want to avoid any sort of automagic / autocall games.
     
     This allows users to assign to either alias or magic names true python
     variables (the magic/alias systems always take second seat to true
     python code).  E.g. ls='hi', or ls,that=1,2"""
     if l_info.theRest and l_info.theRest[0] in '=,':
         return ip.handle_normal
     else:
         return None
 
 
 def checkAutomagic(l_info,ip):
     """If the iFun is magic, and automagic is on, run it.  Note: normal,
     non-auto magic would already have been triggered via '%' in
     check_esc_chars. This just checks for automagic.  Also, before
     triggering the magic handler, make sure that there is nothing in the
     user namespace which could shadow it."""
     if not ip.rc.automagic or not hasattr(ip,'magic_'+l_info.iFun):
         return None
 
     # We have a likely magic method.  Make sure we should actually call it.
     if l_info.continue_prompt and not ip.rc.multi_line_specials:
         return None
 
     head = l_info.iFun.split('.',1)[0]
     if isShadowed(head,ip):
         return None
 
     return ip.handle_magic
 
         
 def checkAlias(l_info,ip):
     "Check if the initital identifier on the line is an alias."
     # Note: aliases can not contain '.'
     head = l_info.iFun.split('.',1)[0]
     
     if l_info.iFun not in ip.alias_table \
            or head not in ip.alias_table \
            or isShadowed(head,ip): 
         return None
 
     return ip.handle_alias
 
 
 def checkPythonOps(l_info,ip):
     """If the 'rest' of the line begins with a function call or pretty much
     any python operator, we should simply execute the line (regardless of
     whether or not there's a possible autocall expansion).  This avoids
     spurious (and very confusing) geattr() accesses."""
     if l_info.theRest and l_info.theRest[0] in '!=()<>,+*/%^&|':
         return ip.handle_normal
     else:
         return None
 
 
 def checkAutocall(l_info,ip):
     "Check if the initial word/function is callable and autocall is on."
     if not ip.rc.autocall:
         return None
 
     oinfo = l_info.ofind(ip) # This can mutate state via getattr
     if not oinfo['found']:
         return None
         
     if callable(oinfo['obj']) \
            and (not re_exclude_auto.match(l_info.theRest)) \
            and re_fun_name.match(l_info.iFun):
         #print 'going auto'  # dbg
         return ip.handle_auto
     else:
         #print 'was callable?', callable(l_info.oinfo['obj'])  # dbg
         return None
     
 # RegExp to identify potential function names
 re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
 
 # RegExp to exclude strings with this start from autocalling.  In
 # particular, all binary operators should be excluded, so that if foo is
 # callable, foo OP bar doesn't become foo(OP bar), which is invalid.  The
 # characters '!=()' don't need to be checked for, as the checkPythonChars
 # routine explicitely does so, to catch direct calls and rebindings of
 # existing names.
 
 # Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
 # it affects the rest of the group in square brackets.
 re_exclude_auto = re.compile(r'^[,&^\|\*/\+-]'
                              r'|^is |^not |^in |^and |^or ')
 
 # try to catch also methods for stuff in lists/tuples/dicts: off
 # (experimental). For this to work, the line_split regexp would need
 # to be modified so it wouldn't break things at '['. That line is
 # nasty enough that I shouldn't change it until I can test it _well_.
 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
 
 # Handler Check Utilities
 def isShadowed(identifier,ip):
     """Is the given identifier defined in one of the namespaces which shadow
     the alias and magic namespaces?  Note that an identifier is different
     than iFun, because it can not contain a '.' character."""
     # This is much safer than calling ofind, which can change state
     return (identifier in ip.user_ns \
             or identifier in ip.internal_ns \
             or identifier in ip.ns_table['builtin'])
 

test/test_handlers.py

@@ -1,201 +1,202 b''
 """Test the various handlers which do the actual rewriting of the line."""
 
 from StringIO import StringIO
 import sys
 sys.path.append('..')
 
 failures = []
 num_tests = 0
 
 def run(tests):
     """Loop through a list of (pre, post) inputs, where pre is the string
     handed to ipython, and post is how that string looks after it's been
     transformed (i.e. ipython's notion of _i)"""
     for pre, post in tests:
         global num_tests
         num_tests += 1        
         ip.runlines(pre)
         ip.runlines('_i')  # Not sure why I need this...
         actual = ip.user_ns['_i']
-        if actual != None: actual = actual.rstrip('\n')
+        if actual != None:
+            actual = actual.rstrip('\n')
         if actual != post:
             failures.append('Expected %r to become %r, found %r' % (
                 pre, post, actual))
 
 
 # Shutdown stdout/stderr so that ipython isn't noisy during tests.  Have to
 # do this *before* importing IPython below.
 #
 # NOTE: this means that, if you stick print statements into code as part of
 # debugging, you won't see the results (unless you comment out some of the
 # below).  I keep on doing this, so apparently it's easy.  Or I am an idiot.
 old_stdout = sys.stdout
 old_stderr = sys.stderr
 
 sys.stdout = StringIO()
 sys.stderr = StringIO()
 
 import IPython
 import IPython.ipapi
 
 IPython.Shell.start()
 ip = IPython.ipapi.get()
 
 class CallableIndexable(object):
     def __getitem__(self, idx): return True
     def __call__(self, *args, **kws): return True
 
     
 try:
     # alias expansion
     
     # We're using 'true' as our syscall of choice because it doesn't
     # write anything to stdout.
 
     # Turn off actual execution of aliases, because it's noisy
-    old_system_cmd = ip.IP.system
-    ip.IP.system = lambda cmd: None
+    old_system_cmd = ip.system
+    ip.system = lambda cmd: None
     
     
     ip.IP.alias_table['an_alias'] = (0, 'true')
     # These are useful for checking a particular recursive alias issue
     ip.IP.alias_table['top'] = (0, 'd:/cygwin/top')
     ip.IP.alias_table['d'] =   (0, 'true')
     run([("an_alias",    '_ip.system("true ")'),     # alias
          # Below: recursive aliases should expand whitespace-surrounded
          # chars, *not* initial chars which happen to be aliases:
          ("top",         '_ip.system("d:/cygwin/top ")'),
          ])
-    ip.IP.system = old_system_cmd
+    ip.system = old_system_cmd
 
 
     call_idx = CallableIndexable()
     ip.to_user_ns('call_idx')
 
     # For many of the below, we're also checking that leading whitespace
     # turns off the esc char, which it should unless there is a continuation
     # line.
     run([('"no change"', '"no change"'),             # normal
          ("!true",       '_ip.system("true")'),      # shell_escapes
          ("!! true",     '_ip.magic("sx  true")'),   # shell_escapes + magic
          ("!!true",      '_ip.magic("sx true")'),    # shell_escapes + magic
          ("%lsmagic",    '_ip.magic("lsmagic ")'),   # magic
          ("lsmagic",     '_ip.magic("lsmagic ")'),   # magic
          ("a = b # PYTHON-MODE", '_i'),          # emacs -- avoids _in cache
 
          # post-esc-char whitespace goes inside
          ("! true",   '_ip.system(" true")'),  
 
          # Leading whitespace generally turns off escape characters
          (" ! true",     ' ! true'),  
          (" !true",      ' !true'),  
 
          # handle_help
 
          # These are weak tests -- just looking at what the help handlers
          # logs, which is not how it really does its work.  But it still
          # lets us check the key paths through the handler.
         
          ("x=1 # what?", "x=1 # what?"), # no help if valid python
          ("len?",  "#?len"),             # this is what help logs when it runs
          ("len??", "#?len?"),                           
          ("?len",  "#?len"),                            
          ])
 
     # multi_line_specials
     ip.options.multi_line_specials = 0
     # W/ multi_line_specials off, leading ws kills esc chars/autoexpansion
     run([
         ('if 1:\n    !true',    'if 1:\n    !true'),
         ('if 1:\n    lsmagic',  'if 1:\n    lsmagic'),
         ('if 1:\n    an_alias', 'if 1:\n    an_alias'),
         ])
 
     ip.options.multi_line_specials = 1
     # initial indents must be preserved.
     run([
          ('if 1:\n    !true',    'if 1:\n    _ip.system("true")'),
          ('if 1:\n    lsmagic',  'if 1:\n    _ip.magic("lsmagic ")'),
          ('if 1:\n    an_alias', 'if 1:\n    _ip.system("true ")'),
          # Weird one
          ('if 1:\n    !!true',   'if 1:\n    _ip.magic("sx true")'),
          
 
          # Even with m_l_s on, all esc_chars except ! are off
          ('if 1:\n    %lsmagic', 'if 1:\n    %lsmagic'),
          ('if 1:\n    /fun 1 2', 'if 1:\n    /fun 1 2'), 
          ('if 1:\n    ;fun 1 2', 'if 1:\n    ;fun 1 2'),
          ('if 1:\n    ,fun 1 2', 'if 1:\n    ,fun 1 2'),
          ('if 1:\n    ?fun 1 2', 'if 1:\n    ?fun 1 2'),
          # What about !!  
          ])
 
          
     # Objects which are instances of IPyAutocall are *always* autocalled
     import IPython.ipapi
     class Autocallable(IPython.ipapi.IPyAutocall):
         def __call__(self):
             return "called"
     
     autocallable = Autocallable()
     ip.to_user_ns('autocallable')
 
     # auto 
     ip.options.autocall = 0
     # Only explicit escapes or instances of IPyAutocallable should get
     # expanded
     run([
         ('len "abc"',       'len "abc"'),        
         ('autocallable',    'autocallable()'),     
         (",list 1 2 3",     'list("1", "2", "3")'),
         (";list 1 2 3",     'list("1 2 3")'),      
         ("/len range(1,4)", 'len(range(1,4))'),
         ])
     ip.options.autocall = 1
     run([
         (",list 1 2 3", 'list("1", "2", "3")'),
         (";list 1 2 3", 'list("1 2 3")'),      
         ("/len range(1,4)", 'len(range(1,4))'),
         ('len "abc"', 'len("abc")'),
         ('len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
         # Autocall is turned off if first arg is [] and the object
         # is both callable and indexable.  Like so:
         ('len [1,2]', 'len([1,2])'),      # len doesn't support __getitem__...
         ('call_idx [1]', 'call_idx [1]'), # call_idx *does*..
         ('call_idx 1', 'call_idx(1)'),
         ('len', 'len '), # only at 2 does it auto-call on single args
         ])
 
     ip.options.autocall = 2
     run([
         (",list 1 2 3", 'list("1", "2", "3")'),
         (";list 1 2 3", 'list("1 2 3")'),      
         ("/len range(1,4)", 'len(range(1,4))'),
         ('len "abc"', 'len("abc")'),
         ('len "abc";', 'len("abc");'),
         ('len [1,2]', 'len([1,2])'),   
         ('call_idx [1]', 'call_idx [1]'),
         ('call_idx 1', 'call_idx(1)'),
         # This is what's different:
         ('len', 'len()'), # only at 2 does it auto-call on single args
         ])
     ip.options.autocall = 1
 
     # Ignoring handle_emacs, 'cause it doesn't do anything.
 finally:
     sys.stdout = old_stdout
     sys.stderr = old_stderr
 
 
 
 
 num_f = len(failures)
 #if verbose:
 #    print
 
 
 print "%s tests run, %s failure%s" % (num_tests,
                                       num_f,
                                       num_f != 1 and "s" or "")
 for f in failures:
     print f

test/test_prefilter.py

@@ -1,428 +1,443 b''
 """
 Test which prefilter transformations get called for various input lines.
 Note that this does *not* test the transformations themselves -- it's just
 verifying that a particular combination of, e.g. config options and escape
 chars trigger the proper handle_X transform of the input line.
 
 Usage: run from the command line with *normal* python, not ipython:
 > python test_prefilter.py
 
 Fairly quiet output by default.  Pass in -v to get everyone's favorite dots.
 """
 
 # The prefilter always ends in a call to some self.handle_X method.  We swap
 # all of those out so that we can capture which one was called.
 
 import sys
 sys.path.append('..')
 import IPython
 import IPython.ipapi
 
 verbose = False
 if len(sys.argv) > 1:
     if sys.argv[1] == '-v':
         sys.argv = sys.argv[:-1]  # IPython is confused by -v, apparently
         verbose = True
     
 IPython.Shell.start()
 
 ip = IPython.ipapi.get()
 
 # Collect failed tests + stats and print them at the end
 failures = []
 num_tests = 0
 
 # Store the results in module vars as we go
 last_line      = None
 handler_called = None
 def install_mock_handler(name):
     """Swap out one of the IP.handle_x methods with a function which can
     record which handler was called and what line was produced. The mock
     handler func always returns '', which causes ipython to cease handling
     the string immediately.  That way, that it doesn't echo output, raise
     exceptions, etc.  But do note that testing multiline strings thus gets
     a bit hard."""    
     def mock_handler(self, line, continue_prompt=None,
                      pre=None,iFun=None,theRest=None,
                      obj=None):
         #print "Inside %s with '%s'" % (name, line)
         global last_line, handler_called
         last_line = line
         handler_called = name
         return ''
     mock_handler.name = name
     setattr(IPython.iplib.InteractiveShell, name, mock_handler)
 
 install_mock_handler('handle_normal')
 install_mock_handler('handle_auto')
 install_mock_handler('handle_magic')
 install_mock_handler('handle_help')
 install_mock_handler('handle_shell_escape')
 install_mock_handler('handle_alias')
 install_mock_handler('handle_emacs')
 
 
 def reset_esc_handlers():
     """The escape handlers are stored in a hash (as an attribute of the
     InteractiveShell *instance*), so we have to rebuild that hash to get our
     new handlers in there."""
     s = ip.IP
     s.esc_handlers = {s.ESC_PAREN  : s.handle_auto,
                       s.ESC_QUOTE  : s.handle_auto,
                       s.ESC_QUOTE2 : s.handle_auto,
                       s.ESC_MAGIC  : s.handle_magic,
                       s.ESC_HELP   : s.handle_help,
                       s.ESC_SHELL  : s.handle_shell_escape,
                       s.ESC_SH_CAP : s.handle_shell_escape,
                       }
 reset_esc_handlers()
     
 # This is so I don't have to quote over and over.  Gotta be a better way.
 handle_normal       = 'handle_normal'
 handle_auto         = 'handle_auto'
 handle_magic        = 'handle_magic'
 handle_help         = 'handle_help'
 handle_shell_escape = 'handle_shell_escape'
 handle_alias        = 'handle_alias'
 handle_emacs        = 'handle_emacs'
 
 def check(assertion, failure_msg):
     """Check a boolean assertion and fail with a message if necessary. Store
     an error essage in module-level failures list in case of failure.  Print
     '.' or 'F' if module var Verbose is true.
     """
     global num_tests
     num_tests += 1
     if assertion:
         if verbose:
             sys.stdout.write('.')
             sys.stdout.flush()        
     else:
         if verbose:
             sys.stdout.write('F')
             sys.stdout.flush()
         failures.append(failure_msg)
     
 
 def check_handler(expected_handler, line):
     """Verify that the expected hander was called (for the given line,
     passed in for failure reporting).
     
     Pulled out to its own function so that tests which don't use
     run_handler_tests can still take advantage of it."""
     check(handler_called == expected_handler,
           "Expected %s to be called for %s, "
           "instead %s called" % (expected_handler,
                                  repr(line),
                                  handler_called))
     
 
 def run_handler_tests(h_tests):
     """Loop through a series of (input_line, handler_name) pairs, verifying
     that, for each ip calls the given handler for the given line. 
 
     The verbose complaint includes the line passed in, so if that line can
     include enough info to find the error, the tests are modestly
     self-documenting.
     """    
     for ln, expected_handler in h_tests:
         global handler_called
         handler_called = None
         ip.runlines(ln)
         check_handler(expected_handler, ln)
 
 def run_one_test(ln, expected_handler):
     run_handler_tests([(ln, expected_handler)])
     
 
 # =========================================
 # Tests
 # =========================================
 
 
 # Fundamental escape characters + whitespace & misc
 # =================================================
 esc_handler_tests = [
     ( '?thing',    handle_help,  ),
     ( 'thing?',    handle_help ),  # '?' can trail...
     ( 'thing!',    handle_normal), # but only '?' can trail
     ( '   ?thing', handle_normal), # leading whitespace turns off esc chars
     ( '!ls',       handle_shell_escape),
     ( '! true',    handle_shell_escape),
     ( '!! true',   handle_shell_escape),
     ( '%magic',    handle_magic),
     # XXX Possibly, add test for /,; once those are unhooked from %autocall
     ( 'emacs_mode # PYTHON-MODE', handle_emacs ),
     ( ' ',         handle_normal), 
+
     # Trailing qmark combos.  Odd special cases abound
-    ( '!thing?',   handle_shell_escape), # trailing '?' loses to shell esc
-    ( '!thing ?',  handle_shell_escape),
-    ( '!!thing?',  handle_shell_escape),
+
+    # The key is: we don't want the trailing ? to trigger help if it's a
+    # part of a shell glob (like, e.g. '!ls file.?').  Instead, we want the
+    # shell handler to be called.  Due to subtleties of the input string
+    # parsing, however, we only call the shell handler if the trailing ? is
+    # part of something whitespace-separated from the !cmd.  See examples.
+    ( '!thing?',      handle_help), 
+    ( '!thing arg?',  handle_shell_escape),
+    ( '!!thing?',     handle_help),
+    ( '!!thing arg?', handle_shell_escape),
+
+    # For all other leading esc chars, we always trigger help
     ( '%cmd?',     handle_help),
+    ( '%cmd ?',    handle_help),
     ( '/cmd?',     handle_help),
+    ( '/cmd ?',    handle_help),
     ( ';cmd?',     handle_help),
     ( ',cmd?',     handle_help),
     ]
 run_handler_tests(esc_handler_tests)
 
 
 
 # Shell Escapes in Multi-line statements
 # ======================================
 #
 # We can't test this via runlines, since the hacked-over-for-testing
 # handlers all return None, so continue_prompt never becomes true.  Instead
 # we drop into prefilter directly and pass in continue_prompt.
 
 old_mls = ip.options.multi_line_specials
 for ln in [ '    !ls $f multi_line_specials %s',
             '    !!ls $f multi_line_specials %s',  # !! escapes work on mls
             # Trailing ? doesn't trigger help:            
             '    !ls $f multi_line_specials %s ?', 
             '    !!ls $f multi_line_specials %s ?',
             ]:
     ip.options.multi_line_specials = 1
     on_ln = ln % 'on'
     ignore = ip.IP.prefilter(on_ln, continue_prompt=True)
     check_handler(handle_shell_escape, on_ln)
 
     ip.options.multi_line_specials = 0
     off_ln = ln % 'off'
     ignore = ip.IP.prefilter(off_ln, continue_prompt=True)
     check_handler(handle_normal, off_ln)
 
 ip.options.multi_line_specials = old_mls
 
 
 # Automagic
 # =========
 
 # Pick one magic fun and one non_magic fun, make sure both exist
 assert hasattr(ip.IP, "magic_cpaste")
 assert not hasattr(ip.IP, "magic_does_not_exist")
 ip.options.autocall = 0 # gotta have this off to get handle_normal
 ip.options.automagic = 0
 run_handler_tests([
     # Without automagic, only shows up with explicit escape
     ( 'cpaste', handle_normal),
     ( '%cpaste', handle_magic),
     ( '%does_not_exist', handle_magic),
     ])
 ip.options.automagic = 1
 run_handler_tests([
     ( 'cpaste',          handle_magic),
     ( '%cpaste',         handle_magic),
     ( 'does_not_exist',  handle_normal),
     ( '%does_not_exist', handle_magic),
     ( 'cd /',            handle_magic),
     ( 'cd = 2',          handle_normal),
+    ( 'r',               handle_magic),
+    ( 'r thing',         handle_magic),
+    ( 'r"str"',          handle_normal),
     ])
 
 # If next elt starts with anything that could be an assignment, func call,
 # etc, we don't call the magic func, unless explicitly escaped to do so.
 #magic_killing_tests = []
 #for c in list('!=()<>,'):
 #    magic_killing_tests.append(('cpaste %s killed_automagic' % c, handle_normal))
 #    magic_killing_tests.append(('%%cpaste %s escaped_magic' % c,   handle_magic))
 #run_handler_tests(magic_killing_tests)
 
 # magic on indented continuation lines -- on iff multi_line_specials == 1
 ip.options.multi_line_specials = 0
 ln = '    cpaste multi_line off kills magic'
 ignore = ip.IP.prefilter(ln, continue_prompt=True)
 check_handler(handle_normal, ln)
 
 ip.options.multi_line_specials = 1
 ln = '    cpaste multi_line on enables magic'
 ignore = ip.IP.prefilter(ln, continue_prompt=True)
 check_handler(handle_magic, ln)
 
 # user namespace shadows the magic one unless shell escaped
 ip.user_ns['cpaste']     = 'user_ns'
 run_handler_tests([
     ( 'cpaste',    handle_normal),
     ( '%cpaste',   handle_magic)])
 del ip.user_ns['cpaste']
 
 
 
 # Check for !=() turning off .ofind
 # =================================
 class AttributeMutator(object):
     """A class which will be modified on attribute access, to test ofind"""
     def __init__(self):
         self.called = False
 
     def getFoo(self): self.called = True
     foo = property(getFoo)
 
 attr_mutator = AttributeMutator()
 ip.to_user_ns('attr_mutator')
 
 ip.options.autocall = 1 
 
 run_one_test('attr_mutator.foo should mutate', handle_normal)
 check(attr_mutator.called, 'ofind should be called in absence of assign characters')
 
 for c in list('!=()<>+*/%^&|'): 
     attr_mutator.called = False
     run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal)
     run_one_test('attr_mutator.foo%s should *not* mutate' % c, handle_normal)
     
     check(not attr_mutator.called,
           'ofind should not be called near character %s' % c)
 
 
 
 # Alias expansion
 # ===============
 
 # With autocall on or off, aliases should be shadowed by user, internal and
 # __builtin__ namespaces
 #
 # XXX Can aliases have '.' in their name?  With autocall off, that works,
 # with autocall on, it doesn't.  Hmmm.
 import __builtin__
 for ac_state in [0,1]:
     ip.options.autocall = ac_state
     ip.IP.alias_table['alias_cmd'] = 'alias_result'
     ip.IP.alias_table['alias_head.with_dot'] = 'alias_result'
     run_handler_tests([
         ("alias_cmd",           handle_alias),
         # XXX See note above
         #("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias), 
         ("alias_cmd.something aliases must match whole expr", handle_normal),
         ("alias_cmd /", handle_alias),
         ])
 
     for ns in [ip.user_ns, ip.IP.internal_ns, __builtin__.__dict__ ]:
         ns['alias_cmd'] = 'a user value'
         ns['alias_head'] = 'a user value'
         run_handler_tests([
             ("alias_cmd",           handle_normal),
             ("alias_head.with_dot", handle_normal)])
         del ns['alias_cmd']
         del ns['alias_head']
 
 ip.options.autocall = 1
 
 
 
 
 # Autocall
 # ========
 
 # For all the tests below, 'len' is callable / 'thing' is not
 
 # Objects which are instances of IPyAutocall are *always* autocalled
 import IPython.ipapi
 class Autocallable(IPython.ipapi.IPyAutocall):
     def __call__(self):
         return "called"
     
 autocallable = Autocallable()
 ip.to_user_ns('autocallable')
 
 
 # First, with autocalling fully off
 ip.options.autocall = 0
 run_handler_tests( [
     # With no escapes, no autocalling expansions happen, callable or not,
     # unless the obj extends IPyAutocall
     ( 'len autocall_0',     handle_normal),
     ( 'thing autocall_0',   handle_normal),
     ( 'autocallable',       handle_auto),
     
     # With explicit escapes, callable and non-callables both get expanded,
     # regardless of the %autocall setting:
     ( '/len autocall_0',    handle_auto),
     ( ',len autocall_0 b0', handle_auto),
     ( ';len autocall_0 b0', handle_auto),
     
     ( '/thing autocall_0',    handle_auto),
     ( ',thing autocall_0 b0', handle_auto),
     ( ';thing autocall_0 b0', handle_auto),
 
     # Explicit autocall should not trigger if there is leading whitespace
     ( ' /len autocall_0',    handle_normal),
     ( ' ;len autocall_0',    handle_normal),
     ( ' ,len autocall_0',    handle_normal),
     ( ' / len autocall_0',   handle_normal),
 
     # But should work if the whitespace comes after the esc char
     ( '/ len autocall_0',    handle_auto),
     ( '; len autocall_0',    handle_auto),
     ( ', len autocall_0',    handle_auto),
     ( '/  len autocall_0',   handle_auto),
     ])
 
 
 # Now, with autocall in default, 'smart' mode
 ip.options.autocall = 1 
 run_handler_tests( [
     # Autocalls without escapes -- only expand if it's callable
     ( 'len a1',       handle_auto),
     ( 'thing a1',     handle_normal),
     ( 'autocallable', handle_auto),
 
     # As above, all explicit escapes generate auto-calls, callable or not
     ( '/len a1',      handle_auto),
     ( ',len a1 b1',   handle_auto),
     ( ';len a1 b1',   handle_auto),
     ( '/thing a1',    handle_auto),
     ( ',thing a1 b1', handle_auto),
     ( ';thing a1 b1', handle_auto),
 
     # Autocalls only happen on things which look like funcs, even if
     # explicitly requested. Which, in this case means they look like a
     # sequence of identifiers and . attribute references. Possibly the
     # second of these two should trigger handle_auto.  But not for now.
     ( '"abc".join range(4)',   handle_normal),
     ( '/"abc".join range(4)',  handle_normal),
     ])
 
 
 # No tests for autocall = 2, since the extra magic there happens inside the
 # handle_auto function, which our test doesn't examine.
 
 # Note that we leave autocall in default, 1, 'smart' mode
 
 
 # Autocall / Binary operators
 # ==========================
 
 # Even with autocall on, 'len in thing' won't transform.
 # But ';len in thing' will
 
 # Note, the tests below don't check for multi-char ops. It could.
 
 # XXX % is a binary op and should be in the list, too, but fails
 bin_ops = list(r'<>,&^|*/+-') + 'is not in and or'.split()
 bin_tests = []
 for b in bin_ops:
     bin_tests.append(('len %s binop_autocall'  % b, handle_normal))
     bin_tests.append((';len %s binop_autocall' % b, handle_auto))
     bin_tests.append((',len %s binop_autocall' % b, handle_auto))
     bin_tests.append(('/len %s binop_autocall' % b, handle_auto))
     
 # Who loves auto-generating tests? 
 run_handler_tests(bin_tests)
 
 
 # Possibly add tests for namespace shadowing (really ofind's business?).
 #
 # user > ipython internal > python builtin > alias > magic
 
 
 # ============
 # Test Summary
 # ============
 num_f = len(failures)
 if verbose:
     print 
 print "%s tests run, %s failure%s" % (num_tests,
                                       num_f,
                                       num_f != 1 and "s" or "")
 for f in failures:
     print f