theme-check 1.6.2 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e992338f154cdf5da965bae74af6907af89156170b5bdcf599f8f15b9708bb87
-  data.tar.gz: 27071bf8d98359410d2486a62502f2e7453465771b932a77a6c27785ba00abbb
+  metadata.gz: 943f8cb722f6c19c1c41e494622922e608a99b50e4ad67f2288a2ed99f406ff3
+  data.tar.gz: a8fd83f054895fd366bba2512ff6431d8c470bb3e013ff6c6bf9f6be5366bf38
 SHA512:
-  metadata.gz: 33969efb3cc9bd670ce7a15a419e7419824e8e48ab5951e1f527f116e3aec42ca01c214eb50cd0eb1058fd6c5975c353f3b84024b990dcbad3a45f27cbb9380f
-  data.tar.gz: 410dd3f410c5dd0fe23533eae5716d8bfefec6fd4bc57e68c77dfe14832e7c498854d2dc6728b25467188d887860d97d92747cf915ab1c669f40226b46a371ad
+  metadata.gz: fb37aed715f2b9f2dd0a8c17f2abf69110d583280d88508ef3f6ee439989c63fe9819025d870cfc1ed64a8deaac19586ac48ab261495e7a371575d9971754980
+  data.tar.gz: 64727b7c9684fa094ce498c09a2a3f1dc06ce10fa99aed066af2aa327bd4de70fcc728f76ad127fd08d7b1b6e28b42b06acf96d83b26193814e7eed1b19a2008

data/CHANGELOG.md

@@ -1,4 +1,13 @@
 
+v1.7.0 / 2021-09-20
+===================
+
+### Features
+
+  * Handle LSP messages concurrently in the Language Server ([#459](https://github.com/shopify/theme-check/issues/459))
+    * Adds progress reporting while checking (:eyes: VS Code status bar)
+    * Makes completions work while checking (more noticeable on Windows since ruby is 3x slower on Windows)
+
 v1.6.2 / 2021-09-16
 ===================
 

data/lib/theme_check/analyzer.rb

@@ -29,19 +29,36 @@ module ThemeCheck
         @html_checks.flat_map(&:offenses)
     end
 
+    def json_file_count
+      @json_file_count ||= @theme.json.size
+    end
+
+    def liquid_file_count
+      @liquid_file_count ||= @theme.liquid.size
+    end
+
+    def total_file_count
+      json_file_count + liquid_file_count
+    end
+
     def analyze_theme
       reset
 
       liquid_visitor = LiquidVisitor.new(@liquid_checks, @disabled_checks)
       html_visitor = HtmlVisitor.new(@html_checks)
+
       ThemeCheck.with_liquid_c_disabled do
-        @theme.liquid.each do |liquid_file|
+        @theme.liquid.each_with_index do |liquid_file, i|
+          yield(liquid_file.relative_path.to_s, i, total_file_count) if block_given?
           liquid_visitor.visit_liquid_file(liquid_file)
           html_visitor.visit_liquid_file(liquid_file)
         end
       end
 
-      @theme.json.each { |json_file| @json_checks.call(:on_file, json_file) }
+      @theme.json.each_with_index do |json_file, i|
+        yield(json_file.relative_path.to_s, liquid_file_count + i, total_file_count) if block_given?
+        @json_checks.call(:on_file, json_file)
+      end
 
       finish
     end
@@ -53,16 +70,23 @@ module ThemeCheck
         # Call all checks that run on the whole theme
         liquid_visitor = LiquidVisitor.new(@liquid_checks.whole_theme, @disabled_checks)
         html_visitor = HtmlVisitor.new(@html_checks.whole_theme)
-        @theme.liquid.each do |liquid_file|
+        total = total_file_count + files.size
+        @theme.liquid.each_with_index do |liquid_file, i|
+          yield(liquid_file.relative_path.to_s, i, total) if block_given?
           liquid_visitor.visit_liquid_file(liquid_file)
           html_visitor.visit_liquid_file(liquid_file)
         end
-        @theme.json.each { |json_file| @json_checks.whole_theme.call(:on_file, json_file) }
+
+        @theme.json.each_with_index do |json_file, i|
+          yield(json_file.relative_path.to_s, liquid_file_count + i, total) if block_given?
+          @json_checks.whole_theme.call(:on_file, json_file)
+        end
 
         # Call checks that run on a single files, only on specified file
         liquid_visitor = LiquidVisitor.new(@liquid_checks.single_file, @disabled_checks)
         html_visitor = HtmlVisitor.new(@html_checks.single_file)
-        files.each do |theme_file|
+        files.each_with_index do |theme_file, i|
+          yield(theme_file.relative_path.to_s, total_file_count + i, total) if block_given?
           if theme_file.liquid?
             liquid_visitor.visit_liquid_file(theme_file)
             html_visitor.visit_liquid_file(theme_file)

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/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ThemeCheck
-  VERSION = "1.6.2"
+  VERSION = "1.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: theme-check
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.7.0
 platform: ruby
 authors:
 - Marc-André Cournoyer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-16 00:00:00.000000000 Z
+date: 2021-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -217,6 +217,7 @@ files:
 - lib/theme_check/language_server/document_link_providers/render_document_link_provider.rb
 - lib/theme_check/language_server/document_link_providers/section_document_link_provider.rb
 - lib/theme_check/language_server/handler.rb
+- lib/theme_check/language_server/messenger.rb
 - lib/theme_check/language_server/protocol.rb
 - lib/theme_check/language_server/server.rb
 - lib/theme_check/language_server/tokens.rb