temp save

Author: zhengbli

tsserver/tsc.js

@@ -1,14 +1,12 @@
-from ..libs import global_vars
+from ..libs import cli
+from ..libs.view_helpers import active_view, get_info
+from ..libs.panel_manager import get_panel_manager
+from ..listeners.project_error_list import start_timer
 from .base_command import TypeScriptBaseWindowCommand
 
 class TypescriptProjectErrorList(TypeScriptBaseWindowCommand):
 
-    error_list_panel = None
-
     def run(self):
-        if not TypescriptProjectErrorList.error_list_panel:
-            TypescriptProjectErrorList.error_list_panel = self.window.create_output_panel("errorList")
-
         if not cli.node_client.workerStarted():
             view = active_view()
             # start worker process
@@ -17,11 +15,8 @@ def run(self):
             get_info(view)
             # send the first error request
             cli.service.request_get_err_for_project(0, view.file_name())
+            start_timer()
 
-        global_vars._is_worker_active = True
-        self.window.run_command("show_panel", {"panel": "output.errorList"})
-
-    @staticmethod
-    def is_worker_active():
-        panel = TypescriptProjectErrorList.error_list_panel  
-        return panel is not None and is_view_visible(panel)
+        panel_manager = get_panel_manager()
+        panel_manager.add_panel("errorlist")
+        panel_manager.show_panel("errorlist")

tsserver/tsserver.js

@@ -1,9 +1,10 @@
-from .node_client import NodeCommClient
+from .node_client import NodeCommClient
 from .popup_manager import PopupManager
 from .service_proxy import ServiceProxy
 from .editor_client import cli, EditorClient
 from .popup_manager import get_popup_manager
 from .logger import log
+from .panel_manager import get_panel_manager
 from . import logger
 __all__ = [
     'cli',
@@ -15,5 +16,6 @@
     'json_helpers',
     'PopupManager',
     'ServiceProxy',
-    'work_scheduler'
+    'work_scheduler',
+    'get_panel_manager'
 ]

typescript/commands/error_list.py

@@ -36,7 +36,6 @@ def __init__(self):
         self.translate_tab_to_spaces = False
         self.ts_auto_format_enabled = True
         self.ts_auto_indent_enabled = True
-        self.project_error_list_enabled = False
         self.auto_match_enabled = True
 
     def initialize(self):
@@ -70,9 +69,6 @@ def initialize(self):
             settings.add_on_change(setting_name, self.load_format_settings)
         self.load_format_settings()
 
-        # project_error_list should only be set once.
-        self.project_error_list_enabled = settings.get('project_error_list')
-
         self.initialized = True
 
     def load_format_settings(self):

typescript/libs/__init__.py

@@ -50,9 +50,4 @@ def get_node_path():
 VALID_COMPLETION_ID_PATTERN = re.compile("[a-zA-Z_$\.][\w$\.]*\Z")
 
 # idle time length in millisecond
-IDLE_TIME_LENGTH = 200
-
-# if the worker process for error list is running
-_is_worker_active = False
-def is_worker_active():
-    return _is_worker_active
+IDLE_TIME_LENGTH = 200

typescript/libs/editor_client.py

@@ -45,29 +45,27 @@ def sendCmdToWorkerAsync(self, cmd, cb): pass
 
 class NodeCommClient(CommClient):
     __CONTENT_LENGTH_HEADER = b"Content-Length: "
+    stop_worker = False
 
-    def __init__(self, script_path):
+    def __init__(self, scriptPath):
         """
         Starts a node client (if not already started) and communicate with it. 
         The script file to run is passed to the constructor.
         """
 
         self.asyncReq = {}
         self.__serverProc = None
-        self.script_path = script_path
+        self.__workerProc = None
+        self.script_path = scriptPath
 
         # create response and event queues
         self.__msgq = queue.Queue()
         self.__eventq = queue.Queue()
         self.__worker_eventq = queue.Queue()
 
-        # set worker to None at init
-        self.__workerProc = None
-
         # start node process
         pref_settings = sublime.load_settings('Preferences.sublime-settings')
         node_path = pref_settings.get('node_path')
-        project_error_list_enabled = pref_settings.get('project_error_list')
         if node_path:
             node_path = os.path.expandvars(node_path)
         if not node_path:
