Got the client side working

Author: zhengbli

typescript/commands/error_list.py

@@ -7,16 +7,16 @@
 class TypescriptProjectErrorList(TypeScriptBaseWindowCommand):
 
     def run(self):
+        panel_manager = get_panel_manager()
+        panel_manager.add_panel("errorlist")
+        panel_manager.show_panel("errorlist")
+
         if not cli.node_client.workerStarted():
             view = active_view()
             # start worker process
             cli.node_client.startWorker()       
             # load the active project
             get_info(view)
             # send the first error request
-            cli.service.request_get_err_for_project(0, view.file_name())
-            start_timer()
-
-        panel_manager = get_panel_manager()
-        panel_manager.add_panel("errorlist")
-        panel_manager.show_panel("errorlist")
+            # cli.service.request_get_err_for_project(0, view.file_name())
+            start_timer()

typescript/libs/node_client.py

@@ -122,14 +122,13 @@ def startWorker(self):
                 [node_path, self.script_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 
         # 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()))
+        if self.__workerProc and (not self.__workerProc.poll()):
+            log.debug("worker proc " + str(self.__workerProc))
+            log.debug("starting worker thread")
+            workerThread = threading.Thread(target=NodeCommClient.__reader, args=(
+                self.__workerProc.stdout, self.__msgq, self.__worker_eventq, self.asyncReq, self.__workerProc))
+            workerThread.daemon = True
+            workerThread.start()
 
     def stopWorker(self):
         NodeCommClient.stop_worker = True
@@ -308,12 +307,12 @@ def __readMsg(stream, msgq, eventq, asyncReq, proc):
 
         if body_length > 0:
             data = stream.read(body_length)
-            log.debug('Read body of length: {0}'.format(body_length))
+            # log.debug('Read body of length: {0}'.format(body_length))
             data_json = data.decode("utf-8")
             data_dict = json_helpers.decode(data_json)
             if data_dict['type'] == "response":
                 request_seq = data_dict['request_seq']
-                log.debug('Body sequence#: {0}'.format(request_seq))
+                # log.debug('Body sequence#: {0}'.format(request_seq))
                 if request_seq in asyncReq:
                     callback = asyncReq.pop(request_seq, None)
                     if callback:

typescript/libs/panel_manager.py

@@ -1,4 +1,4 @@
-import sublime
+import sublime
 
 class PanelManager:
 
@@ -13,13 +13,24 @@ def get_panel(self, panel_name):
     def add_panel(self, panel_name):
         if panel_name not in self.panels:
             self.panels[panel_name] = sublime.active_window().create_output_panel(panel_name)
+        self.panels[panel_name].set_read_only(True)
+        self.panels[panel_name].settings().set("auto_indent", False)
+        self.panels[panel_name].settings().set("draw_white_space", "none")
 
     def is_panel_active(self, panel_name):
         return panel_name in self.panels and self.panels[panel_name].window() is not None
 
     def show_panel(self, panel_name):
         sublime.active_window().run_command("show_panel", {"panel": "output." + panel_name})
 
+    def write_lines_to_panel(self, panel_name, lines):
+        panel = self.panels[panel_name]
+        panel.set_read_only(False)
+        panel.run_command("select_all")
+        panel.run_command("right_delete")
+        panel.run_command("insert", {"characters": "\n".join(lines)})
+        self.panels[panel_name].set_read_only(True)
+
     def hide_panel(self):
         sublime.active_window().run_command("hide_panel")
 

typescript/listeners/idle.py

@@ -18,8 +18,7 @@ def on_activated_with_info(self, view, info):
         self.request_errors(view, info, 200)
 
         # set modified and selection idle timers, so we can read
-        # diagnostics and update
-        # status line
+        # diagnostics and update status line
         self.set_on_idle_timer(IDLE_TIME_LENGTH)
         self.set_on_selection_idle_timer(IDLE_TIME_LENGTH)
         self.just_changed_focus = True

typescript/listeners/project_error_list.py

@@ -11,6 +11,7 @@ def __init__(self):
         self.modified = False
         self.error_info_requested_not_received = False
         self.pending_timeout = 0
+        self.errors = dict()
 
     def is_error_list_panel_active(self):
         return get_panel_manager().is_panel_active("errorlist")
@@ -46,30 +47,63 @@ def on_idle(self):
         if info:
             log.debug("asking for project errors")
             if self.is_error_list_panel_active():
-                self.request_errors(view, info, 500)
+                self.request_errors(view, info, 100)
             else:
                 cli.node_client.stopWorker()
 
     def update_error_list_panel(self):
         test_ev = cli.service.get_event_from_worker()
         if test_ev:
             self.error_info_requested_not_received = False
-            panel_manager = get_panel_manager()
-            error_list_panel = panel_manager.get_panel("errorlist")
+            self.load_error(test_ev)
+
+            # There may be multiple events coming simultaniously
             while test_ev:
-                error_list_panel.run_command("append", {"characters": str(test_ev) + "\n"})
+                self.load_error(test_ev)                   
                 test_ev = cli.service.get_event_from_worker()
+
+            output_lines = []
+            for file in self.errors:
+                if len(self.errors[file]["syntaxDiag"]) + len(self.errors[file]["semanticDiag"]) > 0:
+                    output_lines.append(file)
+                    output_lines.extend(self.errors[file]["syntaxDiag"] + self.errors[file]["semanticDiag"])
+            get_panel_manager().write_lines_to_panel("errorlist", output_lines)
             self.set_on_idle_timer(50)
         elif self.error_info_requested_not_received:
             self.set_on_idle_timer(50)
 
+    def load_error(self, json_dict):
+        if json_dict["type"] != "event":
+            return
+
+        error_type = json_dict["event"]
+        if error_type not in ["syntaxDiag", "semanticDiag"]:
+            return
+
+        body = json_dict["body"]
+        if body is not None:
+            file = body["file"]
+            if file not in self.errors:
+                self.errors[file] = { "syntaxDiag": [], "semanticDiag": [] }
+            self.errors[file][error_type] = []
+            diags = body["diagnostics"]
+            for diag in diags:
+                message = "    ({0}, {1}) {2}".format(
+                    diag["start"]["line"],
+                    diag["start"]["offset"],
+                    diag["text"]
+                    )
+                self.errors[file][error_type].append(message)
+
     def request_errors(self, view, info, error_delay):
         if info and self.is_error_list_panel_active() and (
             self.just_changed_focus or
-            info.change_count_when_last_err_req_sent < change_count(view)
+            self.modified
         ):
             self.just_changed_focus = False
+            self.modified = False
             cli.service.request_get_err_for_project(error_delay, view.file_name())
+            self.error_info_requested_not_received = True
             self.set_on_idle_timer(error_delay + 300)
 
 listener = ProjectErrorListener()