Eric Assistant: comparison AssistantEric/Assistant.py

-:ed537ef44f85
+:68ef15fe34c3
 Module implementing the eric assistant, an alternative autocompletion and
 calltips system.
 """
 import re
+import imp
 from PyQt4.QtCore import QRegExp, QObject
 from E5Gui.E5Application import e5App
 from .APIsManager import APIsManager, ApisNameProject
 from QScintilla.Editor import Editor
 import Preferences
+from Utilities.ModuleParser import Module
 AcsAPIs = 0x0001
 AcsDocument = 0x0002
 AcsProject = 0x0004
 AcsOther = 0x1000
 docCompletionsList = []
 projectCompletionList = []
 sep = ""
 if context:
 wc = re.sub("\w", "", editor.wordCharacters())
+pat = re.compile("\w{0}".format(re.escape(wc)))
 text = editor.text(line)
 beg = text[:col]
 for wsep in editor.getLexer().autoCompletionWordSeparators():
 if beg.endswith(wsep):
 sep = wsep
 break
 depth = 0
 while col > 0 and \
-(not text[col - 1].isalnum() or \
+not pat.match(text[col - 1]):
-(wc and text[col - 1] not in wc)):
 ch = text[col - 1]
 if ch == ')':
 depth = 1
 # ignore everything back to the start of the
 if context:
 self.__lastContext = word
 else:
 self.__lastContext = None
+prefix = ""
+mod = None
+if context:
+beg = beg[:col + 1]
+else:
+beg = editor.text(line)[:col]
+col = len(beg)
+wsep = editor.getLexer().autoCompletionWordSeparators()
+if wsep:
+if beg[col - 1] in wsep:
+col -= 1
+else:
+while col >= 0 and beg[col - 1] not in wsep:
+col -= 1
+if col >= 0:
+col -= 1
+prefix = editor.getWordLeft(line, col)
+if editor.isPy2File() or editor.isPy3File():
+src = editor.text()
+fn = editor.getFileName()
+if fn is None:
+fn = ""
+mod = Module("", fn, imp.PY_SOURCE)
+mod.scan(src)
 if word:
 if self.__plugin.getPreferences("AutoCompletionSource") & AcsAPIs:
 api = self.__apisManager.getAPIs(language)
-apiCompletionsList = self.__getApiCompletions(api, word, context)
+apiCompletionsList = self.__getApiCompletions(
+api, word, context, prefix, mod, editor)
 if self.__plugin.getPreferences("AutoCompletionSource") & AcsProject:
 api = self.__apisManager.getAPIs(ApisNameProject)
-projectCompletionList = self.__getApiCompletions(api, word, context)
+projectCompletionList = self.__getApiCompletions(
+api, word, context, prefix, mod, editor)
 if self.__plugin.getPreferences("AutoCompletionSource") & AcsDocument:
-docCompletionsList = \
+docCompletionsList = self.getCompletionsFromDocument(
-self.getCompletionsFromDocument(editor, word, context, sep)
+editor, word, context, sep, prefix, mod)
 completionsList = list(
 set(apiCompletionsList)
 .union(set(docCompletionsList))
 .union(set(projectCompletionList))
 if len(completionsList) > 0:
 completionsList.sort()
 editor.showUserList(EditorAutoCompletionListID, completionsList)
-def __getApiCompletions(self, api, word, context):
+def __getApiCompletions(self, api, word, context, prefix, module, editor):
 """
 Private method to determine a list of completions from an API object.
 @param api reference to the API object to be used (APIsManager.DbAPIs)
 @param word word (or wordpart) to complete (string)
 @param context flag indicating to autocomplete a context (boolean)
