|
|
"""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 != 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.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.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
|
|
|
|
