theme-check 1.6.1 → 1.7.2

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: ['.', '{{ ', '{% '],
@@ -21,22 +26,24 @@ module ThemeCheck
         },
       }
 
-      def initialize(server)
-        @server = server
-        @diagnostics_tracker = DiagnosticsTracker.new
+      def initialize(bridge)
+        @bridge = bridge
       end
 
       def on_initialize(id, params)
         @root_path = root_path_from_params(params)
 
         # Tell the client we don't support anything if there's no rootPath
-        return send_response(id, { capabilities: {} }) if @root_path.nil?
+        return @bridge.send_response(id, { capabilities: {} }) if @root_path.nil?
+
+        @bridge.supports_work_done_progress = params.dig('capabilities', 'window', 'workDoneProgress') || false
         @storage = in_memory_storage(@root_path)
         @completion_engine = CompletionEngine.new(@storage)
         @document_link_engine = DocumentLinkEngine.new(@storage)
-        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
-        send_response(id, {
+        @diagnostics_engine = DiagnosticsEngine.new(@bridge)
+        @bridge.send_response(id, {
           capabilities: CAPABILITIES,
+          serverInfo: SERVER_INFO,
         })
       end
 
@@ -58,7 +65,7 @@ module ThemeCheck
       def on_text_document_did_open(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
         @storage.write(relative_path, text_document_text(params))
-        analyze_and_send_offenses(text_document_uri(params)) if @diagnostics_tracker.first_run?
+        analyze_and_send_offenses(text_document_uri(params)) if @diagnostics_engine.first_run?
       end
 
       def on_text_document_did_save(_id, params)
@@ -67,14 +74,14 @@ module ThemeCheck
 
       def on_text_document_document_link(id, params)
         relative_path = relative_path_from_text_document_uri(params)
-        send_response(id, document_links(relative_path))
+        @bridge.send_response(id, document_links(relative_path))
       end
 
       def on_text_document_completion(id, params)
         relative_path = relative_path_from_text_document_uri(params)
         line = params.dig('position', 'line')
         col = params.dig('position', 'character')
-        send_response(id, completions(relative_path, line, col))
+        @bridge.send_response(id, completions(relative_path, line, col))
       end
 
       private
@@ -128,38 +135,10 @@ module ThemeCheck
       end
 
       def analyze_and_send_offenses(absolute_path)
-        config = config_for_path(absolute_path)
-        storage = ThemeCheck::FileSystemStorage.new(
-          config.root,
-          ignored_patterns: config.ignored_patterns
+        @diagnostics_engine.analyze_and_send_offenses(
+          absolute_path,
+          config_for_path(absolute_path)
         )
-        theme = ThemeCheck::Theme.new(storage)
-        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
-
-        if @diagnostics_tracker.first_run?
-          # Analyze the full theme on first run
-          log("Checking #{config.root}")
-          offenses = nil
-          time = Benchmark.measure do
-            offenses = analyzer.analyze_theme
-          end
-          log("Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s")
-          send_diagnostics(offenses)
-        else
-          # Analyze selected files
-          relative_path = Pathname.new(@storage.relative_path(absolute_path))
-          file = theme[relative_path]
-          # Skip if not a theme file
-          if file
-            log("Checking #{relative_path}")
-            offenses = nil
-            time = Benchmark.measure do
-              offenses = analyzer.analyze_files([file])
-            end
-            log("Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s")
-            send_diagnostics(offenses, [absolute_path])
-          end
-        end
       end
 
       def completions(relative_path, line, col)
@@ -170,84 +149,8 @@ module ThemeCheck
         @document_link_engine.document_links(relative_path)
       end
 
-      def send_diagnostics(offenses, analyzed_files = nil)
-        @diagnostics_tracker.build_diagnostics(offenses, analyzed_files: analyzed_files) do |path, diagnostic_offenses|
-          send_diagnostic(path, diagnostic_offenses)
-        end
-      end
-
-      def send_diagnostic(path, offenses)
-        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
-        send_notification('textDocument/publishDiagnostics', {
-          uri: file_uri(path),
-          diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
-        })
-      end
-
-      def offense_to_diagnostic(offense)
-        diagnostic = {
-          code: offense.code_name,
-          message: offense.message,
-          range: range(offense),
-          severity: severity(offense),
-          source: "theme-check",
-        }
-        diagnostic["codeDescription"] = code_description(offense) unless offense.doc.nil?
-        diagnostic
-      end
-
-      def code_description(offense)
-        {
-          href: offense.doc,
-        }
-      end
-
-      def severity(offense)
-        case offense.severity
-        when :error
-          1
-        when :suggestion
-          2
-        when :style
-          3
-        else
-          4
-        end
-      end
-
-      def range(offense)
-        {
-          start: {
-            line: offense.start_line,
-            character: offense.start_column,
-          },
-          end: {
-            line: offense.end_line,
-            character: offense.end_column,
-          },
-        }
-      end
-
-      def send_message(message)
-        message[:jsonrpc] = '2.0'
-        @server.send_response(message)
-      end
-
-      def send_response(id, result = nil, error = nil)
-        message = { id: id }
-        message[:result] = result if result
-        message[:error] = error if error
-        send_message(message)
-      end
-
-      def send_notification(method, params)
-        message = { method: method }
-        message[:params] = params
-        send_message(message)
-      end
-
       def log(message)
-        @server.log(message)
+        @bridge.log(message)
       end
 
       def close!

data/lib/theme_check/language_server/io_messenger.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class IOMessenger < Messenger
+      def initialize(
+        in_stream: STDIN,
+        out_stream: STDOUT,
+        err_stream: STDERR
+      )
+        validate!([in_stream, out_stream, err_stream])
+
+        @in = in_stream
+        @out = out_stream
+        @err = err_stream
+
+        # Because programming is fun,
+        #
+        # Ruby on Windows turns \n into \r\n. Which means that \r\n
+        # gets turned into \r\r\n. Which means that the protocol
+        # breaks on windows unless we turn STDOUT into binary mode.
+        #
+        # Hours wasted: 9.
+        @out.binmode
+
+        @out.sync = true # do not buffer
+        @err.sync = true # do not buffer
+
+        # Lock for writing, otherwise messages might be interspersed.
+        @writer = Mutex.new
+      end
+
+      def read_message
+        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
+        content = ''
+        length_to_read = 2 + length # 2 is the empty line length (\r\n)
+        while content.length < length_to_read
+          chunk = @in.read(length_to_read - content.length)
+          raise DoneStreaming if chunk.nil?
+          content += chunk
+        end
+        content.lstrip!
+      end
+
+      def send_message(message_body)
+        @writer.synchronize do
+          @out.write("Content-Length: #{message_body.bytesize}\r\n")
+          @out.write("\r\n")
+          @out.write(message_body)
+          @out.flush
+        end
+      end
+
+      def log(message)
+        @err.puts(message)
+        @err.flush
+      end
+
+      def close_input
+        @in.close unless @in.closed?
+      end
+
+      def close_output
+        @err.close
+        @out.close
+      end
+
+      private
+
+      def initial_line
+        # Scanning for lines that fit the protocol.
+        while true
+          initial_line = @in.gets
+          # gets returning nil means the stream was closed.
+          raise DoneStreaming if initial_line.nil?
+
+          if initial_line.match(/Content-Length: (\d+)/)
+            break
+          end
+        end
+        initial_line
+      end
+
+      def supported_io_classes
+        [IO, StringIO]
+      end
+
+      def validate!(streams = [])
+        streams.each do |stream|
+          unless supported_io_classes.find { |klass| stream.is_a?(klass) }
+            raise IncompatibleStream, incompatible_stream_message
+          end
+        end
+      end
+
+      def incompatible_stream_message
+        'if provided, in_stream, out_stream, and err_stream must be a kind of '\
+        "one of the following: #{supported_io_classes.join(', ')}"
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/messenger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Messenger
+      def send_message
+        raise NotImplementedError
+      end
+
+      def read_message
+        raise NotImplementedError
+      end
+
+      def log
+        raise NotImplementedError
+      end
+
+      def close_input
+        raise NotImplementedError
+      end
+
+      def close_output
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/server.rb

@@ -13,141 +13,132 @@ module ThemeCheck
       attr_reader :should_raise_errors
 
       def initialize(
-        in_stream: STDIN,
-        out_stream: STDOUT,
-        err_stream: STDERR,
-        should_raise_errors: false
+        messenger:,
+        should_raise_errors: false,
+        number_of_threads: 2
       )
-        validate!([in_stream, out_stream, err_stream])
+        # This is what does the IO
+        @messenger = messenger
 
-        @handler = Handler.new(self)
-        @in = in_stream
-        @out = out_stream
-        @err = err_stream
+        # This is what you use to communicate with the language client
+        @bridge = Bridge.new(@messenger)
 
-        # Because programming is fun,
-        #
-        # Ruby on Windows turns \n into \r\n. Which means that \r\n
-        # gets turned into \r\r\n. Which means that the protocol
-        # breaks on windows unless we turn STDOUT into binary mode.
-        #
-        # Hours wasted: 9.
-        @out.binmode
+        # The handler handles messages from the language client
+        @handler = Handler.new(@bridge)
 
-        @out.sync = true # do not buffer
-        @err.sync = true # do not buffer
+        # The queue holds the JSON RPC messages
+        @queue = Queue.new
 
-        @should_raise_errors = should_raise_errors
-      end
+        # The JSON RPC thread pushes messages onto the queue
+        @json_rpc_thread = nil
 
-      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
-        end
-      end
+        # The handler threads read messages from the queue
+        @number_of_threads = number_of_threads
+        @handlers = []
 
-      def send_response(response)
-        response_body = JSON.dump(response)
-        log(JSON.pretty_generate(response)) if $DEBUG
+        # The error queue holds blocks the main thread. When filled, we exit the program.
+        @error = SizedQueue.new(1)
 
-        @out.write("Content-Length: #{response_body.bytesize}\r\n")
-        @out.write("\r\n")
-        @out.write(response_body)
-        @out.flush
+        @should_raise_errors = should_raise_errors
       end
 
-      def log(message)
-        @err.puts(message)
-        @err.flush
+      def listen
+        start_handler_threads
+        start_json_rpc_thread
+        status_code = status_code_from_error(@error.pop)
+        cleanup(status_code)
+      rescue SignalException
+        0
       end
 
-      private
-
-      def supported_io_classes
-        [IO, StringIO]
+      def start_json_rpc_thread
+        @json_rpc_thread = Thread.new do
+          loop do
+            message = @bridge.read_message
+            if message['method'] == 'initialize'
+              handle_message(message)
+            elsif message.key?('result')
+              # Responses are handled on the main thread to prevent
+              # a potential deadlock caused by all handlers waiting
+              # for a responses.
+              handle_response(message)
+            else
+              @queue << message
+            end
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            break @error << e
+          end
+        end
       end
 
-      def validate!(streams = [])
-        streams.each do |stream|
-          unless supported_io_classes.find { |klass| stream.is_a?(klass) }
-            raise IncompatibleStream, incompatible_stream_message
+      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 incompatible_stream_message
-        'if provided, in_stream, out_stream, and err_stream must be a kind of '\
-        "one of the following: #{supported_io_classes.join(', ')}"
+      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
+        @bridge.log(e)
+        @bridge.log(e.backtrace)
+        2
       end
 
-      def process_request
-        request_body = read_new_content
-        request_json = JSON.parse(request_body)
-        log(JSON.pretty_generate(request_json)) if $DEBUG
+      private
 
-        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']
 
         if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
       end
 
-      def to_snake_case(method_name)
-        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
+      def handle_response(message)
+        id = message['id']
+        result = message['result']
+        @bridge.receive_response(id, result)
       end
 
-      def initial_line
-        # Scanning for lines that fit the protocol.
-        while true
-          initial_line = @in.gets
-          # gets returning nil means the stream was closed.
-          raise DoneStreaming if initial_line.nil?
-
-          if initial_line.match(/Content-Length: (\d+)/)
-            break
-          end
-        end
-        initial_line
-      end
-
-      def read_new_content
-        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
-        end
-
-        content
+      def to_snake_case(method_name)
+        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
       end
 
-      def cleanup
-        @err.close
-        @out.close
-      rescue
-        # I did my best
+      def cleanup(status_code)
+        # Stop listenting to RPC calls
+        @messenger.close_input
+        # 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? }
+
+        # Hijack the status_code if an error occurred while cleaning up.
+        # 👀 unit tests.
+        return status_code_from_error(@error.pop) unless @error.empty?
+        status_code
+      ensure
+        @messenger.close_output
       end
     end
   end

data/lib/theme_check/language_server.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
 require_relative "language_server/constants"
+require_relative "language_server/channel"
+require_relative "language_server/messenger"
+require_relative "language_server/io_messenger"
+require_relative "language_server/bridge"
 require_relative "language_server/uri_helper"
 require_relative "language_server/handler"
 require_relative "language_server/server"
@@ -12,6 +16,7 @@ require_relative "language_server/completion_engine"
 require_relative "language_server/document_link_provider"
 require_relative "language_server/document_link_engine"
 require_relative "language_server/diagnostics_tracker"
+require_relative "language_server/diagnostics_engine"
 
 Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
   require file
@@ -24,7 +29,7 @@ end
 module ThemeCheck
   module LanguageServer
     def self.start
-      Server.new.listen
+      Server.new(messenger: IOMessenger.new).listen
     end
   end
 end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ThemeCheck
-  class Template < ThemeFile
+  class LiquidFile < ThemeFile
     def write
       content = rewriter.to_s
       if source != content
@@ -28,7 +28,7 @@ module ThemeCheck
     end
 
     def rewriter
-      @rewriter ||= TemplateRewriter.new(@relative_path, source)
+      @rewriter ||= ThemeFileRewriter.new(@relative_path, source)
     end
 
     def source_excerpt(line)