+@param prefix prefix of the word to be completed (string)
+@param module reference to the scanned module info (Module)
+@param editor reference to the editor object (QScintilla.Editor)
 @return list of possible completions (list of strings)
 """
 completionsList = []
 if api is not None:
-if context:
+if prefix and module and prefix == "self":
+line, col = editor.getCursorPosition()
+for cl in module.classes.values():
+if line >= cl.lineno and \
+(cl.endlineno == -1 or line <= cl.endlineno):
+completions = []
+for super in cl.super:
+if prefix == word:
+completions.extend(
+api.getCompletions(context=super))
+else:
+completions.extend(
+api.getCompletions(start=word, context=super))
+for completion in completions:
+if not completion["context"]:
+entry = completion["completion"]
+else:
+entry = "{0} ({1})".format(
+completion["completion"],
+completion["context"]
+)
+if entry in completionsList:
+completionsList.remove(entry)
+if completion["pictureId"]:
+entry += "?{0}".format(completion["pictureId"])
+else:
+cont = False
+re = QRegExp(QRegExp.escape(entry) + "\?\d{,2}")
+for comp in completionsList:
+if re.exactMatch(comp):
+cont = True
+break
+if cont:
+continue
+if entry not in completionsList:
+completionsList.append(entry)
+break
+elif context:
 completions = api.getCompletions(context=word)
 for completion in completions:
 entry = completion["completion"]
 if completion["pictureId"]:
 entry += "?{0}".format(completion["pictureId"])
 continue
 if entry not in completionsList:
 completionsList.append(entry)
 return completionsList
-def getCompletionsFromDocument(self, editor, word, context, sep):
+def getCompletionsFromDocument(self, editor, word, context, sep, prefix, module):
 """
 Public method to determine autocompletion proposals from the document.
 @param editor reference to the editor object (QScintilla.Editor)
 @param word string to be completed (string)
 @param context flag indicating to autocomplete a context (boolean)
 @param sep separator string (string)
