|
|
# -*- coding: utf-8 -*-
|
|
|
""" python-part of PythonCompleter
|
|
|
|
|
|
code/ideas taken from IPython, but IPython doesn't work with PythonQt...
|
|
|
|
|
|
Authors:
|
|
|
"Melven Zoellner" <melven@topen.org>
|
|
|
"""
|
|
|
|
|
|
|
|
|
# system imports
|
|
|
import sys
|
|
|
|
|
|
import rlcompleter
|
|
|
import imp
|
|
|
|
|
|
|
|
|
from __main__ import PYMODULES
|
|
|
sys.path.append(PYMODULES+'/pygments/')
|
|
|
sys.path.insert(0,PYMODULES)
|
|
|
|
|
|
# Third-party imports
|
|
|
from pygments.lexers import PythonLexer
|
|
|
from pygments.token import Token, is_token_subtype
|
|
|
|
|
|
from module_completion import module_completion
|
|
|
|
|
|
|
|
|
# undo sys.path modifications
|
|
|
#if not dot_in_path:
|
|
|
# sys.path.remove('/opt/SocExplorer/python')
|
|
|
|
|
|
|
|
|
# ugly fix to make rlcompleter work with PythonQt:
|
|
|
# problem:
|
|
|
# hasattr raises SystemError for
|
|
|
# <type 'PythonQt.PythonQtInstanceWrapper'>
|
|
|
# this is probably a PythonQt-problem and should be fixed there?
|
|
|
def _get_class_members(klass):
|
|
|
ret = dir(klass)
|
|
|
try:
|
|
|
for base in klass.__bases__:
|
|
|
ret = ret + _get_class_members(base)
|
|
|
except SystemError:
|
|
|
pass
|
|
|
return ret
|
|
|
|
|
|
rlcompleter.get_class_members = _get_class_members
|
|
|
|
|
|
|
|
|
def pythonqt_specific_completions(context, parent):
|
|
|
""" determines pythonqt-specific completions,
|
|
|
currently it adds only named children of QObjects """
|
|
|
try:
|
|
|
completions = list()
|
|
|
# for completions for instances of PythonQt-Wrapper classes
|
|
|
# we need to do some ugly stuff here
|
|
|
# 1. get the base name
|
|
|
base_name = '.'.join(context[0:-1])
|
|
|
# 2. eval the name in the parent context
|
|
|
base_object = eval(base_name, parent.__dict__)
|
|
|
# 2. check if it is really an instance of a PythonQt-Wrapper class
|
|
|
if repr(type(type(base_object))) == "<type 'PythonQt.PythonQtClassWrapper'>":
|
|
|
# 3. look for the names of it's children
|
|
|
if( hasattr(base_object, 'children') and callable(base_object.children) ):
|
|
|
for child in base_object.children():
|
|
|
if( hasattr(child, 'objectName') and child.objectName != '' ):
|
|
|
completions.append(child.objectName)
|
|
|
return completions
|
|
|
except:
|
|
|
return list()
|
|
|
|
|
|
def autocompleteCode(code, parent = sys.modules['__main__']):
|
|
|
""" try to find useful completions for code """
|
|
|
|
|
|
# get last line and context
|
|
|
all_lines = code.split('\n')
|
|
|
line = all_lines[-1]
|
|
|
context = get_context(line)
|
|
|
word = '.'.join(context)
|
|
|
|
|
|
|
|
|
completions = None
|
|
|
|
|
|
# module completion
|
|
|
if line.startswith('from ') or line.startswith('import '):
|
|
|
completions = module_completion(line)
|
|
|
|
|
|
|
|
|
# rlcompleter
|
|
|
if completions is None:
|
|
|
completer = rlcompleter.Completer(parent.__dict__)
|
|
|
if '.' in word:
|
|
|
completions = completer.attr_matches(word)
|
|
|
|
|
|
# also append PythonQt-specific completions
|
|
|
completions += pythonqt_specific_completions(context, parent)
|
|
|
|
|
|
else:
|
|
|
completions = completer.global_matches(word)
|
|
|
|
|
|
# we only need the last part of the completion
|
|
|
# (e.g. my_function from my_class.my_function)
|
|
|
completions = [ c.split('.')[-1] for c in completions ]
|
|
|
|
|
|
# sort completions and remove duplicates
|
|
|
completions = sorted(set(completions), key=(lambda s: s.lower()))
|
|
|
|
|
|
# hide all members that begin with '_',
|
|
|
# except the user starts a name with '_'
|
|
|
if not (context and context[-1].startswith('_')):
|
|
|
completions = [c for c in completions if not c.startswith('_')]
|
|
|
|
|
|
# return results
|
|
|
return completions
|
|
|
|
|
|
|
|
|
|
|
|
def get_context(string):
|
|
|
""" Assuming the cursor is at the end of the specified string, get the
|
|
|
context (a list of names) for the symbol at cursor position.
|
|
|
"""
|
|
|
lexer = PythonLexer()
|
|
|
context = []
|
|
|
reversed_tokens = list(lexer.get_tokens(string))
|
|
|
reversed_tokens.reverse()
|
|
|
|
|
|
# Pygments often tacks on a newline when none is specified in the input.
|
|
|
# Remove this newline.
|
|
|
if reversed_tokens and reversed_tokens[0][1].endswith('\n') and \
|
|
|
not string.endswith('\n'):
|
|
|
reversed_tokens.pop(0)
|
|
|
|
|
|
current_op = ''
|
|
|
for token, text in reversed_tokens:
|
|
|
|
|
|
if is_token_subtype(token, Token.Name):
|
|
|
|
|
|
# Handle a trailing separator, e.g 'foo.bar.'
|
|
|
if current_op == '.':
|
|
|
if not context:
|
|
|
context.insert(0, '')
|
|
|
|
|
|
# Handle non-separator operators and punction.
|
|
|
elif current_op:
|
|
|
break
|
|
|
|
|
|
context.insert(0, text)
|
|
|
current_op = ''
|
|
|
|
|
|
# Pygments doesn't understand that, e.g., '->' is a single operator
|
|
|
# in C++. This is why we have to build up an operator from
|
|
|
# potentially several tokens.
|
|
|
elif token is Token.Operator or token is Token.Punctuation:
|
|
|
current_op = text + current_op
|
|
|
|
|
|
# Break on anything that is not a Operator, Punctuation, or Name.
|
|
|
else:
|
|
|
break
|
|
|
|
|
|
return context
|
|
|
|
