move mixin to compiled/fake to structure it better

jedi/evaluate/compiled/fake/_functools.pym

@@ -0,0 +1,9 @@
+class partial():
+    def __init__(self, func, *args, **keywords):
+        self.__func = func
+        self.__args = args
+        self.__keywords = keywords
+
+    def __call__(self, *args, **kwargs):
+        # I know this doesn't work in Python, but Jedi can this ;-)
+        return self.__func(*self.__args, *args, **self.keywords, **kwargs)

jedi/evaluate/compiled/fake/_io.pym

@@ -0,0 +1,3 @@
+class TextIOWrapper():
+    def __next__(self):
+        return ''

jedi/evaluate/compiled/fake/_sqlite3.pym

@@ -0,0 +1,26 @@
+def connect(database, timeout=None, isolation_level=None, detect_types=None, factory=None):
+    return Connection()
+
+
+class Connection():
+    def cursor(self):
+        return Cursor()
+
+
+class Cursor():
+    def cursor(self):
+        return Cursor()
+
+    def fetchone(self):
+        return Row()
+
+    def fetchmany(self, size=cursor.arraysize):
+        return [self.fetchone()]
+
+    def fetchall(self):
+        return [self.fetchone()]
+
+
+class Row():
+    def keys(self):
+        return ['']

jedi/evaluate/compiled/fake/_sre.pym

@@ -0,0 +1,99 @@
+def compile():
+    class SRE_Match():
+        endpos = 1
+        lastgroup = 0
+        lastindex = 1
+        pos = 0
+        string = 'a'
+        regs = ((0, 1),)
+
+        def __init__(self, pattern):
+            self.re = pattern
+
+        def start(self):
+            return 0
+
+        def end(self):
+            return 1
+
+        def span(self):
+            return 0, 1
+
+        def expand(self):
+            return ''
+
+        def group(self, nr):
+            return ''
+
+        def groupdict(self):
+            return {'a', 'a'}
+
+        def groups(self):
+            return ('a',)
+
+    class SRE_Pattern():
+        flags = 0
+        groupindex = {}
+        groups = 0
+        pattern = 'a'
+
+        def findall(self, string, pos=None, endpos=None):
+            """
+            findall(string[, pos[, endpos]]) --> list.
+            Return a list of all non-overlapping matches of pattern in string.
+            """
+            return ['a']
+
+        def finditer(self, string, pos=None, endpos=None):
+            """
+            finditer(string[, pos[, endpos]]) --> iterator.
+            Return an iterator over all non-overlapping matches for the
+            RE pattern in string. For each match, the iterator returns a
+            match object.
+            """
+            yield SRE_Match(self)
+
+        def match(self, string, pos=None, endpos=None):
+            """
+            match(string[, pos[, endpos]]) --> match object or None.
+            Matches zero or more characters at the beginning of the string
+            pattern
+            """
+            return SRE_Match(self)
+
+        def scanner(self, string, pos=None, endpos=None):
+            pass
+
+        def search(self, string, pos=None, endpos=None):
+            """
+            search(string[, pos[, endpos]]) --> match object or None.
+            Scan through string looking for a match, and return a corresponding
+            MatchObject instance. Return None if no position in the string matches.
+            """
+            return SRE_Match(self)
+
+        def split(self, string, maxsplit=0]):
+            """
+            split(string[, maxsplit = 0])  --> list.
+            Split string by the occurrences of pattern.
+            """
+            return ['a']
+
+        def sub(self, repl, string, count=0):
+            """
+            sub(repl, string[, count = 0]) --> newstring
+            Return the string obtained by replacing the leftmost non-overlapping
+            occurrences of pattern in string by the replacement repl.
+            """
+            return ''
+
+        def subn(self, repl, string, count=0):
+            """
+            subn(repl, string[, count = 0]) --> (newstring, number of subs)
+            Return the tuple (new_string, number_of_subs_made) found by replacing
+            the leftmost non-overlapping occurrences of pattern with the
+            replacement repl.
+            """
+            return ('', 1)
+
+    return SRE_Pattern()

jedi/evaluate/compiled/fake/_weakref.pym

@@ -0,0 +1,8 @@
+def proxy(object, callback=None):
+    return object
+
+class ref():
+    def __init__(self, object, callback=None):
+        self.__object = object
+    def __call__(self):
+        return self.__object

jedi/evaluate/compiled/fake/builtins.pym

