##// END OF EJS Templates
Greedy completer for qtconsole....
macgyver -
Show More
@@ -1,869 +1,874 b''
1 1 """Word completion for IPython.
2 2
3 3 This module is a fork of the rlcompleter module in the Python standard
4 4 library. The original enhancements made to rlcompleter have been sent
5 5 upstream and were accepted as of Python 2.3, but we need a lot more
6 6 functionality specific to IPython, so this module will continue to live as an
7 7 IPython-specific utility.
8 8
9 9 Original rlcompleter documentation:
10 10
11 11 This requires the latest extension to the readline module (the
12 12 completes keywords, built-ins and globals in __main__; when completing
13 13 NAME.NAME..., it evaluates (!) the expression up to the last dot and
14 14 completes its attributes.
15 15
16 16 It's very cool to do "import string" type "string.", hit the
17 17 completion key (twice), and see the list of names defined by the
18 18 string module!
19 19
20 20 Tip: to use the tab key as the completion key, call
21 21
22 22 readline.parse_and_bind("tab: complete")
23 23
24 24 Notes:
25 25
26 26 - Exceptions raised by the completer function are *ignored* (and
27 27 generally cause the completion to fail). This is a feature -- since
28 28 readline sets the tty device in raw (or cbreak) mode, printing a
29 29 traceback wouldn't work well without some complicated hoopla to save,
30 30 reset and restore the tty state.
31 31
32 32 - The evaluation of the NAME.NAME... form may cause arbitrary
33 33 application defined code to be executed if an object with a
34 34 __getattr__ hook is found. Since it is the responsibility of the
35 35 application (or the user) to enable this feature, I consider this an
36 36 acceptable risk. More complicated expressions (e.g. function calls or
37 37 indexing operations) are *not* evaluated.
38 38
39 39 - GNU readline is also used by the built-in functions input() and
40 40 raw_input(), and thus these also benefit/suffer from the completer
41 41 features. Clearly an interactive application can benefit by
42 42 specifying its own completer function and using raw_input() for all
43 43 its input.
44 44
45 45 - When the original stdin is not a tty device, GNU readline is never
46 46 used, and this module (and the readline module) are silently inactive.
47 47 """
48 48
49 49 #*****************************************************************************
50 50 #
51 51 # Since this file is essentially a minimally modified copy of the rlcompleter
52 52 # module which is part of the standard Python distribution, I assume that the
53 53 # proper procedure is to maintain its copyright as belonging to the Python
54 54 # Software Foundation (in addition to my own, for all new code).
55 55 #
56 56 # Copyright (C) 2008-2010 IPython Development Team
57 57 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
58 58 # Copyright (C) 2001 Python Software Foundation, www.python.org
59 59 #
60 60 # Distributed under the terms of the BSD License. The full license is in
61 61 # the file COPYING, distributed as part of this software.
62 62 #
63 63 #*****************************************************************************
64 64 from __future__ import print_function
65 65
66 66 #-----------------------------------------------------------------------------
67 67 # Imports
68 68 #-----------------------------------------------------------------------------
69 69
70 70 import __builtin__
71 71 import __main__
72 72 import glob
73 73 import inspect
74 74 import itertools
75 75 import keyword
76 76 import os
77 77 import re
78 78 import shlex
79 79 import sys
80 80
81 81 from IPython.core.error import TryNext
82 82 from IPython.core.prefilter import ESC_MAGIC
83 83 from IPython.utils import generics
84 84 from IPython.utils import io
85 85 from IPython.utils.dir2 import dir2
86 86 from IPython.utils.process import arg_split
87 87
88 88 #-----------------------------------------------------------------------------
89 89 # Globals
90 90 #-----------------------------------------------------------------------------
91 91
92 92 # Public API
93 93 __all__ = ['Completer','IPCompleter']
94 94
95 95 if sys.platform == 'win32':
96 96 PROTECTABLES = ' '
97 97 else:
98 98 PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
99 99
100 100 #-----------------------------------------------------------------------------
101 101 # Main functions and classes
102 102 #-----------------------------------------------------------------------------
103 103
104 104 def has_open_quotes(s):
105 105 """Return whether a string has open quotes.
106 106
107 107 This simply counts whether the number of quote characters of either type in
108 108 the string is odd.
109 109
110 110 Returns
111 111 -------
112 112 If there is an open quote, the quote character is returned. Else, return
113 113 False.
114 114 """
115 115 # We check " first, then ', so complex cases with nested quotes will get
116 116 # the " to take precedence.
117 117 if s.count('"') % 2:
118 118 return '"'
119 119 elif s.count("'") % 2:
120 120 return "'"
121 121 else:
122 122 return False
123 123
124 124
125 125 def protect_filename(s):
126 126 """Escape a string to protect certain characters."""
127 127
128 128 return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
129 129 for ch in s])
130 130
131 131
132 132 def mark_dirs(matches):
133 133 """Mark directories in input list by appending '/' to their names."""
134 134 out = []
135 135 isdir = os.path.isdir
136 136 for x in matches:
137 137 if isdir(x):
138 138 out.append(x+'/')
139 139 else:
140 140 out.append(x)
141 141 return out
142 142
143 143
144 144 def expand_user(path):
145 145 """Expand '~'-style usernames in strings.
146 146
147 147 This is similar to :func:`os.path.expanduser`, but it computes and returns
148 148 extra information that will be useful if the input was being used in
149 149 computing completions, and you wish to return the completions with the
150 150 original '~' instead of its expanded value.
151 151
152 152 Parameters
153 153 ----------
154 154 path : str
155 155 String to be expanded. If no ~ is present, the output is the same as the
156 156 input.
157 157
158 158 Returns
159 159 -------
160 160 newpath : str
161 161 Result of ~ expansion in the input path.
162 162 tilde_expand : bool
163 163 Whether any expansion was performed or not.
164 164 tilde_val : str
165 165 The value that ~ was replaced with.
166 166 """
167 167 # Default values
168 168 tilde_expand = False
169 169 tilde_val = ''
170 170 newpath = path
171 171
172 172 if path.startswith('~'):
173 173 tilde_expand = True
174 174 rest = path[1:]
175 175 newpath = os.path.expanduser(path)
176 176 tilde_val = newpath.replace(rest, '')
177 177
178 178 return newpath, tilde_expand, tilde_val
179 179
180 180
181 181 def compress_user(path, tilde_expand, tilde_val):
182 182 """Does the opposite of expand_user, with its outputs.
183 183 """
184 184 if tilde_expand:
185 185 return path.replace(tilde_val, '~')
186 186 else:
187 187 return path
188 188
189 189
190 190 def single_dir_expand(matches):
191 191 "Recursively expand match lists containing a single dir."
192 192
193 193 if len(matches) == 1 and os.path.isdir(matches[0]):
194 194 # Takes care of links to directories also. Use '/'
195 195 # explicitly, even under Windows, so that name completions
196 196 # don't end up escaped.
197 197 d = matches[0]
198 198 if d[-1] in ['/','\\']:
199 199 d = d[:-1]
200 200
201 201 subdirs = os.listdir(d)
202 202 if subdirs:
203 203 matches = [ (d + '/' + p) for p in subdirs]
204 204 return single_dir_expand(matches)
205 205 else:
206 206 return matches
207 207 else:
208 208 return matches
209 209
210 210
211 211 class Bunch(object): pass
212 212
213 213
214 214 class CompletionSplitter(object):
215 215 """An object to split an input line in a manner similar to readline.
216 216
217 217 By having our own implementation, we can expose readline-like completion in
218 218 a uniform manner to all frontends. This object only needs to be given the
219 219 line of text to be split and the cursor position on said line, and it
220 220 returns the 'word' to be completed on at the cursor after splitting the
221 221 entire line.
222 222
223 223 What characters are used as splitting delimiters can be controlled by
224 224 setting the `delims` attribute (this is a property that internally
225 225 automatically builds the necessary """
226 226
227 227 # Private interface
228 228
229 229 # A string of delimiter characters. The default value makes sense for
230 230 # IPython's most typical usage patterns.
231 _delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
231 #_delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
232 _delims = ' \n\t'
232 233
233 234 # The expression (a normal string) to be compiled into a regular expression
234 235 # for actual splitting. We store it as an attribute mostly for ease of
235 236 # debugging, since this type of code can be so tricky to debug.
236 237 _delim_expr = None
237 238
238 239 # The regular expression that does the actual splitting
239 240 _delim_re = None
240 241
241 242 def __init__(self, delims=None):
242 243 delims = CompletionSplitter._delims if delims is None else delims
243 244 self.set_delims(delims)
244 245
245 246 def set_delims(self, delims):
246 247 """Set the delimiters for line splitting."""
247 248 expr = '[' + ''.join('\\'+ c for c in delims) + ']'
248 249 self._delim_re = re.compile(expr)
249 250 self._delims = delims
250 251 self._delim_expr = expr
251 252
252 253 def get_delims(self):
253 254 """Return the string of delimiter characters."""
254 255 return self._delims
255 256
256 257 def split_line(self, line, cursor_pos=None):
257 258 """Split a line of text with a cursor at the given position.
258 259 """
259 260 l = line if cursor_pos is None else line[:cursor_pos]
260 261 return self._delim_re.split(l)[-1]
261 262
262 263
263 264 class Completer(object):
264 265 def __init__(self, namespace=None, global_namespace=None):
265 266 """Create a new completer for the command line.
266 267
267 268 Completer([namespace,global_namespace]) -> completer instance.
268 269
269 270 If unspecified, the default namespace where completions are performed
270 271 is __main__ (technically, __main__.__dict__). Namespaces should be
271 272 given as dictionaries.
272 273
273 274 An optional second namespace can be given. This allows the completer
274 275 to handle cases where both the local and global scopes need to be
275 276 distinguished.
276 277
277 278 Completer instances should be used as the completion mechanism of
278 279 readline via the set_completer() call:
279 280
280 281 readline.set_completer(Completer(my_namespace).complete)
281 282 """
282 283
283 284 # Don't bind to namespace quite yet, but flag whether the user wants a
284 285 # specific namespace or to use __main__.__dict__. This will allow us
285 286 # to bind to __main__.__dict__ at completion time, not now.
286 287 if namespace is None:
287 288 self.use_main_ns = 1
288 289 else:
289 290 self.use_main_ns = 0
290 291 self.namespace = namespace
291 292
292 293 # The global namespace, if given, can be bound directly
293 294 if global_namespace is None:
294 295 self.global_namespace = {}
295 296 else:
296 297 self.global_namespace = global_namespace
297 298
298 299 def complete(self, text, state):
299 300 """Return the next possible completion for 'text'.
300 301
301 302 This is called successively with state == 0, 1, 2, ... until it
302 303 returns None. The completion should begin with 'text'.
303 304
304 305 """
305 306 if self.use_main_ns:
306 307 self.namespace = __main__.__dict__
307 308
308 309 if state == 0:
309 310 if "." in text:
310 311 self.matches = self.attr_matches(text)
311 312 else:
312 313 self.matches = self.global_matches(text)
313 314 try:
314 315 return self.matches[state]
315 316 except IndexError:
316 317 return None
317 318
318 319 def global_matches(self, text):
319 320 """Compute matches when text is a simple name.
320 321
321 322 Return a list of all keywords, built-in functions and names currently
322 323 defined in self.namespace or self.global_namespace that match.
323 324
324 325 """
325 326 #print 'Completer->global_matches, txt=%r' % text # dbg
326 327 matches = []
327 328 match_append = matches.append
328 329 n = len(text)
329 330 for lst in [keyword.kwlist,
330 331 __builtin__.__dict__.keys(),
331 332 self.namespace.keys(),
332 333 self.global_namespace.keys()]:
333 334 for word in lst:
334 335 if word[:n] == text and word != "__builtins__":
335 336 match_append(word)
336 337 return matches
337 338
338 339 def attr_matches(self, text):
339 340 """Compute matches when text contains a dot.
340 341
341 342 Assuming the text is of the form NAME.NAME....[NAME], and is
342 343 evaluatable in self.namespace or self.global_namespace, it will be
343 344 evaluated and its attributes (as revealed by dir()) are used as
344 345 possible completions. (For class instances, class members are are
345 346 also considered.)
346 347
347 348 WARNING: this can still invoke arbitrary C code, if an object
348 349 with a __getattr__ hook is evaluated.
349 350
350 351 """
351 352
352 #print 'Completer->attr_matches, txt=%r' % text # dbg
353 #io.rprint('Completer->attr_matches, txt=%r' % text) # dbg
353 354 # Another option, seems to work great. Catches things like ''.<tab>
354 355 m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
355 356
356 if not m:
357 return []
358
359 expr, attr = m.group(1, 3)
357 if m:
358 expr, attr = m.group(1, 3)
359 else:
360 m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
361 if not m2:
362 return []
363 expr, attr = m2.group(1,2)
364
360 365 try:
361 366 obj = eval(expr, self.namespace)
362 367 except:
363 368 try:
364 369 obj = eval(expr, self.global_namespace)
365 370 except:
366 371 return []
367 372
368 373 words = dir2(obj)
369 374
370 375 try:
371 376 words = generics.complete_object(obj, words)
372 377 except TryNext:
373 378 pass
374 379 # Build match list to return
375 380 n = len(attr)
376 381 res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
377 382 return res
378 383
379 384
380 385 class IPCompleter(Completer):
381 386 """Extension of the completer class with IPython-specific features"""
382 387
383 388 def __init__(self, shell, namespace=None, global_namespace=None,
384 389 omit__names=True, alias_table=None, use_readline=True):
385 390 """IPCompleter() -> completer
386 391
387 392 Return a completer object suitable for use by the readline library
388 393 via readline.set_completer().
389 394
390 395 Inputs:
391 396
392 397 - shell: a pointer to the ipython shell itself. This is needed
393 398 because this completer knows about magic functions, and those can
394 399 only be accessed via the ipython instance.
395 400
396 401 - namespace: an optional dict where completions are performed.
397 402
398 403 - global_namespace: secondary optional dict for completions, to
399 404 handle cases (such as IPython embedded inside functions) where
400 405 both Python scopes are visible.
401 406
402 407 - The optional omit__names parameter sets the completer to omit the
403 408 'magic' names (__magicname__) for python objects unless the text
404 409 to be completed explicitly starts with one or more underscores.
405 410
406 411 - If alias_table is supplied, it should be a dictionary of aliases
407 412 to complete.
408 413
409 414 use_readline : bool, optional
410 415 If true, use the readline library. This completer can still function
411 416 without readline, though in that case callers must provide some extra
412 417 information on each call about the current line."""
413 418
414 419 Completer.__init__(self, namespace, global_namespace)
415 420
416 421 self.magic_escape = ESC_MAGIC
417 422 self.splitter = CompletionSplitter()
418 423
419 424 # Readline configuration, only used by the rlcompleter method.
420 425 if use_readline:
421 426 # We store the right version of readline so that later code
422 427 import IPython.utils.rlineimpl as readline
423 428 self.readline = readline
424 429 else:
425 430 self.readline = None
426 431
427 432 # List where completion matches will be stored
428 433 self.matches = []
429 434 self.omit__names = omit__names
430 435 self.merge_completions = shell.readline_merge_completions
431 436 self.shell = shell.shell
432 437 if alias_table is None:
433 438 alias_table = {}
434 439 self.alias_table = alias_table
435 440 # Regexp to split filenames with spaces in them
436 441 self.space_name_re = re.compile(r'([^\\] )')
437 442 # Hold a local ref. to glob.glob for speed
438 443 self.glob = glob.glob
439 444
440 445 # Determine if we are running on 'dumb' terminals, like (X)Emacs
441 446 # buffers, to avoid completion problems.
442 447 term = os.environ.get('TERM','xterm')
443 448 self.dumb_terminal = term in ['dumb','emacs']
444 449
445 450 # Special handling of backslashes needed in win32 platforms
446 451 if sys.platform == "win32":
447 452 self.clean_glob = self._clean_glob_win32
448 453 else:
449 454 self.clean_glob = self._clean_glob
450 455
451 456 # All active matcher routines for completion
452 457 self.matchers = [self.python_matches,
453 458 self.file_matches,
454 459 self.magic_matches,
455 460 self.alias_matches,
456 461 self.python_func_kw_matches,
457 462 ]
458 463
459 464 def all_completions(self, text):
460 465 """
461 466 Wrapper around the complete method for the benefit of emacs
462 467 and pydb.
463 468 """
464 469 return self.complete(text)[1]
465 470
466 471 def _clean_glob(self,text):
467 472 return self.glob("%s*" % text)
468 473
469 474 def _clean_glob_win32(self,text):
470 475 return [f.replace("\\","/")
471 476 for f in self.glob("%s*" % text)]
472 477
473 478 def file_matches(self, text):
474 479 """Match filenames, expanding ~USER type strings.
475 480
476 481 Most of the seemingly convoluted logic in this completer is an
477 482 attempt to handle filenames with spaces in them. And yet it's not
478 483 quite perfect, because Python's readline doesn't expose all of the
479 484 GNU readline details needed for this to be done correctly.
480 485
481 486 For a filename with a space in it, the printed completions will be
482 487 only the parts after what's already been typed (instead of the
483 488 full completions, as is normally done). I don't think with the
484 489 current (as of Python 2.3) Python readline it's possible to do
485 490 better."""
486 491
487 492 #io.rprint('Completer->file_matches: <%r>' % text) # dbg
488 493
489 494 # chars that require escaping with backslash - i.e. chars
490 495 # that readline treats incorrectly as delimiters, but we
491 496 # don't want to treat as delimiters in filename matching
492 497 # when escaped with backslash
493 498 if text.startswith('!'):
494 499 text = text[1:]
495 500 text_prefix = '!'
496 501 else:
497 502 text_prefix = ''
498 503
499 504 text_until_cursor = self.text_until_cursor
500 505 # track strings with open quotes
501 506 open_quotes = has_open_quotes(text_until_cursor)
502 507
503 508 if '(' in text_until_cursor or '[' in text_until_cursor:
504 509 lsplit = text
505 510 else:
506 511 try:
507 512 # arg_split ~ shlex.split, but with unicode bugs fixed by us
508 513 lsplit = arg_split(text_until_cursor)[-1]
509 514 except ValueError:
510 515 # typically an unmatched ", or backslash without escaped char.
511 516 if open_quotes:
512 517 lsplit = text_until_cursor.split(open_quotes)[-1]
513 518 else:
514 519 return []
515 520 except IndexError:
516 521 # tab pressed on empty line
517 522 lsplit = ""
518 523
519 524 if not open_quotes and lsplit != protect_filename(lsplit):
520 525 # if protectables are found, do matching on the whole escaped name
521 526 has_protectables = True
522 527 text0,text = text,lsplit
523 528 else:
524 529 has_protectables = False
525 530 text = os.path.expanduser(text)
526 531
527 532 if text == "":
528 533 return [text_prefix + protect_filename(f) for f in self.glob("*")]
529 534
530 535 # Compute the matches from the filesystem
531 536 m0 = self.clean_glob(text.replace('\\',''))
532 537
533 538 if has_protectables:
534 539 # If we had protectables, we need to revert our changes to the
535 540 # beginning of filename so that we don't double-write the part
536 541 # of the filename we have so far
537 542 len_lsplit = len(lsplit)
538 543 matches = [text_prefix + text0 +
539 544 protect_filename(f[len_lsplit:]) for f in m0]
540 545 else:
541 546 if open_quotes:
542 547 # if we have a string with an open quote, we don't need to
543 548 # protect the names at all (and we _shouldn't_, as it
544 549 # would cause bugs when the filesystem call is made).
545 550 matches = m0
546 551 else:
547 552 matches = [text_prefix +
548 553 protect_filename(f) for f in m0]
549 554
550 555 #io.rprint('mm', matches) # dbg
551 556 return mark_dirs(matches)
552 557
553 558 def magic_matches(self, text):
554 559 """Match magics"""
555 560 #print 'Completer->magic_matches:',text,'lb',self.text_until_cursor # dbg
556 561 # Get all shell magics now rather than statically, so magics loaded at
557 562 # runtime show up too
558 563 magics = self.shell.lsmagic()
559 564 pre = self.magic_escape
560 565 baretext = text.lstrip(pre)
561 566 return [ pre+m for m in magics if m.startswith(baretext)]
562 567
563 568 def alias_matches(self, text):
564 569 """Match internal system aliases"""
565 570 #print 'Completer->alias_matches:',text,'lb',self.text_until_cursor # dbg
566 571
567 572 # if we are not in the first 'item', alias matching
568 573 # doesn't make sense - unless we are starting with 'sudo' command.
569 574 main_text = self.text_until_cursor.lstrip()
570 575 if ' ' in main_text and not main_text.startswith('sudo'):
571 576 return []
572 577 text = os.path.expanduser(text)
573 578 aliases = self.alias_table.keys()
574 579 if text == '':
575 580 return aliases
576 581 else:
577 582 return [a for a in aliases if a.startswith(text)]
578 583
579 584 def python_matches(self,text):
580 585 """Match attributes or global python names"""
581 586
582 #print 'Completer->python_matches, txt=%r' % text # dbg
587 #io.rprint('Completer->python_matches, txt=%r' % text) # dbg
583 588 if "." in text:
584 589 try:
585 590 matches = self.attr_matches(text)
586 591 if text.endswith('.') and self.omit__names:
587 592 if self.omit__names == 1:
588 593 # true if txt is _not_ a __ name, false otherwise:
589 594 no__name = (lambda txt:
590 595 re.match(r'.*\.__.*?__',txt) is None)
591 596 else:
592 597 # true if txt is _not_ a _ name, false otherwise:
593 598 no__name = (lambda txt:
594 599 re.match(r'.*\._.*?',txt) is None)
595 600 matches = filter(no__name, matches)
596 601 except NameError:
597 602 # catches <undefined attributes>.<tab>
598 603 matches = []
599 604 else:
600 605 matches = self.global_matches(text)
601 606
602 607 return matches
603 608
604 609 def _default_arguments(self, obj):
605 610 """Return the list of default arguments of obj if it is callable,
606 611 or empty list otherwise."""
607 612
608 613 if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
609 614 # for classes, check for __init__,__new__
610 615 if inspect.isclass(obj):
611 616 obj = (getattr(obj,'__init__',None) or
612 617 getattr(obj,'__new__',None))
613 618 # for all others, check if they are __call__able
614 619 elif hasattr(obj, '__call__'):
615 620 obj = obj.__call__
616 621 # XXX: is there a way to handle the builtins ?
617 622 try:
618 623 args,_,_1,defaults = inspect.getargspec(obj)
619 624 if defaults:
620 625 return args[-len(defaults):]
621 626 except TypeError: pass
622 627 return []
623 628
624 629 def python_func_kw_matches(self,text):
625 630 """Match named parameters (kwargs) of the last open function"""
626 631
627 632 if "." in text: # a parameter cannot be dotted
628 633 return []
629 634 try: regexp = self.__funcParamsRegex
630 635 except AttributeError:
631 636 regexp = self.__funcParamsRegex = re.compile(r'''
632 637 '.*?' | # single quoted strings or
633 638 ".*?" | # double quoted strings or
634 639 \w+ | # identifier
635 640 \S # other characters
636 641 ''', re.VERBOSE | re.DOTALL)
637 642 # 1. find the nearest identifier that comes before an unclosed
638 643 # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
639 644 tokens = regexp.findall(self.line_buffer)
640 645 tokens.reverse()
641 646 iterTokens = iter(tokens); openPar = 0
642 647 for token in iterTokens:
643 648 if token == ')':
644 649 openPar -= 1
645 650 elif token == '(':
646 651 openPar += 1
647 652 if openPar > 0:
648 653 # found the last unclosed parenthesis
649 654 break
650 655 else:
651 656 return []
652 657 # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
653 658 ids = []
654 659 isId = re.compile(r'\w+$').match
655 660 while True:
656 661 try:
657 662 ids.append(iterTokens.next())
658 663 if not isId(ids[-1]):
659 664 ids.pop(); break
660 665 if not iterTokens.next() == '.':
661 666 break
662 667 except StopIteration:
663 668 break
664 669 # lookup the candidate callable matches either using global_matches
665 670 # or attr_matches for dotted names
666 671 if len(ids) == 1:
667 672 callableMatches = self.global_matches(ids[0])
668 673 else:
669 674 callableMatches = self.attr_matches('.'.join(ids[::-1]))
670 675 argMatches = []
671 676 for callableMatch in callableMatches:
672 677 try:
673 678 namedArgs = self._default_arguments(eval(callableMatch,
674 679 self.namespace))
675 680 except:
676 681 continue
677 682 for namedArg in namedArgs:
678 683 if namedArg.startswith(text):
679 684 argMatches.append("%s=" %namedArg)
680 685 return argMatches
681 686
682 687 def dispatch_custom_completer(self, text):
683 #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
688 #io.rprint("Custom! '%s' %s" % (text, self.custom_completers)) # dbg
684 689 line = self.line_buffer
685 690 if not line.strip():
686 691 return None
687 692
688 693 # Create a little structure to pass all the relevant information about
689 694 # the current completion to any custom completer.
690 695 event = Bunch()
691 696 event.line = line
692 697 event.symbol = text
693 698 cmd = line.split(None,1)[0]
694 699 event.command = cmd
695 700 event.text_until_cursor = self.text_until_cursor
696 701
697 702 #print "\ncustom:{%s]\n" % event # dbg
698 703
699 704 # for foo etc, try also to find completer for %foo
700 705 if not cmd.startswith(self.magic_escape):
701 706 try_magic = self.custom_completers.s_matches(
702 707 self.magic_escape + cmd)
703 708 else:
704 709 try_magic = []
705 710
706 711 for c in itertools.chain(self.custom_completers.s_matches(cmd),
707 712 try_magic,
708 713 self.custom_completers.flat_matches(self.text_until_cursor)):
709 714 #print "try",c # dbg
710 715 try:
711 716 res = c(event)
712 717 if res:
713 718 # first, try case sensitive match
714 719 withcase = [r for r in res if r.startswith(text)]
715 720 if withcase:
716 721 return withcase
717 722 # if none, then case insensitive ones are ok too
718 723 text_low = text.lower()
719 724 return [r for r in res if r.lower().startswith(text_low)]
720 725 except TryNext:
721 726 pass
722 727
723 728 return None
724 729
725 730 def complete(self, text=None, line_buffer=None, cursor_pos=None):
726 731 """Find completions for the given text and line context.
727 732
728 733 This is called successively with state == 0, 1, 2, ... until it
729 734 returns None. The completion should begin with 'text'.
730 735
731 736 Note that both the text and the line_buffer are optional, but at least
732 737 one of them must be given.
733 738
734 739 Parameters
735 740 ----------
736 741 text : string, optional
737 742 Text to perform the completion on. If not given, the line buffer
738 743 is split using the instance's CompletionSplitter object.
739 744
740 745 line_buffer : string, optional
741 746 If not given, the completer attempts to obtain the current line
742 747 buffer via readline. This keyword allows clients which are
743 748 requesting for text completions in non-readline contexts to inform
744 749 the completer of the entire text.
745 750
746 751 cursor_pos : int, optional
747 752 Index of the cursor in the full line buffer. Should be provided by
748 753 remote frontends where kernel has no access to frontend state.
749 754
750 755 Returns
751 756 -------
752 757 text : str
753 758 Text that was actually used in the completion.
754 759
755 760 matches : list
756 761 A list of completion matches.
757 762 """
758 763 #io.rprint('\nCOMP1 %r %r %r' % (text, line_buffer, cursor_pos)) # dbg
759 764
760 765 # if the cursor position isn't given, the only sane assumption we can
761 766 # make is that it's at the end of the line (the common case)
762 767 if cursor_pos is None:
763 768 cursor_pos = len(line_buffer) if text is None else len(text)
764 769
765 770 # if text is either None or an empty string, rely on the line buffer
766 771 if not text:
767 772 text = self.splitter.split_line(line_buffer, cursor_pos)
768 773
769 774 # If no line buffer is given, assume the input text is all there was
770 775 if line_buffer is None:
771 776 line_buffer = text
772 777
773 778 self.line_buffer = line_buffer
774 779 self.text_until_cursor = self.line_buffer[:cursor_pos]
775 780 #io.rprint('\nCOMP2 %r %r %r' % (text, line_buffer, cursor_pos)) # dbg
776 781
777 782 # Start with a clean slate of completions
778 783 self.matches[:] = []
779 784 custom_res = self.dispatch_custom_completer(text)
780 785 if custom_res is not None:
781 786 # did custom completers produce something?
782 787 self.matches = custom_res
783 788 else:
784 789 # Extend the list of completions with the results of each
785 790 # matcher, so we return results to the user from all
786 791 # namespaces.
787 792 if self.merge_completions:
788 793 self.matches = []
789 794 for matcher in self.matchers:
790 795 try:
791 796 self.matches.extend(matcher(text))
792 797 except:
793 798 # Show the ugly traceback if the matcher causes an
794 799 # exception, but do NOT crash the kernel!
795 800 sys.excepthook(*sys.exc_info())
796 801 else:
797 802 for matcher in self.matchers:
798 803 self.matches = matcher(text)
799 804 if self.matches:
800 805 break
801 806 # FIXME: we should extend our api to return a dict with completions for
802 807 # different types of objects. The rlcomplete() method could then
803 808 # simply collapse the dict into a list for readline, but we'd have
804 809 # richer completion semantics in other evironments.
805 810 self.matches = sorted(set(self.matches))
806 811 #io.rprint('COMP TEXT, MATCHES: %r, %r' % (text, self.matches)) # dbg
807 812 return text, self.matches
808 813
809 814 def rlcomplete(self, text, state):
810 815 """Return the state-th possible completion for 'text'.
811 816
812 817 This is called successively with state == 0, 1, 2, ... until it
813 818 returns None. The completion should begin with 'text'.
814 819
815 820 Parameters
816 821 ----------
817 822 text : string
818 823 Text to perform the completion on.
819 824
820 825 state : int
821 826 Counter used by readline.
822 827 """
823 828 if state==0:
824 829
825 830 self.line_buffer = line_buffer = self.readline.get_line_buffer()
826 831 cursor_pos = self.readline.get_endidx()
827 832
828 833 #io.rprint("\nRLCOMPLETE: %r %r %r" %
829 834 # (text, line_buffer, cursor_pos) ) # dbg
830 835
831 836 # if there is only a tab on a line with only whitespace, instead of
832 837 # the mostly useless 'do you want to see all million completions'
833 838 # message, just do the right thing and give the user his tab!
834 839 # Incidentally, this enables pasting of tabbed text from an editor
835 840 # (as long as autoindent is off).
836 841
837 842 # It should be noted that at least pyreadline still shows file
838 843 # completions - is there a way around it?
839 844
840 845 # don't apply this on 'dumb' terminals, such as emacs buffers, so
841 846 # we don't interfere with their own tab-completion mechanism.
842 847 if not (self.dumb_terminal or line_buffer.strip()):
843 848 self.readline.insert_text('\t')
844 849 sys.stdout.flush()
845 850 return None
846 851
847 852 # Note: debugging exceptions that may occur in completion is very
848 853 # tricky, because readline unconditionally silences them. So if
849 854 # during development you suspect a bug in the completion code, turn
850 855 # this flag on temporarily by uncommenting the second form (don't
851 856 # flip the value in the first line, as the '# dbg' marker can be
852 857 # automatically detected and is used elsewhere).
853 858 DEBUG = False
854 859 #DEBUG = True # dbg
855 860 if DEBUG:
856 861 try:
857 862 self.complete(text, line_buffer, cursor_pos)
858 863 except:
859 864 import traceback; traceback.print_exc()
860 865 else:
861 866 # The normal production version is here
862 867
863 868 # This method computes the self.matches array
864 869 self.complete(text, line_buffer, cursor_pos)
865 870
866 871 try:
867 872 return self.matches[state]
868 873 except IndexError:
869 874 return None
General Comments 0
You need to be logged in to leave comments. Login now