forked from VimPlug/jedi
124 lines
3.4 KiB
Python
124 lines
3.4 KiB
Python
import os
|
|
import json
|
|
|
|
from jedi._compatibility import FileNotFoundError
|
|
from jedi.api.environment import DefaultEnvironment, \
|
|
get_default_environment, from_executable
|
|
from jedi.api.exceptions import WrongVersion
|
|
|
|
_CONFIG_FOLDER = '.jedi'
|
|
_CONTAINS_POTENTIAL_PROJECT = 'setup.py', '.git', '.hg', 'MANIFEST.in'
|
|
|
|
_SERIALIZER_VERSION = 1
|
|
|
|
|
|
class Project(object):
|
|
_serializer_ignore_attributes = ('_environment',)
|
|
_environment = None
|
|
_executable = None
|
|
|
|
@staticmethod
|
|
def _get_json_path(base_path):
|
|
return os.path.join(base_path, _CONFIG_FOLDER, 'project.json')
|
|
|
|
@classmethod
|
|
def load(cls, path):
|
|
"""
|
|
:param path: The path of the directory you want to use as a project.
|
|
"""
|
|
with open(cls._get_json_path(path)) as f:
|
|
version, data = json.load(f)
|
|
|
|
if version == 1:
|
|
self = cls.__new__()
|
|
self.__dict__.update(data)
|
|
if self._executable is not None:
|
|
self._environment = from_executable(self._executable)
|
|
return self
|
|
else:
|
|
raise WrongVersion(
|
|
"The Jedi version of this project seems newer than what we can handle."
|
|
)
|
|
|
|
def __init__(self, path, **kwargs):
|
|
"""
|
|
:param path: The base path for this project.
|
|
"""
|
|
def py2_comp(path, environment=None, sys_path=None):
|
|
self._path = path
|
|
if isinstance(environment, DefaultEnvironment):
|
|
self._environment = environment
|
|
self._executable = environment._executable
|
|
|
|
self._sys_path = sys_path
|
|
|
|
py2_comp(path, **kwargs)
|
|
|
|
def _get_sys_path(self, environment=None):
|
|
if self._sys_path is not None:
|
|
return self._sys_path
|
|
|
|
# The sys path has not been set explicitly.
|
|
if environment is None:
|
|
environment = self.get_environment()
|
|
|
|
return environment.get_sys_path()
|
|
|
|
def save(self):
|
|
data = dict(self.__dict__)
|
|
for attribute in self._serializer_ignore_attributes:
|
|
data.pop(attribute, None)
|
|
|
|
with open(self._get_json_path(self._path), 'wb') as f:
|
|
return json.dump((_SERIALIZER_VERSION, data), f)
|
|
|
|
def get_environment(self):
|
|
if self._environment is None:
|
|
return get_default_environment()
|
|
|
|
return self._environment
|
|
|
|
def __setstate__(self, state):
|
|
self.__dict__.update(state)
|
|
|
|
|
|
def _is_potential_project(path):
|
|
for name in _CONTAINS_POTENTIAL_PROJECT:
|
|
if os.path.exists(os.path.join(path)):
|
|
return True
|
|
return False
|
|
|
|
|
|
_cached_default_project = None
|
|
|
|
|
|
def get_default_project():
|
|
global _cached_default_project
|
|
if _cached_default_project is None:
|
|
# We are caching it here, because checking for it every time is just
|
|
# too much work.
|
|
_cached_default_project = _get_default_project()
|
|
return _cached_default_project
|
|
|
|
|
|
def _get_default_project():
|
|
previous = None
|
|
curdir = dir = os.path.realpath(os.curdir())
|
|
probable_path = None
|
|
while dir != previous:
|
|
try:
|
|
return Project.load(dir)
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
if probable_path is None and _is_potential_project(dir):
|
|
probable_path = dir
|
|
|
|
previous = dir
|
|
dir = os.path.dirname(dir)
|
|
else:
|
|
if probable_path is not None:
|
|
# TODO search for setup.py etc
|
|
return Project(probable_path)
|
|
return Project(curdir)
|