Lib/idlelib/AutoComplete.py

   1 """AutoComplete.py - An IDLE extension for automatically completing names.
   2
   3 This extension can complete either attribute names of file names. It can pop
   4 a window with all available names, for the user to select from.
   5 """
   6 import os
   7 import sys
   8 import string
   9
  10 from configHandler import idleConf
  11
  12 import AutoCompleteWindow
  13 from HyperParser import HyperParser
  14
  15 import __main__
  16
  17 # This string includes all chars that may be in a file name (without a path
  18 # separator)
  19 FILENAME_CHARS = string.ascii_letters + string.digits + os.curdir + "._~#$:-"
  20 # This string includes all chars that may be in an identifier
  21 ID_CHARS = string.ascii_letters + string.digits + "_"
  22
  23 # These constants represent the two different types of completions
  24 COMPLETE_ATTRIBUTES, COMPLETE_FILES = range(1, 2+1)
  25
  26 class AutoComplete:
  27
  28     menudefs = [
  29         ('edit', [
  30             ("Show Completions", "<<force-open-completions>>"),
  31         ])
  32     ]
  33
  34     popupwait = idleConf.GetOption("extensions", "AutoComplete",
  35                                    "popupwait", type="int", default=0)
  36
  37     def __init__(self, editwin=None):
  38         if editwin == None:  # subprocess and test
  39             self.editwin = None
  40             return
  41         self.editwin = editwin
  42         self.text = editwin.text
  43         self.autocompletewindow = None
  44
  45         # id of delayed call, and the index of the text insert when the delayed
  46         # call was issued. If _delayed_completion_id is None, there is no
  47         # delayed call.
  48         self._delayed_completion_id = None
  49         self._delayed_completion_index = None
  50
  51     def _make_autocomplete_window(self):
  52         return AutoCompleteWindow.AutoCompleteWindow(self.text)
  53
  54     def _remove_autocomplete_window(self, event=None):
  55         if self.autocompletewindow:
  56             self.autocompletewindow.hide_window()
  57             self.autocompletewindow = None
  58
  59     def force_open_completions_event(self, event):
  60         """Happens when the user really wants to open a completion list, even
  61         if a function call is needed.
  62         """
  63         self.open_completions(True, False, True)
  64
  65     def try_open_completions_event(self, event):
  66         """Happens when it would be nice to open a completion list, but not
  67         really neccesary, for example after an dot, so function
  68         calls won't be made.
  69         """
  70         lastchar = self.text.get("insert-1c")
  71         if lastchar == ".":
  72             self._open_completions_later(False, False, False,
  73                                          COMPLETE_ATTRIBUTES)
  74         elif lastchar == os.sep:
  75             self._open_completions_later(False, False, False,
  76                                          COMPLETE_FILES)
  77
  78     def autocomplete_event(self, event):
  79         """Happens when the user wants to complete his word, and if neccesary,
  80         open a completion list after that (if there is more than one
  81         completion)
  82         """
  83         if hasattr(event, "mc_state") and event.mc_state:
  84             # A modifier was pressed along with the tab, continue as usual.
  85             return
  86         if self.autocompletewindow and self.autocompletewindow.is_active():
  87             self.autocompletewindow.complete()
  88             return "break"
  89         else:
  90             opened = self.open_completions(False, True, True)
  91             if opened:
  92                 return "break"
  93
  94     def _open_completions_later(self, *args):
  95         self._delayed_completion_index = self.text.index("insert")
  96         if self._delayed_completion_id is not None:
  97             self.text.after_cancel(self._delayed_completion_id)
  98         self._delayed_completion_id = \
  99             self.text.after(self.popupwait, self._delayed_open_completions,
 100                             *args)
 101
 102     def _delayed_open_completions(self, *args):
 103         self._delayed_completion_id = None
 104         if self.text.index("insert") != self._delayed_completion_index:
 105             return
 106         self.open_completions(*args)
 107
 108     def open_completions(self, evalfuncs, complete, userWantsWin, mode=None):
 109         """Find the completions and create the AutoCompleteWindow.
 110         Return True if successful (no syntax error or so found).
 111         if complete is True, then if there's nothing to complete and no
 112         start of completion, won't open completions and return False.
 113         If mode is given, will open a completion list only in this mode.
 114         """
 115         # Cancel another delayed call, if it exists.
 116         if self._delayed_completion_id is not None:
 117             self.text.after_cancel(self._delayed_completion_id)
 118             self._delayed_completion_id = None
 119
 120         hp = HyperParser(self.editwin, "insert")
 121         curline = self.text.get("insert linestart", "insert")
 122         i = j = len(curline)
 123         if hp.is_in_string() and (not mode or mode==COMPLETE_FILES):
 124             self._remove_autocomplete_window()
 125             mode = COMPLETE_FILES
 126             while i and curline[i-1] in FILENAME_CHARS:
 127                 i -= 1
 128             comp_start = curline[i:j]
 129             j = i
 130             while i and curline[i-1] in FILENAME_CHARS+os.sep:
 131                 i -= 1
 132             comp_what = curline[i:j]
 133         elif hp.is_in_code() and (not mode or mode==COMPLETE_ATTRIBUTES):
 134             self._remove_autocomplete_window()
 135             mode = COMPLETE_ATTRIBUTES
 136             while i and curline[i-1] in ID_CHARS:
 137                 i -= 1
 138             comp_start = curline[i:j]
 139             if i and curline[i-1] == '.':
 140                 hp.set_index("insert-%dc" % (len(curline)-(i-1)))
 141                 comp_what = hp.get_expression()
 142                 if not comp_what or \
 143                    (not evalfuncs and comp_what.find('(') != -1):
 144                     return
 145             else:
 146                 comp_what = ""
 147         else:
 148             return
 149
 150         if complete and not comp_what and not comp_start:
 151             return
 152         comp_lists = self.fetch_completions(comp_what, mode)
 153         if not comp_lists[0]:
 154             return
 155         self.autocompletewindow = self._make_autocomplete_window()
 156         self.autocompletewindow.show_window(comp_lists,
 157                                             "insert-%dc" % len(comp_start),
 158                                             complete,
 159                                             mode,
 160                                             userWantsWin)
 161         return True
 162
 163     def fetch_completions(self, what, mode):
 164         """Return a pair of lists of completions for something. The first list
 165         is a sublist of the second. Both are sorted.
 166
 167         If there is a Python subprocess, get the comp. list there.  Otherwise,
 168         either fetch_completions() is running in the subprocess itself or it
 169         was called in an IDLE EditorWindow before any script had been run.
 170
 171         The subprocess environment is that of the most recently run script.  If
 172         two unrelated modules are being edited some calltips in the current
 173         module may be inoperative if the module was not the last to run.
 174         """
 175         try:
 176             rpcclt = self.editwin.flist.pyshell.interp.rpcclt
 177         except:
 178             rpcclt = None
 179         if rpcclt:
 180             return rpcclt.remotecall("exec", "get_the_completion_list",
 181                                      (what, mode), {})
 182         else:
 183             if mode == COMPLETE_ATTRIBUTES:
 184                 if what == "":
 185                     namespace = __main__.__dict__.copy()
 186                     namespace.update(__main__.__builtins__.__dict__)
 187                     bigl = eval("dir()", namespace)
 188                     bigl.sort()
 189                     if "__all__" in bigl:
 190                         smalll = eval("__all__", namespace)
 191                         smalll.sort()
 192                     else:
 193                         smalll = filter(lambda s: s[:1] != '_', bigl)
 194                 else:
 195                     try:
 196                         entity = self.get_entity(what)
 197                         bigl = dir(entity)
 198                         bigl.sort()
 199                         if "__all__" in bigl:
 200                             smalll = entity.__all__
 201                             smalll.sort()
 202                         else:
 203                             smalll = filter(lambda s: s[:1] != '_', bigl)
 204                     except:
 205                         return [], []
 206
 207             elif mode == COMPLETE_FILES:
 208                 if what == "":
 209                     what = "."
 210                 try:
 211                     expandedpath = os.path.expanduser(what)
 212                     bigl = os.listdir(expandedpath)
 213                     bigl.sort()
 214                     smalll = filter(lambda s: s[:1] != '.', bigl)
 215                 except OSError:
 216                     return [], []
 217
 218             if not smalll:
 219                 smalll = bigl
 220             return smalll, bigl
 221
 222     def get_entity(self, name):
 223         """Lookup name in a namespace spanning sys.modules and __main.dict__"""
 224         namespace = sys.modules.copy()
 225         namespace.update(__main__.__dict__)
 226         return eval(name, namespace)