mirror of
https://github.com/davidhalter/jedi.git
synced 2025-12-07 22:44:27 +08:00
122 lines
3.5 KiB
Python
122 lines
3.5 KiB
Python
import imp
|
|
import sys
|
|
import os
|
|
|
|
import debug
|
|
import parsing
|
|
import builtin
|
|
|
|
files = {}
|
|
load_module_cb = None
|
|
module_find_path = sys.path[1:]
|
|
|
|
|
|
|
|
class ModuleNotFound(Exception):
|
|
pass
|
|
|
|
|
|
class File(object):
|
|
"""
|
|
Manages all files, that are parsed and caches them.
|
|
|
|
:param source: The source code of the file.
|
|
:param module_path: The module path of the file.
|
|
"""
|
|
module_cache = {}
|
|
|
|
def __init__(self, module_path, source):
|
|
self.source = source
|
|
self.module_path = module_path
|
|
self._line_cache = None
|
|
self._parser = None
|
|
|
|
@property
|
|
def parser(self):
|
|
if self._parser:
|
|
return self._parser
|
|
if not self.module_path and not self.source:
|
|
raise AttributeError("Submit a module name or the source code")
|
|
elif self.module_path:
|
|
# check the cache
|
|
try:
|
|
timestamp, _parser = File.module_cache[self.module_path]
|
|
if timestamp == os.path.getmtime(self.module_path):
|
|
debug.dbg('hit cache')
|
|
return _parser
|
|
except:
|
|
pass
|
|
|
|
return self._load_module()
|
|
|
|
def _load_module(self):
|
|
self._parser = parsing.PyFuzzyParser(self.source, self.module_path)
|
|
del self.source # efficiency
|
|
|
|
# insert into cache
|
|
to_cache = (os.path.getmtime(self.module_path), self._parser)
|
|
File.module_cache[self.module_path] = to_cache
|
|
return self._parser
|
|
|
|
def find_module(current_module, point_path):
|
|
"""
|
|
Find a module with a path (of the module, like usb.backend.libusb10).
|
|
|
|
Relative imports: http://www.python.org/dev/peps/pep-0328
|
|
are only used like this (py3000): from .module import name.
|
|
|
|
:param current_ns_path: A path to the current namespace.
|
|
:param point_path: A name from the parser.
|
|
:return: The rest of the path, and the module top scope.
|
|
"""
|
|
def follow_str(ns, string):
|
|
debug.dbg('follow_module', ns, string)
|
|
if ns:
|
|
path = [ns[1]]
|
|
else:
|
|
path = None
|
|
debug.dbg('search_module', string, path)
|
|
try:
|
|
i = imp.find_module(string, path)
|
|
except ImportError:
|
|
# find builtins (ommit path):
|
|
i = imp.find_module(string)
|
|
if i[0]:
|
|
# if the import has a file descriptor, it cannot be a builtin.
|
|
raise
|
|
return i
|
|
|
|
# TODO handle relative paths - they are included int the import object
|
|
current_namespace = None
|
|
sys.path.insert(0, os.path.dirname(current_module.module_path))
|
|
# now execute those paths
|
|
rest = []
|
|
for i, s in enumerate(point_path):
|
|
try:
|
|
current_namespace = follow_str(current_namespace, s)
|
|
except ImportError:
|
|
if current_namespace:
|
|
rest = point_path[i:]
|
|
else:
|
|
raise ModuleNotFound(
|
|
'The module you searched has not been found')
|
|
|
|
sys.path.pop(0)
|
|
path = current_namespace[1]
|
|
is_package_directory = current_namespace[2][2] == imp.PKG_DIRECTORY
|
|
|
|
if is_package_directory or current_namespace[0]:
|
|
# is a directory module
|
|
if is_package_directory:
|
|
path += '/__init__.py'
|
|
# python2.5 cannot cope with the `with` statement
|
|
#with open(path) as f:
|
|
# source = f.read()
|
|
source = open(path).read()
|
|
else:
|
|
source = current_namespace[0].read()
|
|
f = File(path, source)
|
|
else:
|
|
f = builtin.Parser(path)
|
|
return f.parser.top, rest
|