Add settings for worker thread, and add worker version server proxies

Author: zhengbli

Preferences.sublime-settings

@@ -1,4 +1,5 @@
 {
     "typescript_auto_format": true,
-    "auto_complete_commit_on_tab": true
+    "auto_complete_commit_on_tab": true,
+    "project_error_list": false
 }

TypeScript.sublime-commands

@@ -10,5 +10,6 @@
  { "caption" : "TypeScript: Rename", "command": "typescript_rename" },
  { "caption" : "TypeScript: PasteAndFormat", "command": "typescript_paste_and_format" },
  { "caption" : "TypeScript: FormatLine", "command": "typescript_format_line" },
- { "caption" : "TypeScript: FormatBlock", "command": "typescript_format_brackets" }
+ { "caption" : "TypeScript: FormatBlock", "command": "typescript_format_brackets" },
+ { "caption" : "TypeScript: ShowErrorList", "command": "typescript_project_error_list" }
 ]

typescript/commands/__init__.py

@@ -1,4 +1,4 @@
-from .error_info import TypescriptErrorInfo
+from .error_info import TypescriptErrorInfo, TypescriptProjectErrorList
 from .go_to_definition import TypescriptGoToDefinitionCommand
 from .go_to_type import TypescriptGoToTypeCommand
 from .nav_to import TypescriptNavToCommand
@@ -31,6 +31,7 @@
 __all__ = [
     "TypescriptAutoIndentOnEnterBetweenCurlyBrackets",
     "TypescriptErrorInfo",
+    "TypescriptProjectErrorList",
     "TypescriptFormatBrackets",
     "TypescriptFormatDocument",
     "TypescriptFormatLine",

typescript/commands/error_info.py

@@ -1,7 +1,7 @@
 import sublime_plugin
 
 from ..libs.view_helpers import cli
-from .base_command import TypeScriptBaseTextCommand
+from .base_command import TypeScriptBaseTextCommand, TypeScriptBaseWindowCommand
 
 
 class TypescriptErrorInfo(TypeScriptBaseTextCommand):
@@ -25,3 +25,14 @@ def run(self, text):
             self.view.set_status("typescript_error", error_text)
         else:
             self.view.erase_status("typescript_error")
+
+
+class TypescriptProjectErrorList(TypeScriptBaseWindowCommand):
+
+    error_list_panel = None
+
+    def run(self):
+        # if self.window.get_output_panel("errorList") is None:
+        if not TypescriptProjectErrorList.error_list_panel:
+            TypescriptProjectErrorList.error_list_panel = self.window.create_output_panel("errorList")
+        self.window.run_command("show_panel", {"panel": "output.errorList"})

typescript/libs/editor_client.py

@@ -36,6 +36,7 @@ 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):
@@ -69,6 +70,9 @@ 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/node_client.py

@@ -17,17 +17,29 @@
 
 
 class CommClient:
+    def serverStarted(self): pass
+
+    def workerStarted(self): pass
+
     def getEvent(self): pass
 
+    def getEventFromWorker(self): pass
+
     def postCmd(self, cmd): pass
 
+    def postCmdToWorker(self, cmd): pass
+
     def sendCmd(self, cb, cmd): pass
 
+    def sendCmdToWorker(self, cmd): pass
+
     def sendCmdSync(self, cmd): pass
 
+    def sendCmdToWorkerSync(self, cmd): pass
+
     def sendCmdAsync(self, cmd): pass
 
-    def postCmdToWorker(self, cmd): pass
+    def sendCmdToWorkerAsync(self, cmd): pass
 
 
 class NodeCommClient(CommClient):
@@ -45,6 +57,7 @@ def __init__(self, scriptPath):
         # create response and event queues
         self.__msgq = queue.Queue()
         self.__eventq = queue.Queue()
+        self.__worker_eventq = queue.Queue()
 
         # start node process
         pref_settings = sublime.load_settings('Preferences.sublime-settings')
@@ -92,18 +105,19 @@ def __init__(self, scriptPath):
             readerThread.daemon = True
             readerThread.start()
 
