##// END OF EJS Templates
catch all exceptions raised by attr_matches completer for expressions with dots
vivainio -
Show More

The requested changes are too big and content was truncated. Show full diff

@@ -1,629 +1,633 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 object = eval(expr, self.global_namespace)
204 try:
205 object = eval(expr, self.global_namespace)
206 except:
207 return []
208
205
209
206 # Start building the attribute list via dir(), and then complete it
210 # Start building the attribute list via dir(), and then complete it
207 # with a few extra special-purpose calls.
211 # with a few extra special-purpose calls.
208 words = dir(object)
212 words = dir(object)
209
213
210 if hasattr(object,'__class__'):
214 if hasattr(object,'__class__'):
211 words.append('__class__')
215 words.append('__class__')
212 words.extend(get_class_members(object.__class__))
216 words.extend(get_class_members(object.__class__))
213
217
214 # this is the 'dir' function for objects with Enthought's traits
218 # this is the 'dir' function for objects with Enthought's traits
215 if hasattr(object, 'trait_names'):
219 if hasattr(object, 'trait_names'):
216 try:
220 try:
217 words.extend(object.trait_names())
221 words.extend(object.trait_names())
218 # eliminate possible duplicates, as some traits may also
222 # eliminate possible duplicates, as some traits may also
219 # appear as normal attributes in the dir() call.
223 # appear as normal attributes in the dir() call.
220 words = set(words)
224 words = set(words)
221 except TypeError:
225 except TypeError:
222 # This will happen if `object` is a class and not an instance.
226 # This will happen if `object` is a class and not an instance.
223 pass
227 pass
224
228
225 # Support for PyCrust-style _getAttributeNames magic method.
229 # Support for PyCrust-style _getAttributeNames magic method.
226 if hasattr(object, '_getAttributeNames'):
230 if hasattr(object, '_getAttributeNames'):
227 try:
231 try:
228 words.extend(object._getAttributeNames())
232 words.extend(object._getAttributeNames())
229 # Eliminate duplicates.
233 # Eliminate duplicates.
230 words = set(words)
234 words = set(words)
231 except TypeError:
235 except TypeError:
232 # `object` is a class and not an instance. Ignore
236 # `object` is a class and not an instance. Ignore
233 # this error.
237 # this error.
234 pass
238 pass
235
239
236 # filter out non-string attributes which may be stuffed by dir() calls
240 # filter out non-string attributes which may be stuffed by dir() calls
237 # and poor coding in third-party modules
241 # and poor coding in third-party modules
238 words = [w for w in words
242 words = [w for w in words
239 if isinstance(w, basestring) and w != "__builtins__"]
243 if isinstance(w, basestring) and w != "__builtins__"]
240 # Build match list to return
244 # Build match list to return
241 n = len(attr)
245 n = len(attr)
242 return ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
246 return ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
243
247
244 class IPCompleter(Completer):
248 class IPCompleter(Completer):
245 """Extension of the completer class with IPython-specific features"""
249 """Extension of the completer class with IPython-specific features"""
246
250
247 def __init__(self,shell,namespace=None,global_namespace=None,
251 def __init__(self,shell,namespace=None,global_namespace=None,
248 omit__names=0,alias_table=None):
252 omit__names=0,alias_table=None):
249 """IPCompleter() -> completer
253 """IPCompleter() -> completer
250
254
251 Return a completer object suitable for use by the readline library
255 Return a completer object suitable for use by the readline library
252 via readline.set_completer().
256 via readline.set_completer().
253
257
254 Inputs:
258 Inputs:
255
259
256 - shell: a pointer to the ipython shell itself. This is needed
260 - shell: a pointer to the ipython shell itself. This is needed
257 because this completer knows about magic functions, and those can
261 because this completer knows about magic functions, and those can
258 only be accessed via the ipython instance.
262 only be accessed via the ipython instance.
259
263
260 - namespace: an optional dict where completions are performed.
264 - namespace: an optional dict where completions are performed.
261
265
262 - global_namespace: secondary optional dict for completions, to
266 - global_namespace: secondary optional dict for completions, to
263 handle cases (such as IPython embedded inside functions) where
267 handle cases (such as IPython embedded inside functions) where
264 both Python scopes are visible.
268 both Python scopes are visible.
265
269
266 - The optional omit__names parameter sets the completer to omit the
270 - The optional omit__names parameter sets the completer to omit the
267 'magic' names (__magicname__) for python objects unless the text
271 'magic' names (__magicname__) for python objects unless the text
268 to be completed explicitly starts with one or more underscores.
272 to be completed explicitly starts with one or more underscores.
269
273
270 - If alias_table is supplied, it should be a dictionary of aliases
274 - If alias_table is supplied, it should be a dictionary of aliases
271 to complete. """
275 to complete. """
272
276
273 Completer.__init__(self,namespace,global_namespace)
277 Completer.__init__(self,namespace,global_namespace)
274 self.magic_prefix = shell.name+'.magic_'
278 self.magic_prefix = shell.name+'.magic_'
275 self.magic_escape = shell.ESC_MAGIC
279 self.magic_escape = shell.ESC_MAGIC
276 self.readline = readline
280 self.readline = readline
277 delims = self.readline.get_completer_delims()
281 delims = self.readline.get_completer_delims()
278 delims = delims.replace(self.magic_escape,'')
282 delims = delims.replace(self.magic_escape,'')
279 self.readline.set_completer_delims(delims)
283 self.readline.set_completer_delims(delims)
280 self.get_line_buffer = self.readline.get_line_buffer
284 self.get_line_buffer = self.readline.get_line_buffer
281 self.omit__names = omit__names
285 self.omit__names = omit__names
282 self.merge_completions = shell.rc.readline_merge_completions
286 self.merge_completions = shell.rc.readline_merge_completions
283
287
284 if alias_table is None:
288 if alias_table is None:
285 alias_table = {}
289 alias_table = {}
286 self.alias_table = alias_table
290 self.alias_table = alias_table
287 # Regexp to split filenames with spaces in them
291 # Regexp to split filenames with spaces in them
288 self.space_name_re = re.compile(r'([^\\] )')
292 self.space_name_re = re.compile(r'([^\\] )')
289 # Hold a local ref. to glob.glob for speed
293 # Hold a local ref. to glob.glob for speed
290 self.glob = glob.glob
294 self.glob = glob.glob
291
295
292 # Determine if we are running on 'dumb' terminals, like (X)Emacs
296 # Determine if we are running on 'dumb' terminals, like (X)Emacs
293 # buffers, to avoid completion problems.
297 # buffers, to avoid completion problems.
294 term = os.environ.get('TERM','xterm')
298 term = os.environ.get('TERM','xterm')
295 self.dumb_terminal = term in ['dumb','emacs']
299 self.dumb_terminal = term in ['dumb','emacs']
296
300
297 # Special handling of backslashes needed in win32 platforms
301 # Special handling of backslashes needed in win32 platforms
298 if sys.platform == "win32":
302 if sys.platform == "win32":
299 self.clean_glob = self._clean_glob_win32
303 self.clean_glob = self._clean_glob_win32
300 else:
304 else:
301 self.clean_glob = self._clean_glob
305 self.clean_glob = self._clean_glob
302 self.matchers = [self.python_matches,
306 self.matchers = [self.python_matches,
303 self.file_matches,
307 self.file_matches,
304 self.alias_matches,
308 self.alias_matches,
305 self.python_func_kw_matches]
309 self.python_func_kw_matches]
306
310
307 # Code contributed by Alex Schmolck, for ipython/emacs integration
311 # Code contributed by Alex Schmolck, for ipython/emacs integration
308 def all_completions(self, text):
312 def all_completions(self, text):
309 """Return all possible completions for the benefit of emacs."""
313 """Return all possible completions for the benefit of emacs."""
310
314
311 completions = []
315 completions = []
312 comp_append = completions.append
316 comp_append = completions.append
313 try:
317 try:
314 for i in xrange(sys.maxint):
318 for i in xrange(sys.maxint):
315 res = self.complete(text, i)
319 res = self.complete(text, i)
316
320
317 if not res: break
321 if not res: break
318
322
319 comp_append(res)
323 comp_append(res)
320 #XXX workaround for ``notDefined.<tab>``
324 #XXX workaround for ``notDefined.<tab>``
321 except NameError:
325 except NameError:
322 pass
326 pass
323 return completions
327 return completions
324 # /end Alex Schmolck code.
328 # /end Alex Schmolck code.
325
329
326 def _clean_glob(self,text):
330 def _clean_glob(self,text):
327 return self.glob("%s*" % text)
331 return self.glob("%s*" % text)
328
332
329 def _clean_glob_win32(self,text):
333 def _clean_glob_win32(self,text):
330 return [f.replace("\\","/")
334 return [f.replace("\\","/")
331 for f in self.glob("%s*" % text)]
335 for f in self.glob("%s*" % text)]
332
336
333 def file_matches(self, text):
337 def file_matches(self, text):
334 """Match filneames, expanding ~USER type strings.
338 """Match filneames, expanding ~USER type strings.
335
339
336 Most of the seemingly convoluted logic in this completer is an
340 Most of the seemingly convoluted logic in this completer is an
337 attempt to handle filenames with spaces in them. And yet it's not
341 attempt to handle filenames with spaces in them. And yet it's not
338 quite perfect, because Python's readline doesn't expose all of the
342 quite perfect, because Python's readline doesn't expose all of the
339 GNU readline details needed for this to be done correctly.
343 GNU readline details needed for this to be done correctly.
340
344
341 For a filename with a space in it, the printed completions will be
345 For a filename with a space in it, the printed completions will be
342 only the parts after what's already been typed (instead of the
346 only the parts after what's already been typed (instead of the
343 full completions, as is normally done). I don't think with the
347 full completions, as is normally done). I don't think with the
344 current (as of Python 2.3) Python readline it's possible to do
348 current (as of Python 2.3) Python readline it's possible to do
345 better."""
349 better."""
346
350
347 #print 'Completer->file_matches: <%s>' % text # dbg
351 #print 'Completer->file_matches: <%s>' % text # dbg
348
352
349 # chars that require escaping with backslash - i.e. chars
353 # chars that require escaping with backslash - i.e. chars
350 # that readline treats incorrectly as delimiters, but we
354 # that readline treats incorrectly as delimiters, but we
351 # don't want to treat as delimiters in filename matching
355 # don't want to treat as delimiters in filename matching
352 # when escaped with backslash
356 # when escaped with backslash
353
357
354 protectables = ' ()[]{}'
358 protectables = ' ()[]{}'
355
359
356 def protect_filename(s):
360 def protect_filename(s):
357 return "".join([(ch in protectables and '\\' + ch or ch)
361 return "".join([(ch in protectables and '\\' + ch or ch)
358 for ch in s])
362 for ch in s])
359
363
360 lbuf = self.lbuf
364 lbuf = self.lbuf
361 open_quotes = 0 # track strings with open quotes
365 open_quotes = 0 # track strings with open quotes
362 try:
366 try:
363 lsplit = shlex.split(lbuf)[-1]
367 lsplit = shlex.split(lbuf)[-1]
364 except ValueError:
368 except ValueError:
365 # typically an unmatched ", or backslash without escaped char.
369 # typically an unmatched ", or backslash without escaped char.
366 if lbuf.count('"')==1:
370 if lbuf.count('"')==1:
367 open_quotes = 1
371 open_quotes = 1
368 lsplit = lbuf.split('"')[-1]
372 lsplit = lbuf.split('"')[-1]
369 elif lbuf.count("'")==1:
373 elif lbuf.count("'")==1:
370 open_quotes = 1
374 open_quotes = 1
371 lsplit = lbuf.split("'")[-1]
375 lsplit = lbuf.split("'")[-1]
372 else:
376 else:
373 return None
377 return None
374 except IndexError:
378 except IndexError:
375 # tab pressed on empty line
379 # tab pressed on empty line
376 lsplit = ""
380 lsplit = ""
377
381
378 if lsplit != protect_filename(lsplit):
382 if lsplit != protect_filename(lsplit):
379 # if protectables are found, do matching on the whole escaped
383 # if protectables are found, do matching on the whole escaped
380 # name
384 # name
381 has_protectables = 1
385 has_protectables = 1
382 text0,text = text,lsplit
386 text0,text = text,lsplit
383 else:
387 else:
384 has_protectables = 0
388 has_protectables = 0
385 text = os.path.expanduser(text)
389 text = os.path.expanduser(text)
386
390
387 if text == "":
391 if text == "":
388 return [protect_filename(f) for f in self.glob("*")]
392 return [protect_filename(f) for f in self.glob("*")]
389
393
390 m0 = self.clean_glob(text.replace('\\',''))
394 m0 = self.clean_glob(text.replace('\\',''))
391 if has_protectables:
395 if has_protectables:
392 # If we had protectables, we need to revert our changes to the
396 # If we had protectables, we need to revert our changes to the
393 # beginning of filename so that we don't double-write the part
397 # beginning of filename so that we don't double-write the part
394 # of the filename we have so far
398 # of the filename we have so far
395 len_lsplit = len(lsplit)
399 len_lsplit = len(lsplit)
396 matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]
400 matches = [text0 + protect_filename(f[len_lsplit:]) for f in m0]
397 else:
401 else:
398 if open_quotes:
402 if open_quotes:
399 # if we have a string with an open quote, we don't need to
403 # if we have a string with an open quote, we don't need to
400 # protect the names at all (and we _shouldn't_, as it
404 # protect the names at all (and we _shouldn't_, as it
401 # would cause bugs when the filesystem call is made).
405 # would cause bugs when the filesystem call is made).
402 matches = m0
406 matches = m0
403 else:
407 else:
404 matches = [protect_filename(f) for f in m0]
408 matches = [protect_filename(f) for f in m0]
405 if len(matches) == 1 and os.path.isdir(matches[0]):
409 if len(matches) == 1 and os.path.isdir(matches[0]):
406 # Takes care of links to directories also. Use '/'
410 # Takes care of links to directories also. Use '/'
407 # explicitly, even under Windows, so that name completions
411 # explicitly, even under Windows, so that name completions
408 # don't end up escaped.
412 # don't end up escaped.
409 pjoin = os.path.join
413 pjoin = os.path.join
410 d = matches[0]
414 d = matches[0]
411 matches = [ pjoin(d,p) for p in os.listdir(d) ]
415 matches = [ pjoin(d,p) for p in os.listdir(d) ]
412 return matches
416 return matches
413
417
414 def alias_matches(self, text):
418 def alias_matches(self, text):
415 """Match internal system aliases"""
419 """Match internal system aliases"""
416 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
420 #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
417
421
418 # if we are not in the first 'item', alias matching
422 # if we are not in the first 'item', alias matching
419 # doesn't make sense
423 # doesn't make sense
420 if ' ' in self.lbuf:
424 if ' ' in self.lbuf:
421 return []
425 return []
422 text = os.path.expanduser(text)
426 text = os.path.expanduser(text)
423 aliases = self.alias_table.keys()
427 aliases = self.alias_table.keys()
424 if text == "":
428 if text == "":
425 return aliases
429 return aliases
426 else:
430 else:
427 return [alias for alias in aliases if alias.startswith(text)]
431 return [alias for alias in aliases if alias.startswith(text)]
428
432
429 def python_matches(self,text):
433 def python_matches(self,text):
430 """Match attributes or global python names"""
434 """Match attributes or global python names"""
431
435
432 #print 'Completer->python_matches, txt=<%s>' % text # dbg
436 #print 'Completer->python_matches, txt=<%s>' % text # dbg
433 if "." in text:
437 if "." in text:
434 try:
438 try:
435 matches = self.attr_matches(text)
439 matches = self.attr_matches(text)
436 if text.endswith('.') and self.omit__names:
440 if text.endswith('.') and self.omit__names:
437 if self.omit__names == 1:
441 if self.omit__names == 1:
438 # true if txt is _not_ a __ name, false otherwise:
442 # true if txt is _not_ a __ name, false otherwise:
439 no__name = (lambda txt:
443 no__name = (lambda txt:
440 re.match(r'.*\.__.*?__',txt) is None)
444 re.match(r'.*\.__.*?__',txt) is None)
441 else:
445 else:
442 # true if txt is _not_ a _ name, false otherwise:
446 # true if txt is _not_ a _ name, false otherwise:
443 no__name = (lambda txt:
447 no__name = (lambda txt:
444 re.match(r'.*\._.*?',txt) is None)
448 re.match(r'.*\._.*?',txt) is None)
445 matches = filter(no__name, matches)
449 matches = filter(no__name, matches)
446 except NameError:
450 except NameError:
447 # catches <undefined attributes>.<tab>
451 # catches <undefined attributes>.<tab>
448 matches = []
452 matches = []
449 else:
453 else:
450 matches = self.global_matches(text)
454 matches = self.global_matches(text)
451 # this is so completion finds magics when automagic is on:
455 # this is so completion finds magics when automagic is on:
452 if (matches == [] and
456 if (matches == [] and
453 not text.startswith(os.sep) and
457 not text.startswith(os.sep) and
454 not ' ' in self.lbuf):
458 not ' ' in self.lbuf):
455 matches = self.attr_matches(self.magic_prefix+text)
459 matches = self.attr_matches(self.magic_prefix+text)
456 return matches
460 return matches
457
461
458 def _default_arguments(self, obj):
462 def _default_arguments(self, obj):
459 """Return the list of default arguments of obj if it is callable,
463 """Return the list of default arguments of obj if it is callable,
460 or empty list otherwise."""
464 or empty list otherwise."""
461
465
462 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
466 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
463 # for classes, check for __init__,__new__
467 # for classes, check for __init__,__new__
464 if inspect.isclass(obj):
468 if inspect.isclass(obj):
465 obj = (getattr(obj,'__init__',None) or
469 obj = (getattr(obj,'__init__',None) or
466 getattr(obj,'__new__',None))
470 getattr(obj,'__new__',None))
467 # for all others, check if they are __call__able
471 # for all others, check if they are __call__able
468 elif hasattr(obj, '__call__'):
472 elif hasattr(obj, '__call__'):
469 obj = obj.__call__
473 obj = obj.__call__
470 # XXX: is there a way to handle the builtins ?
474 # XXX: is there a way to handle the builtins ?
471 try:
475 try:
472 args,_,_1,defaults = inspect.getargspec(obj)
476 args,_,_1,defaults = inspect.getargspec(obj)
473 if defaults:
477 if defaults:
474 return args[-len(defaults):]
478 return args[-len(defaults):]
475 except TypeError: pass
479 except TypeError: pass
476 return []
480 return []
477
481
478 def python_func_kw_matches(self,text):
482 def python_func_kw_matches(self,text):
479 """Match named parameters (kwargs) of the last open function"""
483 """Match named parameters (kwargs) of the last open function"""
480
484
481 if "." in text: # a parameter cannot be dotted
485 if "." in text: # a parameter cannot be dotted
482 return []
486 return []
483 try: regexp = self.__funcParamsRegex
487 try: regexp = self.__funcParamsRegex
484 except AttributeError:
488 except AttributeError:
485 regexp = self.__funcParamsRegex = re.compile(r'''
489 regexp = self.__funcParamsRegex = re.compile(r'''
486 '.*?' | # single quoted strings or
490 '.*?' | # single quoted strings or
487 ".*?" | # double quoted strings or
491 ".*?" | # double quoted strings or
488 \w+ | # identifier
492 \w+ | # identifier
489 \S # other characters
493 \S # other characters
490 ''', re.VERBOSE | re.DOTALL)
494 ''', re.VERBOSE | re.DOTALL)
491 # 1. find the nearest identifier that comes before an unclosed
495 # 1. find the nearest identifier that comes before an unclosed
492 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
496 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
493 tokens = regexp.findall(self.get_line_buffer())
497 tokens = regexp.findall(self.get_line_buffer())
494 tokens.reverse()
498 tokens.reverse()
495 iterTokens = iter(tokens); openPar = 0
499 iterTokens = iter(tokens); openPar = 0
496 for token in iterTokens:
500 for token in iterTokens:
497 if token == ')':
501 if token == ')':
498 openPar -= 1
502 openPar -= 1
499 elif token == '(':
503 elif token == '(':
500 openPar += 1
504 openPar += 1
501 if openPar > 0:
505 if openPar > 0:
502 # found the last unclosed parenthesis
506 # found the last unclosed parenthesis
503 break
507 break
504 else:
508 else:
505 return []
509 return []
506 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
510 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
507 ids = []
511 ids = []
508 isId = re.compile(r'\w+$').match
512 isId = re.compile(r'\w+$').match
509 while True:
513 while True:
510 try:
514 try:
511 ids.append(iterTokens.next())
515 ids.append(iterTokens.next())
512 if not isId(ids[-1]):
516 if not isId(ids[-1]):
513 ids.pop(); break
517 ids.pop(); break
514 if not iterTokens.next() == '.':
518 if not iterTokens.next() == '.':
515 break
519 break
516 except StopIteration:
520 except StopIteration:
517 break
521 break
518 # lookup the candidate callable matches either using global_matches
522 # lookup the candidate callable matches either using global_matches
519 # or attr_matches for dotted names
523 # or attr_matches for dotted names
520 if len(ids) == 1:
524 if len(ids) == 1:
521 callableMatches = self.global_matches(ids[0])
525 callableMatches = self.global_matches(ids[0])
522 else:
526 else:
523 callableMatches = self.attr_matches('.'.join(ids[::-1]))
527 callableMatches = self.attr_matches('.'.join(ids[::-1]))
524 argMatches = []
528 argMatches = []
525 for callableMatch in callableMatches:
529 for callableMatch in callableMatches:
526 try: namedArgs = self._default_arguments(eval(callableMatch,
530 try: namedArgs = self._default_arguments(eval(callableMatch,
527 self.namespace))
531 self.namespace))
528 except: continue
532 except: continue
529 for namedArg in namedArgs:
533 for namedArg in namedArgs:
530 if namedArg.startswith(text):
534 if namedArg.startswith(text):
531 argMatches.append("%s=" %namedArg)
535 argMatches.append("%s=" %namedArg)
532 return argMatches
536 return argMatches
533
537
534 def dispatch_custom_completer(self,text):
538 def dispatch_custom_completer(self,text):
535 # print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
539 # print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
536 line = self.full_lbuf
540 line = self.full_lbuf
537 if not line.strip():
541 if not line.strip():
538 return None
542 return None
539
543
540 event = Struct()
544 event = Struct()
541 event.line = line
545 event.line = line
542 event.symbol = text
546 event.symbol = text
543 cmd = line.split(None,1)[0]
547 cmd = line.split(None,1)[0]
544 event.command = cmd
548 event.command = cmd
545 #print "\ncustom:{%s]\n" % event # dbg
549 #print "\ncustom:{%s]\n" % event # dbg
546
550
547 # for foo etc, try also to find completer for %foo
551 # for foo etc, try also to find completer for %foo
548 if not cmd.startswith(self.magic_escape):
552 if not cmd.startswith(self.magic_escape):
549 try_magic = self.custom_completers.s_matches(
553 try_magic = self.custom_completers.s_matches(
550 self.magic_escape + cmd)
554 self.magic_escape + cmd)
551 else:
555 else:
552 try_magic = []
556 try_magic = []
553
557
554
558
555 for c in itertools.chain(
559 for c in itertools.chain(
556 self.custom_completers.s_matches(cmd),
560 self.custom_completers.s_matches(cmd),
557 try_magic,
561 try_magic,
558 self.custom_completers.flat_matches(self.lbuf)):
562 self.custom_completers.flat_matches(self.lbuf)):
559 # print "try",c # dbg
563 # print "try",c # dbg
560 try:
564 try:
561 res = c(event)
565 res = c(event)
562 return [r for r in res if r.lower().startswith(text.lower())]
566 return [r for r in res if r.lower().startswith(text.lower())]
563 except ipapi.TryNext:
567 except ipapi.TryNext:
564 pass
568 pass
565
569
566 return None
570 return None
567
571
568
572
569
573
570 def complete(self, text, state):
574 def complete(self, text, state):
571 """Return the next possible completion for 'text'.
575 """Return the next possible completion for 'text'.
572
576
573 This is called successively with state == 0, 1, 2, ... until it
577 This is called successively with state == 0, 1, 2, ... until it
574 returns None. The completion should begin with 'text'. """
578 returns None. The completion should begin with 'text'. """
575
579
576 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
580 #print '\n*** COMPLETE: <%s> (%s)' % (text,state) # dbg
577
581
578 # if there is only a tab on a line with only whitespace, instead
582 # if there is only a tab on a line with only whitespace, instead
579 # of the mostly useless 'do you want to see all million
583 # of the mostly useless 'do you want to see all million
580 # completions' message, just do the right thing and give the user
584 # completions' message, just do the right thing and give the user
581 # his tab! Incidentally, this enables pasting of tabbed text from
585 # his tab! Incidentally, this enables pasting of tabbed text from
582 # an editor (as long as autoindent is off).
586 # an editor (as long as autoindent is off).
583
587
584 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
588 # don't apply this on 'dumb' terminals, such as emacs buffers, so we
585 # don't interfere with their own tab-completion mechanism.
589 # don't interfere with their own tab-completion mechanism.
586 self.full_lbuf = self.get_line_buffer()
590 self.full_lbuf = self.get_line_buffer()
587 self.lbuf = self.full_lbuf[:self.readline.get_endidx()]
591 self.lbuf = self.full_lbuf[:self.readline.get_endidx()]
588 if not (self.dumb_terminal or self.get_line_buffer().strip()):
592 if not (self.dumb_terminal or self.get_line_buffer().strip()):
589 self.readline.insert_text('\t')
593 self.readline.insert_text('\t')
590 return None
594 return None
591
595
592
596
593 magic_escape = self.magic_escape
597 magic_escape = self.magic_escape
594 magic_prefix = self.magic_prefix
598 magic_prefix = self.magic_prefix
595
599
596 try:
600 try:
597 if text.startswith(magic_escape):
601 if text.startswith(magic_escape):
598 text = text.replace(magic_escape,magic_prefix)
602 text = text.replace(magic_escape,magic_prefix)
599 elif text.startswith('~'):
603 elif text.startswith('~'):
600 text = os.path.expanduser(text)
604 text = os.path.expanduser(text)
601 if state == 0:
605 if state == 0:
602 custom_res = self.dispatch_custom_completer(text)
606 custom_res = self.dispatch_custom_completer(text)
603 if custom_res is not None:
607 if custom_res is not None:
604 # did custom completers produce something?
608 # did custom completers produce something?
605 self.matches = custom_res
609 self.matches = custom_res
606 else:
610 else:
607 # Extend the list of completions with the results of each
611 # Extend the list of completions with the results of each
608 # matcher, so we return results to the user from all
612 # matcher, so we return results to the user from all
609 # namespaces.
613 # namespaces.
610 if self.merge_completions:
614 if self.merge_completions:
611 self.matches = []
615 self.matches = []
612 for matcher in self.matchers:
616 for matcher in self.matchers:
613 self.matches.extend(matcher(text))
617 self.matches.extend(matcher(text))
614 else:
618 else:
615 for matcher in self.matchers:
619 for matcher in self.matchers:
616 self.matches = matcher(text)
620 self.matches = matcher(text)
617 if self.matches:
621 if self.matches:
618 break
622 break
619
623
620 try:
624 try:
621 return self.matches[state].replace(magic_prefix,magic_escape)
625 return self.matches[state].replace(magic_prefix,magic_escape)
622 except IndexError:
626 except IndexError:
623 return None
627 return None
624 except:
628 except:
625 from IPython.ultraTB import AutoFormattedTB; # dbg
629 from IPython.ultraTB import AutoFormattedTB; # dbg
626 tb=AutoFormattedTB('Verbose');tb() #dbg
630 tb=AutoFormattedTB('Verbose');tb() #dbg
627
631
628 # If completion fails, don't annoy the user.
632 # If completion fails, don't annoy the user.
629 return None
633 return None
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now