@@ -0,0 +1,228 @@
+"""
+Pure Python implementation of some builtins.
+This code is not going to be executed anywhere.
+These implementations are not always correct, but should work as good as
+possible for the auto completion.
+"""
+
+
+def next(iterator, default=None):
+    if hasattr("next"):
+        return iterator.next()
+    else:
+        return iterator.__next__()
+    return default
+
+
+def iter(collection, sentinel=None):
+    if sentinel:
+        yield collection()
+    else:
+        for c in collection:
+            yield c
+
+
+def range(start, stop=None, step=1):
+    return [0]
+
+
+class file():
+    def __iter__(self):
+        yield ''
+    def next(self):
+        return ''
+
+
+class xrange():
+    # Attention: this function doesn't exist in Py3k (there it is range).
+    def __iter__(self):
+        yield 1
+
+    def count(self):
+        return 1
+
+    def index(self):
+        return 1
+
+
+#--------------------------------------------------------
+# descriptors
+#--------------------------------------------------------
+class property():
+    def __init__(self, fget, fset=None, fdel=None, doc=None):
+        self.fget = fget
+        self.fset = fset
+        self.fdel = fdel
+        self.__doc__ = doc
+
+    def __get__(self, obj, cls):
+        return self.fget(obj)
+
+    def __set__(self, obj, value):
+        self.fset(obj, value)
+
+    def __delete__(self, obj):
+        self.fdel(obj)
+
+    def setter(self, func):
+        self.fset = func
+        return self
+
+    def getter(self, func):
+        self.fget = func
+        return self
+
+    def deleter(self, func):
+        self.fdel = func
+        return self
+
+
+class staticmethod():
+    def __init__(self, func):
+        self.__func = func
+
+    def __get__(self, obj, cls):
+        return self.__func
+
+
+class classmethod():
+    def __init__(self, func):
+        self.__func = func
+
+    def __get__(self, obj, cls):
+        def _method(*args, **kwargs):
+            return self.__func(cls, *args, **kwargs)
+        return _method
+
+
+#--------------------------------------------------------
+# array stuff
+#--------------------------------------------------------
+class list():
+    def __init__(self, iterable=[]):
+        self.__iterable = []
+        for i in iterable:
+            self.__iterable += [i]
+
+    def __iter__(self):
+        for i in self.__iterable:
+            yield i
+
+    def __getitem__(self, y):
+        return self.__iterable[y]
+
+    def pop(self):
+        return self.__iterable[-1]
+
+
+class tuple():
+    def __init__(self, iterable=[]):
+        self.__iterable = []
+        for i in iterable:
+            self.__iterable += [i]
+
+    def __iter__(self):
+        for i in self.__iterable:
+            yield i
+
+    def __getitem__(self, y):
+        return self.__iterable[y]
+
+    def index(self):
+        return 1
+
+    def count(self):
+        return 1
+
+
+class set():
+    def __init__(self, iterable=[]):
+        self.__iterable = iterable
+
+    def __iter__(self):
+        for i in self.__iterable:
+            yield i
+
+    def pop(self):
+        return self.__iterable.pop()
+
+    def copy(self):
+        return self
+
+    def difference(self, other):
+        return self - other
+
+    def intersection(self, other):
+        return self & other
+
+    def symmetric_difference(self, other):
+        return self ^ other
+
+    def union(self, other):
+        return self | other
+
+
+class frozenset():
+    def __init__(self, iterable=[]):
+        self.__iterable = iterable
+
+    def __iter__(self):
+        for i in self.__iterable:
+            yield i
+
+    def copy(self):
+        return self
+
+
+class dict():
+    def __init__(self, **elements):
+        self.__elements = elements
+
+    def clear(self):
+        # has a strange docstr
+        pass
+
+    def get(self, k, d=None):
+        # TODO implement
+        try:
+            #return self.__elements[k]
+            pass
+        except KeyError:
+            return d
+
+
+class reversed():
+    def __init__(self, sequence):
+        self.__sequence = sequence
+
+    def __iter__(self):
+        for i in self.__sequence:
+            yield i
+
+    def __next__(self):
+        return next(self.__iter__())
+
+    def next(self):
+        return next(self.__iter__())
+
+
+def sorted(iterable, cmp=None, key=None, reverse=False):
+    return iterable
+
+
+#--------------------------------------------------------
+# basic types
+#--------------------------------------------------------
+class int():
+    def __init__(self, x, base=None):
+        pass
+
+
+class str():
+    def __init__(self, obj):
+        pass
+
+
+class type():
+    def mro():
+        return [object]

jedi/evaluate/compiled/fake/datetime.pym

@@ -0,0 +1,4 @@
+class datetime():
+    @staticmethod
+    def now():
+        return datetime()

jedi/evaluate/compiled/fake/posix.pym

@@ -0,0 +1,5 @@
+def getcwd():
+    return ''
+
+def getcwdu():
+    return ''