theme-check 1.5.2 → 1.7.0

data/lib/theme_check/language_server/handler.rb

@@ -7,6 +7,11 @@ module ThemeCheck
     class Handler
       include URIHelper
 
+      SERVER_INFO = {
+        name: $PROGRAM_NAME,
+        version: ThemeCheck::VERSION,
+      }
+
       CAPABILITIES = {
         completionProvider: {
           triggerCharacters: ['.', '{{ ', '{% '],
@@ -24,10 +29,17 @@ module ThemeCheck
       def initialize(server)
         @server = server
         @diagnostics_tracker = DiagnosticsTracker.new
+        @diagnostics_lock = Mutex.new
+        @supports_progress = false
+      end
+
+      def supports_progress_notifications?
+        @supports_progress
       end
 
       def on_initialize(id, params)
         @root_path = root_path_from_params(params)
+        @supports_progress = params.dig('capabilities', 'window', 'workDoneProgress')
 
         # Tell the client we don't support anything if there's no rootPath
         return send_response(id, { capabilities: {} }) if @root_path.nil?
@@ -37,6 +49,7 @@ module ThemeCheck
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
         send_response(id, {
           capabilities: CAPABILITIES,
+          serverInfo: SERVER_INFO,
         })
       end
 
@@ -128,6 +141,8 @@ module ThemeCheck
       end
 
       def analyze_and_send_offenses(absolute_path)
+        return unless @diagnostics_lock.try_lock
+        token = send_create_work_done_progress_request
         config = config_for_path(absolute_path)
         storage = ThemeCheck::FileSystemStorage.new(
           config.root,
@@ -137,13 +152,17 @@ module ThemeCheck
         analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
 
         if @diagnostics_tracker.first_run?
-          # Analyze the full theme on first run
+          send_work_done_progress_begin(token, "Full theme check")
           log("Checking #{config.root}")
           offenses = nil
           time = Benchmark.measure do
-            offenses = analyzer.analyze_theme
+            offenses = analyzer.analyze_theme do |path, i, total|
+              send_work_done_progress_report(token, "#{i}/#{total} #{path}", (i.to_f / total * 100.0).to_i)
+            end
           end
-          log("Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s")
+          end_message = "Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s"
+          log(end_message)
+          send_work_done_progress_end(token, end_message)
           send_diagnostics(offenses)
         else
           # Analyze selected files
@@ -152,14 +171,20 @@ module ThemeCheck
           # Skip if not a theme file
           if file
             log("Checking #{relative_path}")
+            send_work_done_progress_begin(token, "Partial theme check")
             offenses = nil
             time = Benchmark.measure do
-              offenses = analyzer.analyze_files([file])
+              offenses = analyzer.analyze_files([file]) do |path, i, total|
+                send_work_done_progress_report(token, "#{i}/#{total} #{path}", (i.to_f / total * 100.0).to_i)
+              end
             end
-            log("Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s")
+            end_message = "Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s"
+            send_work_done_progress_end(token, end_message)
+            log(end_message)
             send_diagnostics(offenses, [absolute_path])
           end
         end
+        @diagnostics_lock.unlock
       end
 
       def completions(relative_path, line, col)
@@ -228,9 +253,57 @@ module ThemeCheck
         }
       end
 
+      def send_create_work_done_progress_request
+        return unless supports_progress_notifications?
+        token = nil
+        @server.request do |id|
+          token = id # we'll reuse the RQID as token
+          send_message({
+            id: id,
+            method: "window/workDoneProgress/create",
+            params: {
+              token: id,
+            },
+          })
+        end
+        token
+      end
+
+      def send_work_done_progress_begin(token, title)
+        return unless supports_progress_notifications?
+        send_progress(token, {
+          kind: 'begin',
+          title: title,
+          cancellable: false,
+          percentage: 0,
+        })
+      end
+
+      def send_work_done_progress_report(token, message, percentage)
+        return unless supports_progress_notifications?
+        send_progress(token, {
+          kind: 'report',
+          message: message,
+          cancellable: false,
+          percentage: percentage,
+        })
+      end
+
+      def send_work_done_progress_end(token, message)
+        return unless supports_progress_notifications?
+        send_progress(token, {
+          kind: 'end',
+          message: message,
+        })
+      end
+
+      def send_progress(token, value)
+        send_notification("$/progress", token: token, value: value)
+      end
+
       def send_message(message)
         message[:jsonrpc] = '2.0'
-        @server.send_response(message)
+        @server.send_message(message)
       end
 
       def send_response(id, result = nil, error = nil)
@@ -240,6 +313,15 @@ module ThemeCheck
         send_message(message)
       end
 
+      def send_request(method, params = nil)
+        @server.request do |id|
+          message = { id: id }
+          message[:method] = method
+          message[:params] = params if params
+          send_message(message)
+        end
+      end
+
       def send_notification(method, params)
         message = { method: method }
         message[:params] = params

data/lib/theme_check/language_server/messenger.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Messenger
+      def initialize
+        @responses = {}
+        @mutex = Mutex.new
+        @id = 0
+      end
+
+      # Here's how you'd use this:
+      #
+      # def some_method_that_communicates_both_ways
+      #
+      #   # this will block until the JSON rpc loop has an answer
+      #   token = @server.request do |id|
+      #     send_create_work_done_progress_request(id, ...)
+      #   end
+      #
+      #   send_create_work_done_begin_notification(token, "...")
+      #
+      #   do_stuff do |file, i, total|
+      #     send_create_work_done_progress_notification(token, "...")
+      #   end
+      #
+      #   send_create_work_done_end_notification(token, "...")
+      #
+      # end
+      def request(&block)
+        id = @mutex.synchronize { @id += 1 }
+        @responses[id] = SizedQueue.new(1)
+
+        # Execute the block in the parent thread with an ID
+        # So that we're able to relinquish control in the right
+        # place when we have a response.
+        block.call(id)
+
+        # this call is blocking until we get a response from somewhere
+        result = @responses[id].pop
+
+        # cleanup when done
+        @responses.delete(id)
+
+        # return the response
+        result
+      end
+
+      # In the JSONRPC loop, when we find the response to the
+      # request, we unblock the thread that made the request with the
+      # response.
+      def respond(id, value)
+        @responses[id] << value
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/server.rb

@@ -16,7 +16,8 @@ module ThemeCheck
         in_stream: STDIN,
         out_stream: STDOUT,
         err_stream: STDERR,
-        should_raise_errors: false
+        should_raise_errors: false,
+        number_of_threads: 2
       )
         validate!([in_stream, out_stream, err_stream])
 
@@ -37,33 +38,90 @@ module ThemeCheck
         @out.sync = true # do not buffer
         @err.sync = true # do not buffer
 
+        # The queue holds the JSON RPC messages
+        @queue = Queue.new
+
+        # The JSON RPC thread pushes messages onto the queue
+        @json_rpc_thread = nil
+
+        # The handler threads read messages from the queue
+        @number_of_threads = number_of_threads
+        @handlers = []
+
+        # The messenger permits requests to be made from the handler
+        # to the language client and for those messages to be resolved in place.
+        @messenger = Messenger.new
+
+        # The error queue holds blocks the main thread. When filled, we exit the program.
+        @error = SizedQueue.new(1)
+
         @should_raise_errors = should_raise_errors
       end
 
       def listen
-        loop do
-          process_request
-
-        # support ctrl+c and stuff
-        rescue SignalException, DoneStreaming
-          cleanup
-          return 0
-
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          raise e if should_raise_errors
-          log(e)
-          log(e.backtrace)
-          return 1
+        start_handler_threads
+        start_json_rpc_thread
+        status_code_from_error(@error.pop)
+      rescue SignalException
+        0
+      ensure
+        cleanup
+      end
+
+      def start_json_rpc_thread
+        @json_rpc_thread = Thread.new do
+          loop do
+            message = read_json_rpc_message
+            if message['method'] == 'initialize'
+              handle_message(message)
+            else
+              @queue << message
+            end
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            break @error << e
+          end
+        end
+      end
+
+      def start_handler_threads
+        @number_of_threads.times do
+          @handlers << Thread.new do
+            loop do
+              message = @queue.pop
+              break if @queue.closed? && @queue.empty?
+              handle_message(message)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              break @error << e
+            end
+          end
         end
       end
 
-      def send_response(response)
-        response_body = JSON.dump(response)
-        log(JSON.pretty_generate(response)) if $DEBUG
+      def status_code_from_error(e)
+        raise e
+
+      # support ctrl+c and stuff
+      rescue SignalException, DoneStreaming
+        0
+
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise e if should_raise_errors
+        log(e)
+        log(e.backtrace)
+        2
+      end
+
+      def request(&block)
+        @messenger.request(&block)
+      end
+
+      def send_message(message)
+        message_body = JSON.dump(message)
+        log(JSON.pretty_generate(message)) if $DEBUG
 
-        @out.write("Content-Length: #{response_body.bytesize}\r\n")
+        @out.write("Content-Length: #{message_body.bytesize}\r\n")
         @out.write("\r\n")
-        @out.write(response_body)
+        @out.write(message_body)
         @out.flush
       end
 
@@ -91,17 +149,23 @@ module ThemeCheck
         "one of the following: #{supported_io_classes.join(', ')}"
       end
 
-      def process_request
-        request_body = read_new_content
-        request_json = JSON.parse(request_body)
-        log(JSON.pretty_generate(request_json)) if $DEBUG
+      def read_json_rpc_message
+        message_body = read_new_content
+        message_json = JSON.parse(message_body)
+        log(JSON.pretty_generate(message_json)) if $DEBUG
+        message_json
+      end
 
-        id = request_json['id']
-        method_name = request_json['method']
-        params = request_json['params']
-        method_name = "on_#{to_snake_case(method_name)}"
+      def handle_message(message)
+        id = message['id']
+        method_name = message['method']
+        method_name &&= "on_#{to_snake_case(method_name)}"
+        params = message['params']
+        result = message['result']
 
-        if @handler.respond_to?(method_name)
+        if message.key?('result')
+          @messenger.respond(id, result)
+        elsif @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
       end
@@ -128,26 +192,27 @@ module ThemeCheck
         length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
         content = ''
         while content.length < length + 2
-          begin
-            # Why + 2? Because \r\n
-            content += @in.read(length + 2)
-          rescue => e
-            log(e)
-            log(e.backtrace)
-            # We have almost certainly been disconnected from the server
-            cleanup
-            raise DoneStreaming
-          end
+          # Why + 2? Because \r\n
+          content += @in.read(length + 2)
+          raise DoneStreaming if @in.closed?
         end
 
         content
       end
 
       def cleanup
+        # Stop listenting to RPC calls
+        @in.close unless @in.closed?
+        # Wait for rpc loop to close
+        @json_rpc_thread&.join if @json_rpc_thread&.alive?
+        # Close the queue
+        @queue.close unless @queue.closed?
+        # Give 10 seconds for the handlers to wrap up what they were
+        # doing/emptying the queue. 👀 unit tests.
+        @handlers.each { |thread| thread.join(10) if thread.alive? }
+      ensure
         @err.close
         @out.close
-      rescue
-        # I did my best
       end
     end
   end

data/lib/theme_check/language_server.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
+require_relative "language_server/messenger"
 require_relative "language_server/constants"
 require_relative "language_server/uri_helper"
 require_relative "language_server/handler"

data/lib/theme_check/{template.rb → liquid_file.rb}

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module ThemeCheck
-  class Template < ThemeFile
+  class LiquidFile < ThemeFile
     def write
-      content = updated_content
+      content = rewriter.to_s
       if source != content
-        @storage.write(@relative_path, content)
+        @storage.write(@relative_path, content.gsub("\n", @eol))
         @source = content
+        @rewriter = nil
       end
     end
 
@@ -26,19 +27,8 @@ module ThemeCheck
       name.start_with?('snippets')
     end
 
-    def lines
-      # Retain trailing newline character
-      @lines ||= source.split("\n", -1)
-    end
-
-    # Not entirely obvious but lines is mutable, corrections are to be
-    # applied on @lines.
-    def updated_content
-      lines.join("\n")
-    end
-
-    def excerpt(line)
-      lines[line - 1].strip
+    def rewriter
+      @rewriter ||= ThemeFileRewriter.new(@relative_path, source)
     end
 
     def source_excerpt(line)
@@ -46,10 +36,6 @@ module ThemeCheck
       original_lines[line - 1].strip
     end
 
-    def full_line(line)
-      lines[line - 1]
-    end
-
     def parse
       @ast ||= self.class.parse(source)
     end