@@ -89,26 +87,29 @@ def __init__(self, script_path):
                     # so only use it if on Windows
                     si = subprocess.STARTUPINFO()
                     si.dwFlags |= subprocess.SW_HIDE | subprocess.STARTF_USESHOWWINDOW
-                    self.__serverProc = subprocess.Popen([node_path, script_path],
+                    self.__serverProc = subprocess.Popen([node_path, scriptPath],
                                                          stdin=subprocess.PIPE, stdout=subprocess.PIPE, startupinfo=si)
                 else:
-                    log.debug("opening " + node_path + " " + script_path)
-                    self.__serverProc = subprocess.Popen([node_path, script_path],
+                    log.debug("opening " + node_path + " " + scriptPath)
+                    self.__serverProc = subprocess.Popen([node_path, scriptPath],
                                                          stdin=subprocess.PIPE, stdout=subprocess.PIPE)
             except:
                 self.__serverProc = None
         # start reader thread
         if self.__serverProc and (not self.__serverProc.poll()):
             log.debug("server proc " + str(self.__serverProc))
             log.debug("starting reader thread")
-            readerThread = threading.Thread(target=NodeCommClient.__reader, args=(self.__serverProc.stdout, self.__msgq, self.__eventq, self.asyncReq, self.__serverProc))
+            readerThread = threading.Thread(target=NodeCommClient.__reader, args=(
+                self.__serverProc.stdout, self.__msgq, self.__eventq, self.asyncReq, self.__serverProc))
             readerThread.daemon = True
             readerThread.start()
 
         self.__debugProc = None
         self.__breakpoints = []
 
     def startWorker(self):
+        NodeCommClient.stop_worker = False
+
         node_path = global_vars.get_node_path()
         if os.name == "nt":
             si = subprocess.STARTUPINFO()
@@ -120,14 +121,18 @@ def startWorker(self):
             self.__workerProc = subprocess.Popen(
                 [node_path, self.script_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 
-        # start the worker thread
-        if self.__workerProc and not self.__workerProc.poll():
-            log.debug("worker proc {0}".format(self.__workerProc))
-            log.debug("starting worker thread")
-            self.worker_thread = threading.Thread(target=NodeCommClient.__reader,
-                args=(self.__workerProc.stdout, self.__msgq, self.__worker_eventq, self.asyncReq, self.__workerProc))
-            self.worker_thread.daemon = True
-            self.worker_thread.start()
+        # start reader thread
+        if self.__serverProc and (not self.__serverProc.poll()):
+            log.debug("server proc " + str(self.__serverProc))
+            log.debug("starting reader thread")
+            readerThread = threading.Thread(target=NodeCommClient.__reader, args=(
+                self.__serverProc.stdout, self.__msgq, self.__eventq, self.asyncReq, self.__serverProc))
+            readerThread.daemon = True
+            readerThread.start()
+            log.debug("readerThread.is_alive: {0}".format(readerThread.is_alive()))
+
+    def stopWorker(self):
+        NodeCommClient.stop_worker = True
 
     def serverStarted(self):
         return self.__serverProc is not None
@@ -289,7 +294,6 @@ def __readMsg(stream, msgq, eventq, asyncReq, proc):
             #         header if header else 'None'
             #     )
             # )
-
             if len(header) == 0:
                 if state == 'init':
                     # log.info('0 byte line in stream when expecting header')
@@ -326,11 +330,18 @@ def __readMsg(stream, msgq, eventq, asyncReq, proc):
 
     @staticmethod
     def __reader(stream, msgq, eventq, asyncReq, proc):
-        """
-        Main function for reader thread
-        """
+        """ Main function for reader thread """
         while True:
             if NodeCommClient.__readMsg(stream, msgq, eventq, asyncReq, proc):
+                log.debug("server exited")
+                return
+
+    @staticmethod
+    def __worker_reader(stream, msgq, eventq, asyncReq, proc):
+        """ Main function for worker thread """
+        while True:
+            if NodeCommClient.__readMsg(stream, msgq, eventq, asyncReq, proc) or NodeCommClient.stop_worker:
+                log.debug("worker exited")
                 return
 
     @staticmethod