##// END OF EJS Templates
alias completer works in indented lines now
vivainio -
Show More
@@ -1,673 +1,673 b''
1 """Word completion for IPython.
1 """Word completion for IPython.
2
2
3 This module is a fork of the rlcompleter module in the Python standard
3 This module is a fork of the rlcompleter module in the Python standard
4 library. The original enhancements made to rlcompleter have been sent
4 library. The original enhancements made to rlcompleter have been sent
5 upstream and were accepted as of Python 2.3, but we need a lot more
5 upstream and were accepted as of Python 2.3, but we need a lot more
6 functionality specific to IPython, so this module will continue to live as an
6 functionality specific to IPython, so this module will continue to live as an
7 IPython-specific utility.
7 IPython-specific utility.
8
8
9 ---------------------------------------------------------------------------
9 ---------------------------------------------------------------------------
10 Original rlcompleter documentation:
10 Original rlcompleter documentation:
11
11
12 This requires the latest extension to the readline module (the
12 This requires the latest extension to the readline module (the
13 completes keywords, built-ins and globals in __main__; when completing
13 completes keywords, built-ins and globals in __main__; when completing
14 NAME.NAME..., it evaluates (!) the expression up to the last dot and
14 NAME.NAME..., it evaluates (!) the expression up to the last dot and
15 completes its attributes.
15 completes its attributes.
16
16
17 It's very cool to do "import string" type "string.", hit the
17 It's very cool to do "import string" type "string.", hit the
18 completion key (twice), and see the list of names defined by the
18 completion key (twice), and see the list of names defined by the
19 string module!
19 string module!
20
20
21 Tip: to use the tab key as the completion key, call
21 Tip: to use the tab key as the completion key, call
22
22
23 readline.parse_and_bind("tab: complete")
23 readline.parse_and_bind("tab: complete")
24
24
25 Notes:
25 Notes:
26
26
27 - Exceptions raised by the completer function are *ignored* (and
27 - Exceptions raised by the completer function are *ignored* (and
28 generally cause the completion to fail). This is a feature -- since
28 generally cause the completion to fail). This is a feature -- since
29 readline sets the tty device in raw (or cbreak) mode, printing a
29 readline sets the tty device in raw (or cbreak) mode, printing a
30 traceback wouldn't work well without some complicated hoopla to save,
30 traceback wouldn't work well without some complicated hoopla to save,
31 reset and restore the tty state.
31 reset and restore the tty state.
32
32
33 - The evaluation of the NAME.NAME... form may cause arbitrary
33 - The evaluation of the NAME.NAME... form may cause arbitrary
34 application defined code to be executed if an object with a
34 application defined code to be executed if an object with a
35 __getattr__ hook is found. Since it is the responsibility of the
35 __getattr__ hook is found. Since it is the responsibility of the
36 application (or the user) to enable this feature, I consider this an
36 application (or the user) to enable this feature, I consider this an
37 acceptable risk. More complicated expressions (e.g. function calls or
37 acceptable risk. More complicated expressions (e.g. function calls or
38 indexing operations) are *not* evaluated.
38 indexing operations) are *not* evaluated.
39
39
40 - GNU readline is also used by the built-in functions input() and
40 - GNU readline is also used by the built-in functions input() and
41 raw_input(), and thus these also benefit/suffer from the completer
41 raw_input(), and thus these also benefit/suffer from the completer
42 features. Clearly an interactive application can benefit by
42 features. Clearly an interactive application can benefit by
43 specifying its own completer function and using raw_input() for all
43 specifying its own completer function and using raw_input() for all
44 its input.
44 its input.
45
45
46 - When the original stdin is not a tty device, GNU readline is never
46 - When the original stdin is not a tty device, GNU readline is never
47 used, and this module (and the readline module) are silently inactive.
47 used, and this module (and the readline module) are silently inactive.
48
48
49 """
49 """
50
50
51 #*****************************************************************************
51 #*****************************************************************************
52 #
52 #
53 # Since this file is essentially a minimally modified copy of the rlcompleter
53 # Since this file is essentially a minimally modified copy of the rlcompleter
54 # module which is part of the standard Python distribution, I assume that the
54 # module which is part of the standard Python distribution, I assume that the
55 # proper procedure is to maintain its copyright as belonging to the Python
55 # proper procedure is to maintain its copyright as belonging to the Python
56 # Software Foundation (in addition to my own, for all new code).
56 # Software Foundation (in addition to my own, for all new code).
57 #
57 #
58 # Copyright (C) 2001 Python Software Foundation, www.python.org
58 # Copyright (C) 2001 Python Software Foundation, www.python.org
59 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
59 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
60 #
60 #
61 # Distributed under the terms of the BSD License. The full license is in
61 # Distributed under the terms of the BSD License. The full license is in
62 # the file COPYING, distributed as part of this software.
62 # the file COPYING, distributed as part of this software.
63 #
63 #
64 #*****************************************************************************
64 #*****************************************************************************
65
65
66 import __builtin__
66 import __builtin__
67 import __main__
67 import __main__
68 import glob
68 import glob
69 import keyword
69 import keyword
70 import os
70 import os
71 import re
71 import re
72 import shlex
72 import shlex
73 import sys
73 import sys
74 import IPython.rlineimpl as readline
74 import IPython.rlineimpl as readline
75 import itertools
75 import itertools
76 from IPython.ipstruct import Struct
76 from IPython.ipstruct import Struct
77 from IPython import ipapi
77 from IPython import ipapi
78
78
79 import types
79 import types
80
80
81 # Python 2.4 offers sets as a builtin
81 # Python 2.4 offers sets as a builtin
82 try:
82 try:
83 set([1,2])
83 set([1,2])
84 except NameError:
84 except NameError:
85 from sets import Set as set
85 from sets import Set as set
86
86
87 from IPython.genutils import debugx
87 from IPython.genutils import debugx
88
88
89 __all__ = ['Completer','IPCompleter']
89 __all__ = ['Completer','IPCompleter']
90
90
91 def get_class_members(cls):
91 def get_class_members(cls):
92 ret = dir(cls)
92 ret = dir(cls)
93 if hasattr(cls,'__bases__'):
93 if hasattr(cls,'__bases__'):
94 for base in cls.__bases__:
94 for base in cls.__bases__:
95 ret.extend(get_class_members(base))
95 ret.extend(get_class_members(base))
96 return ret
96 return ret
97
97
98 class Completer:
98 class Completer:
99 def __init__(self,namespace=None,global_namespace=None):
99 def __init__(self,namespace=None,global_namespace=None):
100 """Create a new completer for the command line.
100 """Create a new completer for the command line.
101
101
102 Completer([namespace,global_namespace]) -> completer instance.
102 Completer([namespace,global_namespace]) -> completer instance.
103
103
104 If unspecified, the default namespace where completions are performed
104 If unspecified, the default namespace where completions are performed
105 is __main__ (technically, __main__.__dict__). Namespaces should be
105 is __main__ (technically, __main__.__dict__). Namespaces should be
106 given as dictionaries.
106 given as dictionaries.
107
107
108 An optional second namespace can be given. This allows the completer
108 An optional second namespace can be given. This allows the completer
109 to handle cases where both the local and global scopes need to be
109 to handle cases where both the local and global scopes need to be
110 distinguished.
110 distinguished.
111
111
112 Completer instances should be used as the completion mechanism of
112 Completer instances should be used as the completion mechanism of
113 readline via the set_completer() call:
113 readline via the set_completer() call:
114
114
115 readline.set_completer(Completer(my_namespace).complete)
115 readline.set_completer(Completer(my_namespace).complete)
116 """
116 """
117
117
118 # some minimal strict typechecks. For some core data structures, I
118 # some minimal strict typechecks. For some core data structures, I
119 # want actual basic python types, not just anything that looks like
119 # want actual basic python types, not just anything that looks like
120 # one. This is especially true for namespaces.
120 # one. This is especially true for namespaces.
121 for ns in (namespace,global_namespace):
121 for ns in (namespace,global_namespace):
122 if ns is not None and type(ns) != types.DictType:
122 if ns is not None and type(ns) != types.DictType:
123 raise TypeError,'namespace must be a dictionary'
123 raise TypeError,'namespace must be a dictionary'
124
124
125 # Don't bind to namespace quite yet, but flag whether the user wants a
125 # Don't bind to namespace quite yet, but flag whether the user wants a
126 # specific namespace or to use __main__.__dict__. This will allow us
126 # specific namespace or to use __main__.__dict__. This will allow us
127 # to bind to __main__.__dict__ at completion time, not now.
127 # to bind to __main__.__dict__ at completion time, not now.
128 if namespace is None:
128 if namespace is None:
129 self.use_main_ns = 1
129 self.use_main_ns = 1
130 else:
130 else:
131 self.use_main_ns = 0
131 self.use_main_ns = 0
132 self.namespace = namespace
132 self.namespace = namespace
133
133
134 # The global namespace, if given, can be bound directly
134 # The global namespace, if given, can be bound directly
135 if global_namespace is None:
135 if global_namespace is None:
136 self.global_namespace = {}
136 self.global_namespace = {}
137 else:
137 else:
138 self.global_namespace = global_namespace
138 self.global_namespace = global_namespace
139
139
140 def complete(self, text, state):
140 def complete(self, text, state):
141 """Return the next possible completion for 'text'.
141 """Return the next possible completion for 'text'.
142
142
143 This is called successively with state == 0, 1, 2, ... until it
143 This is called successively with state == 0, 1, 2, ... until it
144 returns None. The completion should begin with 'text'.
144 returns None. The completion should begin with 'text'.
145
145
146 """
146 """
147 if self.use_main_ns:
147 if self.use_main_ns:
148 self.namespace = __main__.__dict__
148 self.namespace = __main__.__dict__
149
149
150 if state == 0:
150 if state == 0:
151 if "." in text:
151 if "." in text:
152 self.matches = self.attr_matches(text)
152 self.matches = self.attr_matches(text)
153 else:
153 else:
154 self.matches = self.global_matches(text)
154 self.matches = self.global_matches(text)
155 try:
155 try:
156 return self.matches[state]
156 return self.matches[state]
157 except IndexError:
157 except IndexError:
158 return None
158 return None
159
159
160 def global_matches(self, text):
160 def global_matches(self, text):
161 """Compute matches when text is a simple name.
161 """Compute matches when text is a simple name.
162
162
163 Return a list of all keywords, built-in functions and names currently
163 Return a list of all keywords, built-in functions and names currently
164 defined in self.namespace or self.global_namespace that match.
164 defined in self.namespace or self.global_namespace that match.
165
165
166 """
166 """
167 matches = []
167 matches = []
168 match_append = matches.append
168 match_append = matches.append
169 n = len(text)
169 n = len(text)
170 for lst in [keyword.kwlist,
170 for lst in [keyword.kwlist,
171 __builtin__.__dict__.keys(),
171 __builtin__.__dict__.keys(),
172 self.namespace.keys(),
172 self.namespace.keys(),
173 self.global_namespace.keys()]:
173 self.global_namespace.keys()]:
174 for word in lst:
174 for word in lst:
175 if word[:n] == text and word != "__builtins__":
175 if word[:n] == text and word != "__builtins__":
176 match_append(word)
176 match_append(word)
177 return matches
177 return matches
178
178
179 def attr_matches(self, text):
179 def attr_matches(self, text):
180 """Compute matches when text contains a dot.
180 """Compute matches when text contains a dot.
181
181
182 Assuming the text is of the form NAME.NAME....[NAME], and is
182 Assuming the text is of the form NAME.NAME....[NAME], and is
183 evaluatable in self.namespace or self.global_namespace, it will be
183 evaluatable in self.namespace or self.global_namespace, it will be
184 evaluated and its attributes (as revealed by dir()) are used as
184 evaluated and its attributes (as revealed by dir()) are used as
185 possible completions. (For class instances, class members are are
185 possible completions. (For class instances, class members are are
186 also considered.)
186 also considered.)
187
187
188 WARNING: this can still invoke arbitrary C code, if an object
188 WARNING: this can still invoke arbitrary C code, if an object
189 with a __getattr__ hook is evaluated.
189 with a __getattr__ hook is evaluated.
190
190
191 """
191 """
192 import re
192 import re
193
193
194 # Another option, seems to work great. Catches things like ''.<tab>
194 # Another option, seems to work great. Catches things like ''.<tab>
195 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
195 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
196
196
197 if not m:
197 if not m:
198 return []
198 return []
199
199
200 expr, attr = m.group(1, 3)
200 expr, attr = m.group(1, 3)
201 try:
201 try:
202 object = eval(expr, self.namespace)
202 object = eval(expr, self.namespace)
203 except:
203 except:
204 try:
204 try:
205 object = eval(expr, self.global_namespace)
205 object = eval(expr, self.global_namespace)
206 except:
206 except:
207 return []
207 return []
208
208
209
209
210 # Start building the attribute list via dir(), and then complete it
210 # Start building the attribute list via dir(), and then complete it
211 # with a few extra special-purpose calls.
211 # with a few extra special-purpose calls.
212 words = dir(object)
212 words = dir(object)
213
213
214 if hasattr(object,'__class__'):
214 if hasattr(object,'__class__'):
215 words.append('__class__')
215 words.append('__class__')
216 words.extend(get_class_members(object.__class__))
216 words.extend(get_class_members(object.__class__))
217
217
218 # Some libraries (such as traits) may introduce duplicates, we want to
218 # Some libraries (such as traits) may introduce duplicates, we want to
219 # track and clean this up if it happens
219 # track and clean this up if it happens
220 may_have_dupes = False
220 may_have_dupes = False
221
221
222 # this is the 'dir' function for objects with Enthought's traits
222 # this is the 'dir' function for objects with Enthought's traits
223 if hasattr(object, 'trait_names'):
223 if hasattr(object, 'trait_names'):
224 try:
224 try:
225 words.extend(object.trait_names())
225 words.extend(object.trait_names())
226 may_have_dupes = True
226 may_have_dupes = True
227 except TypeError:
227 except TypeError:
228 # This will happen if `object` is a class and not an instance.
228 # This will happen if `object` is a class and not an instance.
229 pass
229 pass
230
230
231 # Support for PyCrust-style _getAttributeNames magic method.
231 # Support for PyCrust-style _getAttributeNames magic method.
232 if hasattr(object, '_getAttributeNames'):
232 if hasattr(object, '_getAttributeNames'):
233 try:
233 try:
234 words.extend(object._getAttributeNames())
234 words.extend(object._getAttributeNames())
235 may_have_dupes = True
235 may_have_dupes = True
236 except TypeError:
236 except TypeError:
237 # `object` is a class and not an instance. Ignore
237 # `object` is a class and not an instance. Ignore
238 # this error.
238 # this error.
239 pass
239 pass
240
240
241 if may_have_dupes:
241 if may_have_dupes:
242 # eliminate possible duplicates, as some traits may also
242 # eliminate possible duplicates, as some traits may also
243 # appear as normal attributes in the dir() call.
243 # appear as normal attributes in the dir() call.
244 words = set(words)
244 words = set(words)
245
245
246 # filter out non-string attributes which may be stuffed by dir() calls
246 # filter out non-string attributes which may be stuffed by dir() calls
247 # and poor coding in third-party modules
247 # and poor coding in third-party modules
248 words = [w for w in words
248 words = [w for w in words
249 if isinstance(w, basestring) and w != "__builtins__"]
249 if isinstance(w, basestring) and w != "__builtins__"]
250 # Build match list to return
250 # Build match list to return
251 n = len(attr)
251 n = len(attr)
252 return ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
252 return ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
253
253
254 class IPCompleter(Completer):
254 class IPCompleter(Completer):
255 """Extension of the completer class with IPython-specific features"""
255 """Extension of the completer class with IPython-specific features"""
256
256
257 def __init__(self,shell,namespace=None,global_namespace=None,
257 def __init__(self,shell,namespace=None,global_namespace=None,
258 omit__names=0,alias_table=None):
258 omit__names=0,alias_table=None):
259 """IPCompleter() -> completer
259 """IPCompleter() -> completer
260
260
261 Return a completer object suitable for use by the readline library
261 Return a completer object suitable for use by the readline library
262 via readline.set_completer().
262 via readline.set_completer().
263
263
264 Inputs:
264 Inputs:
265
265
266 - shell: a pointer to the ipython shell itself. This is needed
266 - shell: a pointer to the ipython shell itself. This is needed
267 because this completer knows about magic functions, and those can
267 because this completer knows about magic functions, and those can
268 only be accessed via the ipython instance.
268 only be accessed via the ipython instance.
269
269
270 - namespace: an optional dict where completions are performed.
270 - namespace: an optional dict where completions are performed.
271
271
272 - global_namespace: secondary optional dict for completions, to
272 - global_namespace: secondary optional dict for completions, to
273 handle cases (such as IPython embedded inside functions) where
273 handle cases (such as IPython embedded inside functions) where
274 both Python scopes are visible.
274 both Python scopes are visible.
275
275
276 - The optional omit__names parameter sets the completer to omit the
276 - The optional omit__names parameter sets the completer to omit the
277 'magic' names (__magicname__) for python objects unless the text
277 'magic' names (__magicname__) for python objects unless the text
278 to be completed explicitly starts with one or more underscores.
278 to be completed explicitly starts with one or more underscores.
279
279
280 - If alias_table is supplied, it should be a dictionary of aliases
280 - If alias_table is supplied, it should be a dictionary of aliases
281 to complete. """
281 to complete. """
282
282
283 Completer.__init__(self,namespace,global_namespace)
283 Completer.__init__(self,namespace,global_namespace)
284 self.magic_prefix = shell.name+'.magic_'
284 self.magic_prefix = shell.name+'.magic_'
285 self.magic_escape = shell.ESC_MAGIC
285 self.magic_escape = shell.ESC_MAGIC
286 self.readline = readline
286 self.readline = readline
287 delims = self.readline.get_completer_delims()
287 delims = self.readline.get_completer_delims()
288 delims = delims.replace(self.magic_escape,'')
288 delims = delims.replace(self.magic_escape,'')
289 self.readline.set_completer_delims(delims)
289 self.readline.set_completer_delims(delims)
290 self.get_line_buffer = self.readline.get_line_buffer
290 self.get_line_buffer = self.readline.get_line_buffer
291 self.omit__names = omit__names
291 self.omit__names = omit__names
292 self.merge_completions = shell.rc.readline_merge_completions
292 self.merge_completions = shell.rc.readline_merge_completions
293
293
294 if alias_table is None:
294 if alias_table is None:
295 alias_table = {}
295 alias_table = {}
296 self.alias_table = alias_table
296 self.alias_table = alias_table
297 # Regexp to split filenames with spaces in them
297 # Regexp to split filenames with spaces in them
298 self.space_name_re = re.compile(r'([^\\] )')
298 self.space_name_re = re.compile(r'([^\\] )')
299 # Hold a local ref. to glob.glob for speed
299 # Hold a local ref. to glob.glob for speed
300 self.glob = glob.glob
300 self.glob = glob.glob
301
301
302 # Determine if we are running on 'dumb' terminals, like (X)Emacs
302 # Determine if we are running on 'dumb' terminals, like (X)Emacs
303 # buffers, to avoid completion problems.
303 # buffers, to avoid completion problems.
304 term = os.environ.get('TERM','xterm')
304 term = os.environ.get('TERM','xterm')
305 self.dumb_terminal = term in ['dumb','emacs']
305 self.dumb_terminal = term in ['dumb','emacs']
306
306
307 # Special handling of backslashes needed in win32 platforms
307 # Special handling of backslashes needed in win32 platforms
308 if sys.platform == "win32":
308 if sys.platform == "win32":
309 self.clean_glob = self._clean_glob_win32
309 self.clean_glob = self._clean_glob_win32
310 else:
310 else:
311 self.clean_glob = self._clean_glob
311 self.clean_glob = self._clean_glob
312 self.matchers = [self.python_matches,
312 self.matchers = [self.python_matches,
313 self.file_matches,
313 self.file_matches,
314 self.alias_matches,
314 self.alias_matches,
315 self.python_func_kw_matches]
315 self.python_func_kw_matches]
316
316
317 # Code contributed by Alex Schmolck, for ipython/emacs integration
317 # Code contributed by Alex Schmolck, for ipython/emacs integration
318 def all_completions(self, text):
318 def all_completions(self, text):
319 """Return all possible completions for the benefit of emacs."""
319 """Return all possible completions for the benefit of emacs."""
320
320
321 completions = []
321 completions = []
322 comp_append = completions.append
322 comp_append = completions.append
323 try:
323 try:
324 for i in xrange(sys.maxint):
324 for i in xrange(sys.maxint):
325 res = self.complete(text, i)
325 res = self.complete(text, i)
326
326
327 if not res: break
327 if not res: break
328
328
329 comp_append(res)
329 comp_append(res)
330 #XXX workaround for ``notDefined.<tab>``
330 #XXX workaround for ``notDefined.<tab>``
331 except NameError:
331 except NameError:
332 pass
332 pass
333 return completions
333 return completions
334 # /end Alex Schmolck code.
334 # /end Alex Schmolck code.
335
335
336 def _clean_glob(self,text):
336 def _clean_glob(self,text):
337 return self.glob("%s*" % text)
337 return self.glob("%s*" % text)
338
338
339 def _clean_glob_win32(self,text):
339 def _clean_glob_win32(self,text):
340 return [f.replace("\\","/")
340 return [f.replace("\\","/")
341 for f in self.glob("%s*" % text)]
341 for f in self.glob("%s*" % text)]
342
342
343 def file_matches(self, text):
343 def file_matches(self, text):
344 """Match filenames, expanding ~USER type strings.
344 """Match filenames, expanding ~USER type strings.
345
345
346 Most of the seemingly convoluted logic in this completer is an
346 Most of the seemingly convoluted logic in this completer is an
347 attempt to handle filenames with spaces in them. And yet it's not
347 attempt to handle filenames with spaces in them. And yet it's not
348 quite perfect, because Python's readline doesn't expose all of the
348 quite perfect, because Python's readline doesn't expose all of the
349 GNU readline details needed for this to be done correctly.
349 GNU readline details needed for this to be done correctly.
350
350
351 For a filename with a space in it, the printed completions will be
351 For a filename with a space in it, the printed completions will be
352 only the parts after what's already been typed (instead of the
352 only the parts after what's already been typed (instead of the
353 full completions, as is normally done). I don't think with the
353 full completions, as is normally done). I don't think with the
354 current (as of Python 2.3) Python readline it's possible to do
354 current (as of Python 2.3) Python readline it's possible to do
355 better."""
355 better."""
356
356
357 #print 'Completer->file_matches: <%s>' % text # dbg
357 #print 'Completer->file_matches: <%s>' % text # dbg
358
358
359 # chars that require escaping with backslash - i.e. chars
359 # chars that require escaping with backslash - i.e. chars
360 # that readline treats incorrectly as delimiters, but we
360 # that readline treats incorrectly as delimiters, but we
361 # don't want to treat as delimiters in filename matching
361 # don't want to treat as delimiters in filename matching
362 # when escaped with backslash
362 # when escaped with backslash
363
363
364 protectables = ' ()[]{}'
364 protectables = ' ()[]{}'
365
365
366 if text.startswith('!'):
366 if text.startswith('!'):
367 text = text[1:]
367 text = text[1:]
368 text_prefix = '!'
368 text_prefix = '!'
369 else:
369 else:
370 text_prefix = ''
370 text_prefix = ''
371
371
372 def protect_filename(s):
372 def protect_filename(s):
373 return "".join([(ch in protectables and '\\' + ch or ch)
373 return "".join([(ch in protectables and '\\' + ch or ch)
374 for ch in s])
374 for ch in s])
375
375
376 def single_dir_expand(matches):
376 def single_dir_expand(matches):
377 "Recursively expand match lists containing a single dir."
377 "Recursively expand match lists containing a single dir."
378
378
379 if len(matches) == 1 and os.path.isdir(matches[0]):
379 if len(matches) == 1 and os.path.isdir(matches[0]):
380 # Takes care of links to directories also. Use '/'
380 # Takes care of links to directories also. Use '/'
381 # explicitly, even under Windows, so that name completions
381 # explicitly, even under Windows, so that name completions
382 # don't end up escaped.
382 # don't end up escaped.
383 d = matches[0]
383 d = matches[0]
384 if d[-1] in ['/','\\']:
384 if d[-1] in ['/','\\']:
385 d = d[:-1]
385 d = d[:-1]
386
386
387 subdirs = os.listdir(d)
387 subdirs = os.listdir(d)
388 if subdirs:
388 if subdirs:
389 matches = [ (d + '/' + p) for p in subdirs]
389 matches = [ (d + '/' + p) for p in subdirs]
390 return single_dir_expand(matches)
390 return single_dir_expand(matches)
391 else:
391 else:
392 return matches
392 return matches
393 else:
393 else:
394 return matches
394 return matches
395
395
396 lbuf = self.lbuf
396 lbuf = self.lbuf
397 open_quotes = 0 # track strings with open quotes
397 open_quotes = 0 # track strings with open quotes
398 try:
398 try:
399 lsplit = shlex.split(lbuf)[-1]
399 lsplit = shlex.split(lbuf)[-1]
400 except ValueError:
400 except ValueError:
401 # typically an unmatched ", or backslash without escaped char.
401 # typically an unmatched ", or backslash without escaped char.
402 if lbuf.count('"')==1:
402 if lbuf.count('"')==1:
403 open_quotes = 1
403 open_quotes = 1
404 lsplit = lbuf.split('"')[-1]
404 lsplit = lbuf.split('"')[-1]
405 elif lbuf.count("'")==1:
405 elif lbuf.count("'")==1:
406 open_quotes = 1
406 open_quotes = 1
407 lsplit = lbuf.split("'")[-1]
407 lsplit = lbuf.split("'")[-1]
408 else:
408 else:
409 return []
409 return []
410 except IndexError:
410 except IndexError:
411 # tab pressed on empty line
411 # tab pressed on empty line
412 lsplit = ""
412 lsplit = ""
413
413
414 if lsplit != protect_filename(lsplit):
414 if lsplit != protect_filename(lsplit):
415 # if protectables are found, do matching on the whole escaped
415 # if protectables are found, do matching on the whole escaped
416 # name
416 # name
417 has_protectables = 1
417 has_protectables = 1
418 text0,text = text,lsplit
418 text0,text = text,lsplit
419 else:
419 else:
420 has_protectables = 0
420 has_protectables = 0
421 text = os.path.expanduser(text)
421 text = os.path.expanduser(text)
422
422
423 if text == "":
423 if text == "":
424 return [text_prefix + protect_filename(f) for f in self.glob("*")]
424 return [text_prefix + protect_filename(f) for f in self.glob("*")]
425
425
426 m0 = self.clean_glob(text.replace('\\',''))
426 m0 = self.clean_glob(text.replace('\\',''))
427 if has_protectables:
427 if has_protectables:
428 # If we had protectables, we need to revert our changes to the
428 # If we had protectables, we need to revert our changes to the
429 # beginning of filename so that we don't double-write the part
429 # beginning of filename so that we don't double-write the part
430 # of the filename we have so far
430 # of the filename we have so far
431 len_lsplit = len(lsplit)
431 len_lsplit = len(lsplit)
432 matches = [text_prefix + text0 +
432 matches = [text_prefix + text0 +
433 protect_filename(f[len_lsplit:]) for f in m0]
433 protect_filename(f[len_lsplit:]) for f in m0]
434 else:
434 else:
435 if open_quotes:
435 if open_quotes:
436 # if we have a string with an open quote, we don't need to
436 # if we have a string with an open quote, we don't need to
437 # protect the names at all (and we _shouldn't_, as it
437 # protect the names at all (and we _shouldn't_, as it
438 # would cause bugs when the filesystem call is made).
438 # would cause bugs when the filesystem call is made).
439 matches = m0
439 matches = m0
440 else:
440 else:
441 matches = [text_prefix +
441 matches = [text_prefix +
442 protect_filename(f) for f in m0]
442 protect_filename(f) for f in m0]
443
443
444 #print 'mm',matches # dbg
444 #print 'mm',matches # dbg
445 return single_dir_expand(matches)
445 return single_dir_expand(matches)
446
446
447 def alias_matches(self, text):
447 def alias_matches(self, text):
448 """Match internal system aliases"""
448 """Match internal system aliases"""
449 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
449 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
450
450
451 # if we are not in the first 'item', alias matching
451 # if we are not in the first 'item', alias matching
452 # doesn't make sense
452 # doesn't make sense
453 if ' ' in self.lbuf:
453 if ' ' in self.lbuf.lstrip():
454 return []
454 return []
455 text = os.path.expanduser(text)
455 text = os.path.expanduser(text)
456 aliases = self.alias_table.keys()
456 aliases = self.alias_table.keys()
457 if text == "":
457 if text == "":
458 return aliases
458 return aliases
459 else:
459 else:
460 return [alias for alias in aliases if alias.startswith(text)]
460 return [alias for alias in aliases if alias.startswith(text)]
461
461
462 def python_matches(self,text):
462 def python_matches(self,text):
463 """Match attributes or global python names"""
463 """Match attributes or global python names"""
464
464
465 #print 'Completer->python_matches, txt=<%s>' % text # dbg
465 #print 'Completer->python_matches, txt=<%s>' % text # dbg
466 if "." in text:
466 if "." in text:
467 try:
467 try:
468 matches = self.attr_matches(text)
468 matches = self.attr_matches(text)
469 if text.endswith('.') and self.omit__names:
469 if text.endswith('.') and self.omit__names:
470 if self.omit__names == 1:
470 if self.omit__names == 1:
471 # true if txt is _not_ a __ name, false otherwise:
471 # true if txt is _not_ a __ name, false otherwise:
472 no__name = (lambda txt:
472 no__name = (lambda txt:
473 re.match(r'.*\.__.*?__',txt) is None)
473 re.match(r'.*\.__.*?__',txt) is None)
474 else:
474 else:
475 # true if txt is _not_ a _ name, false otherwise:
475 # true if txt is _not_ a _ name, false otherwise:
476 no__name = (lambda txt:
476 no__name = (lambda txt:
477 re.match(r'.*\._.*?',txt) is None)
477 re.match(r'.*\._.*?',txt) is None)
478 matches = filter(no__name, matches)
478 matches = filter(no__name, matches)
479 except NameError:
479 except NameError:
480 # catches <undefined attributes>.<tab>
480 # catches <undefined attributes>.<tab>
481 matches = []
481 matches = []
482 else:
482 else:
483 matches = self.global_matches(text)
483 matches = self.global_matches(text)
484 # this is so completion finds magics when automagic is on:
484 # this is so completion finds magics when automagic is on:
485 if (matches == [] and
485 if (matches == [] and
486 not text.startswith(os.sep) and
486 not text.startswith(os.sep) and
487 not ' ' in self.lbuf):
487 not ' ' in self.lbuf):
488 matches = self.attr_matches(self.magic_prefix+text)
488 matches = self.attr_matches(self.magic_prefix+text)
489 return matches
489 return matches
490
490
491 def _default_arguments(self, obj):
491 def _default_arguments(self, obj):
492 """Return the list of default arguments of obj if it is callable,
492 """Return the list of default arguments of obj if it is callable,
493 or empty list otherwise."""
493 or empty list otherwise."""
494
494
495 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
495 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
496 # for classes, check for __init__,__new__
496 # for classes, check for __init__,__new__
497 if inspect.isclass(obj):
497 if inspect.isclass(obj):
498 obj = (getattr(obj,'__init__',None) or
498 obj = (getattr(obj,'__init__',None) or
499 getattr(obj,'__new__',None))
499 getattr(obj,'__new__',None))
500 # for all others, check if they are __call__able
500 # for all others, check if they are __call__able
501 elif hasattr(obj, '__call__'):
501 elif hasattr(obj, '__call__'):
502 obj = obj.__call__
502 obj = obj.__call__
503 # XXX: is there a way to handle the builtins ?
503 # XXX: is there a way to handle the builtins ?
504 try:
504 try:
505 args,_,_1,defaults = inspect.getargspec(obj)
505 args,_,_1,defaults = inspect.getargspec(obj)
506 if defaults:
506 if defaults:
507 return args[-len(defaults):]
507 return args[-len(defaults):]
508 except TypeError: pass
508 except TypeError: pass
509 return []
509 return []
510
510
511 def python_func_kw_matches(self,text):
511 def python_func_kw_matches(self,text):
512 """Match named parameters (kwargs) of the last open function"""
512 """Match named parameters (kwargs) of the last open function"""
513
513
514 if "." in text: # a parameter cannot be dotted
514 if "." in text: # a parameter cannot be dotted
515 return []
515 return []
516 try: regexp = self.__funcParamsRegex
516 try: regexp = self.__funcParamsRegex
517 except AttributeError:
517 except AttributeError:
518 regexp = self.__funcParamsRegex = re.compile(r'''
518 regexp = self.__funcParamsRegex = re.compile(r'''
519 '.*?' | # single quoted strings or
519 '.*?' | # single quoted strings or
520 ".*?" | # double quoted strings or
520 ".*?" | # double quoted strings or
521 \w+ | # identifier
521 \w+ | # identifier
522 \S # other characters
522 \S # other characters
523 ''', re.VERBOSE | re.DOTALL)
523 ''', re.VERBOSE | re.DOTALL)
524 # 1. find the nearest identifier that comes before an unclosed
524 # 1. find the nearest identifier that comes before an unclosed
525 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
525 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
526 tokens = regexp.findall(self.get_line_buffer())
526 tokens = regexp.findall(self.get_line_buffer())
527 tokens.reverse()
527 tokens.reverse()
528 iterTokens = iter(tokens); openPar = 0
528 iterTokens = iter(tokens); openPar = 0
529 for token in iterTokens:
529 for token in iterTokens:
530 if token == ')':
530 if token == ')':
531 openPar -= 1
531 openPar -= 1
532 elif token == '(':
532 elif token == '(':
533 openPar += 1
533 openPar += 1
534 if openPar > 0:
534 if openPar > 0:
535 # found the last unclosed parenthesis
535 # found the last unclosed parenthesis
536 break
536 break
537 else:
537 else:
538 return []
538 return []
539 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
539 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
540 ids = []
540 ids = []
541 isId = re.compile(r'\w+$').match
541 isId = re.compile(r'\w+$').match
542 while True:
542 while True:
543 try:
543 try:
544 ids.append(iterTokens.next())
544 ids.append(iterTokens.next())
545 if not isId(ids[-1]):
545 if not isId(ids[-1]):
546 ids.pop(); break
546 ids.pop(); break
547 if not iterTokens.next() == '.':
547 if not iterTokens.next() == '.':
548 break
548 break
549 except StopIteration:
549 except StopIteration:
550 break
550 break
551 # lookup the candidate callable matches either using global_matches
551 # lookup the candidate callable matches either using global_matches
552 # or attr_matches for dotted names
552 # or attr_matches for dotted names
553 if len(ids) == 1:
553 if len(ids) == 1:
554 callableMatches = self.global_matches(ids[0])
554 callableMatches = self.global_matches(ids[0])
555 else:
555 else:
556 callableMatches = self.attr_matches('.'.join(ids[::-1]))
556 callableMatches = self.attr_matches('.'.join(ids[::-1]))
557 argMatches = []
557 argMatches = []
558 for callableMatch in callableMatches:
558 for callableMatch in callableMatches:
559 try: namedArgs = self._default_arguments(eval(callableMatch,
559 try: namedArgs = self._default_arguments(eval(callableMatch,
560 self.namespace))
560 self.namespace))
561 except: continue
561 except: continue
562 for namedArg in namedArgs:
562 for namedArg in namedArgs:
563 if namedArg.startswith(text):
563 if namedArg.startswith(text):
564 argMatches.append("%s=" %namedArg)
564 argMatches.append("%s=" %namedArg)
565 return argMatches
565 return argMatches
566
566
567 def dispatch_custom_completer(self,text):
567 def dispatch_custom_completer(self,text):
568 # print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
568 # print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
569 line = self.full_lbuf
569 line = self.full_lbuf
570 if not line.strip():
570 if not line.strip():
571 return None
571 return None
572
572
573 event = Struct()
573 event = Struct()
574 event.line = line
574 event.line = line
575 event.symbol = text
575 event.symbol = text
576 cmd = line.split(None,1)[0]
576 cmd = line.split(None,1)[0]
577 event.command = cmd
577 event.command = cmd
578 #print "\ncustom:{%s]\n" % event # dbg
578 #print "\ncustom:{%s]\n" % event # dbg
579
579
580 # for foo etc, try also to find completer for %foo
580 # for foo etc, try also to find completer for %foo
581 if not cmd.startswith(self.magic_escape):
581 if not cmd.startswith(self.magic_escape):
582 try_magic = self.custom_completers.s_matches(
582 try_magic = self.custom_completers.s_matches(
583 self.magic_escape + cmd)
583 self.magic_escape + cmd)
584 else:
584 else:
585 try_magic = []
585 try_magic = []
586
586
587
587
588 for c in itertools.chain(
588 for c in itertools.chain(
589 self.custom_completers.s_matches(cmd),
589 self.custom_completers.s_matches(cmd),
590 try_magic,
590 try_magic,
591 self.custom_completers.flat_matches(self.lbuf)):
591 self.custom_completers.flat_matches(self.lbuf)):
592 # print "try",c # dbg
592 # print "try",c # dbg
593 try:
593 try:
594 res = c(event)
594 res = c(event)
595 return [r for r in res if r.lower().startswith(text.lower())]
595 return [r for r in res if r.lower().startswith(text.lower())]
596 except ipapi.TryNext:
596 except ipapi.TryNext:
597 pass
597 pass
598
598
599 return None
599 return None
600
600
601
601
602 def complete(self, text, state,line_buffer=None):
602 def complete(self, text, state,line_buffer=None):
603 """Return the next possible completion for 'text'.
603 """Return the next possible completion for 'text'.
604
604
605 This is called successively with state == 0, 1, 2, ... until it
605 This is called successively with state == 0, 1, 2, ... until it
606 returns None. The completion should begin with 'text'.
606 returns None. The completion should begin with 'text'.
607
607
608 :Keywords:
608 :Keywords:
609 - line_buffer: string
609 - line_buffer: string
610 If not given, the completer attempts to obtain the current line buffer
610 If not given, the completer attempts to obtain the current line buffer
611 via readline. This keyword allows clients which are requesting for
611 via readline. This keyword allows clients which are requesting for
612 text completions in non-readline contexts to inform the completer of
612 text completions in non-readline contexts to inform the completer of
613 the entire text.
613 the entire text.
614 """
614 """
615
615
616 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
616 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
617
617
618 # if there is only a tab on a line with only whitespace, instead
618 # if there is only a tab on a line with only whitespace, instead
619 # of the mostly useless 'do you want to see all million
619 # of the mostly useless 'do you want to see all million
620 # completions' message, just do the right thing and give the user
620 # completions' message, just do the right thing and give the user
621 # his tab! Incidentally, this enables pasting of tabbed text from
621 # his tab! Incidentally, this enables pasting of tabbed text from
622 # an editor (as long as autoindent is off).
622 # an editor (as long as autoindent is off).
623
623
624 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
624 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
625 # don't interfere with their own tab-completion mechanism.
625 # don't interfere with their own tab-completion mechanism.
626 if line_buffer is None:
626 if line_buffer is None:
627 self.full_lbuf = self.get_line_buffer()
627 self.full_lbuf = self.get_line_buffer()
628 else:
628 else:
629 self.full_lbuf = line_buffer
629 self.full_lbuf = line_buffer
630
630
631 if not (self.dumb_terminal or self.full_lbuf.strip()):
631 if not (self.dumb_terminal or self.full_lbuf.strip()):
632 self.readline.insert_text('\t')
632 self.readline.insert_text('\t')
633 return None
633 return None
634
634
635 magic_escape = self.magic_escape
635 magic_escape = self.magic_escape
636 magic_prefix = self.magic_prefix
636 magic_prefix = self.magic_prefix
637
637
638 self.lbuf = self.full_lbuf[:self.readline.get_endidx()]
638 self.lbuf = self.full_lbuf[:self.readline.get_endidx()]
639
639
640 try:
640 try:
641 if text.startswith(magic_escape):
641 if text.startswith(magic_escape):
642 text = text.replace(magic_escape,magic_prefix)
642 text = text.replace(magic_escape,magic_prefix)
643 elif text.startswith('~'):
643 elif text.startswith('~'):
644 text = os.path.expanduser(text)
644 text = os.path.expanduser(text)
645 if state == 0:
645 if state == 0:
646 custom_res = self.dispatch_custom_completer(text)
646 custom_res = self.dispatch_custom_completer(text)
647 if custom_res is not None:
647 if custom_res is not None:
648 # did custom completers produce something?
648 # did custom completers produce something?
649 self.matches = custom_res
649 self.matches = custom_res
650 else:
650 else:
651 # Extend the list of completions with the results of each
651 # Extend the list of completions with the results of each
652 # matcher, so we return results to the user from all
652 # matcher, so we return results to the user from all
653 # namespaces.
653 # namespaces.
654 if self.merge_completions:
654 if self.merge_completions:
655 self.matches = []
655 self.matches = []
656 for matcher in self.matchers:
656 for matcher in self.matchers:
657 self.matches.extend(matcher(text))
657 self.matches.extend(matcher(text))
658 else:
658 else:
659 for matcher in self.matchers:
659 for matcher in self.matchers:
660 self.matches = matcher(text)
660 self.matches = matcher(text)
661 if self.matches:
661 if self.matches:
662 break
662 break
663
663
664 try:
664 try:
665 return self.matches[state].replace(magic_prefix,magic_escape)
665 return self.matches[state].replace(magic_prefix,magic_escape)
666 except IndexError:
666 except IndexError:
667 return None
667 return None
668 except:
668 except:
669 #from IPython.ultraTB import AutoFormattedTB; # dbg
669 #from IPython.ultraTB import AutoFormattedTB; # dbg
670 #tb=AutoFormattedTB('Verbose');tb() #dbg
670 #tb=AutoFormattedTB('Verbose');tb() #dbg
671
671
672 # If completion fails, don't annoy the user.
672 # If completion fails, don't annoy the user.
673 return None
673 return None
General Comments 0
You need to be logged in to leave comments. Login now