-        # 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")
-            worker_thread = threading.Thread(
-                target = NodeCommClient.__reader,
-                args = (
-                    self.__workerProc.stdout, self.__msgq, self.__eventq, self.asyncReq, self.__workerProc
+        if pref_settings.get('project_error_list'):
+            # 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")
+                worker_thread = threading.Thread(
+                    target=NodeCommClient.__reader,
+                    args=(
+                        self.__workerProc.stdout, self.__msgq, self.__worker_eventq, self.asyncReq, self.__workerProc
+                    )
                 )
-            )
-            worker_thread.daemon = True
-            worker_thread.start()
+                worker_thread.daemon = True
+                worker_thread.start()
 
         self.__debugProc = None
         self.__breakpoints = []
@@ -165,6 +179,13 @@ def sendCmdAsync(self, cmd, seq, cb):
         if self.postCmd(cmd):
             self.asyncReq[seq] = cb
 
+    def sendCmdToWorkerAsync(self, cmd, seq, cb):
+        """
+        Sends the command and registers a callback
+        """
+        if self.postCmdToWorker(cmd):
+            self.asyncReq[seq] = cb
+
     def sendCmdSync(self, cmd, seq):
         """
         Sends the command and wait for the result and returns it
@@ -183,6 +204,24 @@ def sendCmdSync(self, cmd, seq):
         else:
             return self.makeTimeoutMsg(cmd, seq)
 
+    def sendCmdToWorkerSync(self, cmd, seq):
+        """
+        Sends the command and wait for the result and returns it
+        """
+        if self.postCmdToWorker(cmd):
+            reqSeq = -1
+            try:
+                while reqSeq < seq:
+                    data = self.__msgq.get(True, 1)
+                    dict = json_helpers.decode(data)
+                    reqSeq = dict['request_seq']
+                return dict
+            except queue.Empty:
+                print("queue timeout")
+                return self.makeTimeoutMsg(cmd, seq)
+        else:
+            return self.makeTimeoutMsg(cmd, seq)
+
     def postCmd(self, cmd):
         """
         Post command to server; no response needed
@@ -221,6 +260,13 @@ def getEvent(self):
             return None
         return ev
 
+    def getEventFromWorker(self):
+        try:
+            ev = self.__worker_eventq.get(False)
+        except:
+            return None
+        return ev
+
     @staticmethod
     def __readMsg(stream, msgq, eventq, asyncReq, proc):
         """

typescript/libs/service_proxy.py

@@ -3,6 +3,7 @@
 from . import json_helpers
 from .node_client import CommClient
 from .text_helpers import Location
+from .editor_client import cli
 
 
 class ServiceProxy:
@@ -26,6 +27,8 @@ def configure(self, host_info="Sublime Text", file=None, format_options=None):
         req_dict = self.create_req_dict("configure", args)
         json_str = json_helpers.encode(req_dict)
         response_dict = self.__comm.sendCmdSync(json_str, req_dict["seq"])
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdToWorkerSync(json_str, req_dict["seq"])
         return response_dict
 
     def change(self, path, begin_location=Location(1, 1), end_location=Location(1, 1), insertString=""):
@@ -40,7 +43,8 @@ def change(self, path, begin_location=Location(1, 1), end_location=Location(1, 1
         req_dict = self.create_req_dict("change", args)
         json_str = json_helpers.encode(req_dict)
         self.__comm.postCmd(json_str)
-        self.__comm.postCmdToWorker(json_str)
+        if self.__comm.workerStarted():
+            self.__comm.postCmdToWorker(json_str)
 
     def completions(self, path, location=Location(1, 1), prefix="", on_completed=None):
         args = {"file": path, "line": location.line, "offset": location.offset, "prefix": prefix}
@@ -92,28 +96,34 @@ def format(self, path, begin_location=Location(1, 1), end_location=Location(1, 1
         req_dict = self.create_req_dict("format", args)
         json_str = json_helpers.encode(req_dict)
         response_dict = self.__comm.sendCmdSync(json_str, req_dict["seq"])
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdToWorkerSync(json_str, req_dict["seq"])
         return response_dict
 
     def format_on_key(self, path, location=Location(1, 1), key=""):
         args = {"file": path, "line": location.line, "offset": location.offset, "key": key}
         req_dict = self.create_req_dict("formatonkey", args)
         json_str = json_helpers.encode(req_dict)
         response_dict = self.__comm.sendCmdSync(json_str, req_dict["seq"])
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdToWorkerSync(json_str, req_dict["seq"])
         return response_dict
 
     def open(self, path):
         args = {"file": path}
         req_dict = self.create_req_dict("open", args)
         json_str = json_helpers.encode(req_dict)
         self.__comm.postCmd(json_str)
-        self.__comm.postCmdToWorker(json_str)
+        if self.__comm.workerStarted():
+            self.__comm.postCmdToWorker(json_str)
 
     def close(self, path):
         args = {"file": path}
         req_dict = self.create_req_dict("close", args)
         json_str = json_helpers.encode(req_dict)
         self.__comm.postCmd(json_str)
-        self.__comm.postCmdToWorker(json_str)
+        if self.__comm.workerStarted():
+            self.__comm.postCmdToWorker(json_str)
 
     def references(self, path, location=Location(1, 1)):
         args = {"file": path, "line": location.line, "offset": location.offset}
@@ -126,28 +136,40 @@ def reload(self, path, alternate_path):
         args = {"file": path, "tmpfile": alternate_path}
         req_dict = self.create_req_dict("reload", args)
         json_str = json_helpers.encode(req_dict)
-        self.__comm.postCmd(json_str)
-        self.__comm.postCmdToWorker(json_str)
+        response_dict = self.__comm.sendCmdSync(json_str, req_dict["seq"])
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdToWorkerSync(json_str, req_dict["seq"])
+        return response_dict
 
     def reload_async(self, path, alternate_path, on_completed):
         args = {"file": path, "tmpfile": alternate_path}
         req_dict = self.create_req_dict("reload", args)
         json_str = json_helpers.encode(req_dict)
         self.__comm.sendCmdAsync(json_str, req_dict["seq"], on_completed)
-        self.__comm.postCmdToWorker(json_str)
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdToWorkerAsync(json_str, req_dict["seq"], None)
 
     def rename(self, path, location=Location(1, 1)):
         args = {"file": path, "line": location.line, "offset": location.offset}
         req_dict = self.create_req_dict("rename", args)
         json_str = json_helpers.encode(req_dict)
         response_dict = self.__comm.sendCmdSync(json_str, req_dict["seq"])
+        if self.__comm.workerStarted():
+            self.__comm.sendCmdSync(json_str, req_dict["seq"])
         return response_dict
 
     def request_get_err(self, delay=0, pathList=[]):
         args = {"files": pathList, "delay": delay}
         req_dict = self.create_req_dict("geterr", args)
         json_str = json_helpers.encode(req_dict)
-        self.__comm.postCmdToWorker(json_str)
+        self.__comm.postCmd(json_str)
+
+    def request_get_err_for_project(self, delay=0, path=""):
+        args = {"file": path, "delay": delay}
+        req_dict = self.create_req_dict("geterrForProject", args)
+        json_str = json_helpers.encode(req_dict)
+        if self.__comm.workerStarted():
+            self.__comm.postCmdToWorker(json_str)
 
     def type(self, path, location=Location(1, 1)):
         args = {"file": path, "line": location.line, "offset": location.offset}
@@ -170,6 +192,10 @@ def get_event(self):
         event_json_str = self.__comm.getEvent()
         return json_helpers.decode(event_json_str) if event_json_str is not None else None
 
+    def get_event_from_worker(self):
+        event_json_str = self.__comm.getEventFromWorker()
+        return json_helpers.decode(event_json_str) if event_json_str is not None else None
+
     def save_to(self, path, alternatePath):
         args = {"file": path, "tmpfile": alternatePath}
         req_dict = self.create_req_dict("saveto", args)

typescript/libs/view_helpers.py

@@ -57,9 +57,9 @@ def get_info(view):
                         reload_buffer(view, info.client_info)
                     else:
                         info.client_info.pending_changes = True
-                # if info in most_recent_used_file_list:
-                #     most_recent_used_file_list.remove(info)
-                # most_recent_used_file_list.append(info)
+                        # if info in most_recent_used_file_list:
+                        #     most_recent_used_file_list.remove(info)
+                        # most_recent_used_file_list.append(info)
     return info
 
 
@@ -213,10 +213,12 @@ def reload_buffer(view, client_info=None):
             client_info.change_count = info.modify_count
         client_info.pending_changes = False
 
+
 def reload_required(view):
     client_info = cli.get_or_add_file(view.file_name())
     return client_info.pending_changes or client_info.change_count < change_count(view)
 
+
 def check_update_view(view):
     """Check if the buffer in the view needs to be reloaded
 
@@ -315,4 +317,9 @@ def change_count(view):
         if IS_ST2:
             return info.modify_count
         else:
-            return view.change_count()
+            return view.change_count()
+
+
+def is_view_visible(view):
+    """The only way to tell a view is visible seems to be to test if it has an attached window"""
+    return view.window() is not None

typescript/listeners/idle.py

@@ -3,6 +3,8 @@
 from ..libs import log
 from .event_hub import EventHub
 
+from ..commands import TypescriptProjectErrorList
+
 
 class IdleListener:
     def __init__(self):
@@ -58,6 +60,8 @@ def request_errors(self, view, info, error_delay):
                     check_update_view(group_active_view)
             if len(files) > 0:
                 cli.service.request_get_err(error_delay, files)
+                if cli.project_error_list_enabled:
+                    cli.service.request_get_err_for_project(error_delay, active_view().file_name())
                 self.error_info_requested_not_received = True
             self.wait_count = 0
             self.set_on_idle_timer(error_delay + 300)
@@ -156,6 +160,15 @@ def handle_time_out(self):
         if self.pending_timeout == 0:
             self.on_idle()
 
+    def update_project_error_list(self):
+        # Retrieve the project wide errors
+        test_ev = cli.service.get_event_from_worker()
+        error_list_panel = TypescriptProjectErrorList.error_list_panel
+        if is_view_visible(error_list_panel):
+            while test_ev:
+                error_list_panel.run_command("append", {"characters": str(test_ev) + "\n"})
+                test_ev = cli.service.get_event_from_worker()
+
     def on_idle(self):
         """Callback after the idle status is confirmed
 
@@ -164,6 +177,10 @@ def on_idle(self):
         """
         view = active_view()
         log.debug("call get_event from on_idle")
+
+        if cli.project_error_list_enabled:
+            self.update_project_error_list()
+
         ev = cli.service.get_event()
         if ev is not None:
             self.error_info_requested_not_received = False