+@param prefix prefix of the word to be completed (string)
+@param module reference to the scanned module info (Module)
 @return list of possible completions (list of strings)
 """
-currentPos = editor.currentPosition()
 completionsList = []
-if context:
-word += sep
+prefixFound = False
+if prefix and module:
-if editor.isUtf8():
+line, col = editor.getCursorPosition()
-sword = word.encode("utf-8")
+if prefix in ["cls", "self"]:
-else:
+prefixFound = True
-sword = word
+for cl in module.classes.values():
-res = editor.findFirstTarget(sword, False,
+if line >= cl.lineno and \
-editor.autoCompletionCaseSensitivity(),
+(cl.endlineno == -1 or line <= cl.endlineno):
-False, begline=0, begindex=0, ws_=True)
+comps = []
-while res:
+for method in cl.methods.values():
-start, length = editor.getFoundTarget()
+if method.name == "__init__":
-pos = start + length
+continue
-if pos != currentPos:
+# determine icon type
-if context:
+if method.isPrivate():
-completion = ""
+iconID = Editor.MethodPrivateID
-else:
+elif method.isProtected():
-completion = word
+iconID = Editor.MethodProtectedID
-line, index = editor.lineIndexFromPosition(pos)
+else:
-curWord = editor.getWord(line, index, useWordChars=False)
+iconID = Editor.MethodID
-completion += curWord[len(completion):]
+if hasattr(method, "modifier"):
-if completion and completion not in completionsList:
+if (prefix == "cls" and \
-completionsList.append(
+method.modifier == method.Class) or \
-"{0}?{1}".format(completion, self.__fromDocumentID))
+prefix == "self":
+comps.append((method.name, iconID))
+else:
+# eric 5.1 cannot differentiate method types
+comps.append((method.name, iconID))
+if prefix != "cls":
+for attribute in cl.attributes.values():
+# determine icon type
+if attribute.isPrivate():
+iconID = Editor.AttributePrivateID
+elif attribute.isProtected():
+iconID = Editor.AttributeProtectedID
+else:
+iconID = Editor.AttributePrivateID
+comps.append((attribute.name, iconID))
+for attribute in cl.globals.values():
+# determine icon type
+if attribute.isPrivate():
+iconID = Editor.AttributePrivateID
+elif attribute.isProtected():
+iconID = Editor.AttributeProtectedID
+else:
+iconID = Editor.AttributePrivateID
+comps.append((attribute.name, iconID))
+if word != prefix:
+completionsList.extend(
+["{0}?{1}".format(c[0], c[1])
+for c in comps if c[0].startswith(word)])
+else:
+completionsList.extend(
+["{0}?{1}".format(c[0], c[1])
+for c in comps])
+break
+else:
+# possibly completing a named class attribute or method
+if prefix in module.classes:
+prefixFound = True
+cl = module.classes[prefix]
+comps = []
+for method in cl.methods.values():
+if method.name == "__init__":
+continue
+if not hasattr(method, "modifier"):
+# eric 5.1 cannot differentiate method types
+continue
+if method.modifier in [method.Class, method.Static]:
+# determine icon type
+if method.isPrivate():
+iconID = Editor.MethodPrivateID
+elif method.isProtected():
+iconID = Editor.MethodProtectedID
+else:
+iconID = Editor.MethodID
+comps.append((method.name, iconID))
+for attribute in cl.globals.values():
+# determine icon type
+if attribute.isPrivate():
+iconID = Editor.AttributePrivateID
+elif attribute.isProtected():
+iconID = Editor.AttributeProtectedID
+else:
+iconID = Editor.AttributePrivateID
+comps.append((attribute.name, iconID))
+if word != prefix:
+completionsList.extend(
+["{0}?{1}".format(c[0], c[1])
+for c in comps if c[0].startswith(word)])
+else:
+completionsList.extend(
+["{0}?{1}".format(c[0], c[1])
+for c in comps])
+if not prefixFound:
+currentPos = editor.currentPosition()
+if context:
+word += sep
-res = editor.findNextTarget()
+if editor.isUtf8():
+sword = word.encode("utf-8")
+else:
+sword = word
+res = editor.findFirstTarget(sword, False,
+editor.autoCompletionCaseSensitivity(),
+False, begline=0, begindex=0, ws_=True)
+while res:
+start, length = editor.getFoundTarget()
+pos = start + length
+if pos != currentPos:
+if context:
+completion = ""
+else:
+completion = word
+line, index = editor.lineIndexFromPosition(pos)
+curWord = editor.getWord(line, index, useWordChars=False)
+completion += curWord[len(completion):]
+if completion and completion not in completionsList:
+completionsList.append(
+"{0}?{1}".format(completion, self.__fromDocumentID))
+res = editor.findNextTarget()
 completionsList.sort()
 return completionsList
 ###########################
 if language == "":
 return
 line, col = editor.lineIndexFromPosition(pos)
 wc = re.sub("\w", "", editor.wordCharacters())
+pat = re.compile("\w{0}".format(re.escape(wc)))
 text = editor.text(line)
 while col > 0 and \
-(not text[col - 1].isalnum() or \
+not pat.match(text[col - 1]):
-(wc and text[col - 1] not in wc)):
 col -= 1
 word = editor.getWordLeft(line, col)
+prefix = ""
+mod = None
+beg = editor.text(line)[:col]
+col = len(beg)
+wsep = editor.getLexer().autoCompletionWordSeparators()
+if wsep:
+if beg[col - 1] in wsep:
+col -= 1
+else:
+while col >= 0 and beg[col - 1] not in wsep + [" ", "\t"]:
+col -= 1
+if col >= 0:
+col -= 1
+prefix = editor.getWordLeft(line, col)
+if editor.isPy2File() or editor.isPy3File():
+src = editor.text()
+fn = editor.getFileName()
+if fn is None:
+fn = ""
+mod = Module("", fn, imp.PY_SOURCE)
+mod.scan(src)
 apiCalltips = []
 projectCalltips = []
+documentCalltips = []
 if self.__plugin.getPreferences("AutoCompletionSource") & AcsAPIs:
 api = self.__apisManager.getAPIs(language)
 if api is not None:
-apiCalltips = api.getCalltips(word, commas, self.__lastContext,
+apiCalltips = self.__getApiCalltips(
-self.__lastFullContext,
+api, word, commas, prefix, mod, editor)
-self.__plugin.getPreferences("CallTipsContextShown"))
 if self.__plugin.getPreferences("AutoCompletionSource") & AcsProject:
 api = self.__apisManager.getAPIs(ApisNameProject)
-projectCalltips = api.getCalltips(word, commas, self.__lastContext,
+projectCalltips = self.__getApiCalltips(
+api, word, commas, prefix, mod, editor)
+if self.__plugin.getPreferences("AutoCompletionSource") & AcsDocument:
+documentCalltips = self.__getCalltipsFromDocument(
+word, prefix, mod, editor)
+return sorted(
+set(apiCalltips)
+.union(set(projectCalltips))
+.union(set(documentCalltips))
+)
+def __getApiCalltips(self, api, word, commas, prefix, module, editor):
+"""
+Private method to determine calltips from APIs.
+@param api reference to the API object to be used (APIsManager.DbAPIs)
+@param word function to get calltips for (string)
+@param commas minimum number of commas contained in the calltip (integer)
+@param prefix prefix of the word to be completed (string)
+@param module reference to the scanned module info (Module)
+@param editor reference to the editor object (QScintilla.Editor)
+@return list of calltips (list of string)
+"""
+calltips = []
+if prefix and module and prefix == "self":
+line, col = editor.getCursorPosition()
+for cl in module.classes.values():
+if line >= cl.lineno and \
+(cl.endlineno == -1 or line <= cl.endlineno):
+for super in cl.super:
+calltips.extend(api.getCalltips(word, commas, super, None,
+self.__plugin.getPreferences("CallTipsContextShown")))
+break
+else:
+calltips = api.getCalltips(word, commas, self.__lastContext,
 self.__lastFullContext,
 self.__plugin.getPreferences("CallTipsContextShown"))
-return sorted(set(apiCalltips).union(set(projectCalltips)))
+return calltips
+def __getCalltipsFromDocument(self, word, prefix, module, editor):
+"""
+Private method to determine calltips from the document.
+@param word function to get calltips for (string)
+@param prefix prefix of the word to be completed (string)
+@param module reference to the scanned module info (Module)
+@param editor reference to the editor object (QScintilla.Editor)
+@return list of calltips (list of string)
+"""
+calltips = []
+if module:
+if prefix:
+# prefix can be 'self', 'cls' or a class name
+sep = editor.getLexer().autoCompletionWordSeparators()[0]
+if prefix in ["self", "cls"]:
+line, col = editor.getCursorPosition()
+for cl in module.classes.values():
+if line >= cl.lineno and \
+(cl.endlineno == -1 or line <= cl.endlineno):
+if word in cl.methods:
+method = cl.methods[word]
+if hasattr(method, "modifier"):
+if prefix == "self" or \
+(prefix == "cls" and \
+method.modifier == method.Class):
+calltips.append("{0}{1}{2}({3})".format(
+cl.name,
+sep,
+word,
+', '.join(method.parameters[1:])))
+else:
+# eric 5.1 cannot differentiate method types
+calltips.append("{0}{1}{2}({3})".format(
+cl.name,
+sep,
+word,
+', '.join(method.parameters[1:])))
+break
+else:
+if prefix in module.classes:
+cl = module.classes[prefix]
+if word in cl.methods:
+method = cl.methods[word]
+if hasattr(method, "modifier") and \
+method.modifier == method.Class:
+# only eric 5.2 and newer can differentiate method types
+calltips.append("{0}{1}{2}({3})".format(
+cl.name,
+sep,
+word,
+', '.join(method.parameters[1:])))
+else:
+# calltip for a module function or class
+if word in module.functions:
+fun = module.functions[word]
+calltips.append("{0}({1})".format(
+word,
+', '.join(fun.parameters[1:])))
+elif word in module.classes:
+cl = module.classes[word]
+if "__init__" in cl.methods:
+method = cl.methods["__init__"]
+calltips.append("{0}({1})".format(
+word,
+', '.join(method.parameters[1:])))
+return calltips

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/Assistant.py

AssistantEric/Assistant.py