##// END OF EJS Templates
apply Matthew Neeley's patch to sort the attribute names properly when the dupes have been removed
vivainio -
Show More

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

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