start introducing the compiled.fake module that fakes builtin code

2014-01-10 22:58:49 +01:00
parent 400b0a4aa7
commit 78cc015b9d
2 changed files with 128 additions and 5 deletions
@@ -0,0 +1,106 @@
+"""
+Loads functions that are mixed in to the standard library. E.g. builtins are
+written in C (binaries), but my autocompletion only understands Python code. By
+mixing in Python code, the autocompletion should work much better for builtins.
+"""
+
+import re
+import os
+import inspect
+
+from jedi._compatibility import is_py3k
+from jedi.parser import Parser
+
+modules = {}
+
+
+def _load_fakes(module_name):
+    regex = r'^(def|class)\s+([\w\d]+)'
+
+    def process_code(code, depth=0):
+        funcs = {}
+        matches = list(re.finditer(regex, code, re.MULTILINE))
+        positions = [m.start() for m in matches]
+        for i, pos in enumerate(positions):
+            try:
+                code_block = code[pos:positions[i + 1]]
+            except IndexError:
+                code_block = code[pos:len(code)]
+            structure_name = matches[i].group(1)
+            name = matches[i].group(2)
+            if structure_name == 'def':
+                funcs[name] = code_block
+            elif structure_name == 'class':
+                if depth > 0:
+                    raise NotImplementedError()
+
+                # remove class line
+                c = re.sub(r'^[^\n]+', '', code_block)
+                # remove whitespace
+                c = re.compile(r'^[ ]{4}', re.MULTILINE).sub('', c)
+
+                funcs[name] = process_code(c)
+            else:
+                raise NotImplementedError()
+        return funcs
+
+    # sometimes there are stupid endings like `_sqlite3.cpython-32mu`
+    module_name = re.sub(r'\..*', '', module_name)
+
+    if module_name == '__builtin__' and not is_py3k:
+        module_name = 'builtins'
+    path = os.path.dirname(os.path.abspath(__file__))
+    try:
+        with open(os.path.join(path, 'mixin', module_name) + '.pym') as f:
+            s = f.read()
+    except IOError:
+        return {}
+    else:
+        mixin_dct = process_code(s)
+        if is_py3k and module_name == 'builtins':
+            # in the case of Py3k xrange is now range
+            mixin_dct['range'] = mixin_dct['xrange']
+        return mixin_dct
+
+
+def _load_module(module):
+    module_name = module.__name__
+    try:
+        return modules[module_name]
+    except KeyError:
+        path = os.path.dirname(os.path.abspath(__file__))
+        try:
+            with open(os.path.join(path, 'fake', module_name) + '.pym') as f:
+                source = f.read()
+        except IOError:
+            return {}
+        module = Parser(source).module
+        modules[module_name] = module
+        return module
+
+
+def get_faked(module, obj):
+    def from_scope(scope, obj):
+        for s in scope.subscopes:
+            if s.name == obj.name:
+                return s
+
+    mod = _load_module(module)
+
+    # Having the module as a `parser.representation.module`, we need to scan
+    # for methods.
+    if is_class_instance(obj):
+        obj = obj.__class__
+    if inspect.isbuiltin(obj):
+        return from_scope(mod, obj)
+    elif not inspect.isclass(obj):
+        # object is a method or descriptor
+        cls = obj.__objclass__
+        return from_scope(from_scope(mod, cls), obj)
+
+
+def is_class_instance(obj):
+    """Like inspect.* methods."""
+    return not (inspect.isclass(obj) or inspect.ismodule(obj)
+                or inspect.isbuiltin(obj) or inspect.ismethod(obj)
+                or inspect.ismethoddescriptor(obj))