env.py

import sublime
import threading, uuid
from uuid import uuid4
import dotensime, dotsession
from paths import *

envLock = threading.RLock()
ensime_envs = {}


def for_window(window):
    if window:
        if window.id() in ensime_envs:
            return ensime_envs[window.id()]
        envLock.acquire()
        try:
            if not (window.id() in ensime_envs):
                # protection against reentrant EnsimeEnvironment calls
                ensime_envs[window.id()] = None
                ensime_envs[window.id()] = EnsimeEnvironment(window)
            return ensime_envs[window.id()]
        finally:
            envLock.release()
    return None


class EnsimeEnvironment(object):
    def __init__(self, window):
        self.w = window
        self.recalc()  # might only see empty window.folders(), so initialized values will be bogus
        sublime.set_timeout(self.__deferred_init__, 500)

    def __deferred_init__(self):
        self.recalc()
        from ensime import Daemon

        v = self.w.active_view()
        if v is not None:
            Daemon(v).on_activated()  # recolorize

    @property
    def project_root(self):
        return decode_path(self._project_root)

    @property
    def project_config(self):
        config = self._project_config
        if self.settings.get("os_independent_paths_in_dot_ensime"):
            if type(config) == list:
                i = 0
                while i < len(config):
                    key = config[i]
                    literal_keys = [":root-dir", ":target"]
                    list_keys = [":compile-deps", ":compile-jars", ":runtime-deps", ":runtime-jars", ":test-deps",
                                 ":sources", ":reference-source-roots"]
                    if str(key) in literal_keys:
                        config[i + 1] = decode_path(config[i + 1])
                    elif str(key) in list_keys:
                        config[i + 1] = map(lambda path: decode_path(path), config[i + 1])
                    else:
                        pass
                    i += 2
        return config

    @property
    def session_file(self):
        return (self.project_root + os.sep + ".ensime_session") if self.project_root else None

    def recalc(self):
        # plugin-wide stuff (immutable)
        self.settings = sublime.load_settings("Ensime.sublime-settings")
        server_dir = self.settings.get("ensime_server_path", "Ensime" + os.sep + "server")
        self.server_path = (server_dir
                            if os.path.isabs(server_dir)
                            else os.path.join(sublime.packages_path(), server_dir))
        self.ensime_executable = (self.server_path + os.sep +
                                  ("bin\\server.bat" if os.name == 'nt'
                                   else "bin/server"))
        self.ensime_args = ""  # TODO Should be loaded from .ensime file
        self.plugin_root = os.path.normpath(os.path.join(self.server_path, ".."))
        self.log_root = os.path.normpath(os.path.join(self.plugin_root, "logs"))

        # instance-specific stuff (immutable)
        (root, conf, _) = dotensime.load(self.w)
        self._project_root = root
        self._project_config = conf
        self.valid = self.project_config != None

        # system stuff (mutable)
        self.session_id = uuid4()
        self.running = False
        self.controller = None  # injected by EnsimeStartup to ensure smooth reloading
        self.compiler_ready = False

        # TODO: find a better place for this beast
        class NoteStorage(object):
            def __init__(self):
                self.data = []
                self.normalized_cache = {}
                self.per_file_cache = {}

            def append(self, data):
                self.data += data
                for datum in data:
                    if not datum.file_name in self.normalized_cache:
                        self.normalized_cache[datum.file_name] = normalize_path(datum.file_name)
                    file_name = self.normalized_cache[datum.file_name]
                    if not file_name in self.per_file_cache:
                        self.per_file_cache[file_name] = []
                    self.per_file_cache[file_name].append(datum)

            def filter(self, pred):
                dropouts = set(
                    map(lambda n: self.normalized_cache[n.file_name], filter(lambda n: not pred(n), self.data)))
                # doesn't take into account pathological cases when a "*.scala" file
                # is actually a symlink to something without a ".scala" extension
                for file_name in self.per_file_cache.keys():
                    if file_name in dropouts:
                        del self.per_file_cache[file_name]
                self.data = filter(pred, self.data)

            def clear(self):
                self.filter(lambda f: False)

            def for_file(self, file_name):
                if not file_name in self.normalized_cache:
                    self.normalized_cache[file_name] = normalize_path(file_name)
                file_name = self.normalized_cache[file_name]
                if not file_name in self.per_file_cache:
                    self.per_file_cache[file_name] = []
                return self.per_file_cache[file_name]

        # core stuff (mutable)
        self._notes = NoteStorage()
        self.notee = None
        # Tracks the most recent completion prefix that has been shown to yield empty
        # completion results. Use this so we don't repeatedly hit ensime for results
        # that don't exist.
        self.completion_ignore_prefix = None

        # debugger stuff (mutable)
        # didn't prefix it with "debugger_", because there are no name clashes yet
        self.profile_being_launched = None
        self.profile = None  # launch config used in current debug session
        self.breakpoints = []
        self.focus = None
        self.backtrace = None
        self.stackframe = None
        self.watchstate = None
        self._output = ""

        # load the session (if exists)
        self.load_session()

    # the guys below are made to be properties
    # because we do want to encapsulate them in objects
    # however doing that will prevent smooth development
    # if we put an object instance into a field, then it won't be reloaded by Sublime
    # when the corresponding source file is changed

    # this leads to a funny model, when env contains all shared state
    # and objects outside env are just bunches of pure functions that carry state around
    # state weaving is made implicit by the EnsimeCommon base class, but it's still there

    @property
    def rpc(self):
        from rpc import Rpc

        return Rpc(self)

    @property
    def notes(self):
        from ensime import Notes

        return Notes(self)

    @property
    def debugger(self):
        from ensime import Debugger

        return Debugger(self)

    @property
    def output(self):
        from ensime import Output

        return Output(self)

    @property
    def stack(self):
        from ensime import Stack

        return Stack(self)

    @property
    def watches(self):
        from ensime import Watches

        return Watches(self)

    # externalizable part of mutable state

    def load_session(self):
        session = dotsession.load(self)
        if session: self.breakpoints = session.breakpoints
        return session

    def save_session(self):
        session = dotsession.load(self) or dotsession.Session(breakpoints=[], launches=[], current_launch=None)
        session.breakpoints = self.breakpoints
        dotsession.save(self, session)