theme-check 1.7.0 → 1.9.0

data/lib/theme_check/language_server/handler.rb

@@ -17,7 +17,16 @@ module ThemeCheck
           triggerCharacters: ['.', '{{ ', '{% '],
           context: true,
         },
+        codeActionProvider: {
+          codeActionKinds: CodeActionProvider.all.map(&:kind),
+          resolveProvider: false,
+          workDoneProgress: false,
+        },
         documentLinkProvider: true,
+        executeCommandProvider: {
+          workDoneProgress: false,
+          commands: ExecuteCommandProvider.all.map(&:command),
+        },
         textDocumentSync: {
           openClose: true,
           change: TextDocumentSyncKind::FULL,
@@ -26,68 +35,104 @@ 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
+      def initialize(bridge)
+        @bridge = bridge
       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?
+        return @bridge.send_response(id, { capabilities: {} }) if @root_path.nil?
+
+        @client_capabilities = ClientCapabilities.new(params.dig(:capabilities) || {})
+        @configuration = Configuration.new(@bridge, @client_capabilities)
+        @bridge.supports_work_done_progress = @client_capabilities.supports_work_done_progress?
         @storage = in_memory_storage(@root_path)
+        @diagnostics_manager = DiagnosticsManager.new
         @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(@storage, @bridge, @diagnostics_manager)
+        @execute_command_engine = ExecuteCommandEngine.new
+        @execute_command_engine << CorrectionExecuteCommandProvider.new(@storage, @bridge, @diagnostics_manager)
+        @execute_command_engine << RunChecksExecuteCommandProvider.new(@diagnostics_engine, @root_path, config_for_path(@root_path))
+        @code_action_engine = CodeActionEngine.new(@storage, @diagnostics_manager)
+        @bridge.send_response(id, {
           capabilities: CAPABILITIES,
           serverInfo: SERVER_INFO,
         })
       end
 
+      def on_initialized(_id, _params)
+        @configuration.fetch
+        @configuration.register_did_change_capability
+      end
+
+      def on_shutdown(id, _params)
+        @bridge.send_response(id, nil)
+      end
+
       def on_exit(_id, _params)
         close!
       end
-      alias_method :on_shutdown, :on_exit
 
-      def on_text_document_did_change(_id, params)
+      def on_text_document_did_open(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
-        @storage.write(relative_path, content_changes_text(params))
+        @storage.write(relative_path, text_document_text(params), text_document_version(params))
+        analyze_and_send_offenses(text_document_uri(params)) if @configuration.check_on_open?
       end
 
-      def on_text_document_did_close(_id, params)
+      def on_text_document_did_change(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
-        @storage.write(relative_path, "")
+        @storage.write(relative_path, content_changes_text(params), text_document_version(params))
+        analyze_and_send_offenses(text_document_uri(params)) if @configuration.check_on_change?
       end
 
-      def on_text_document_did_open(_id, params)
+      def on_text_document_did_close(_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?
+        file_system_content = Pathname.new(text_document_uri(params)).read(mode: 'rb', encoding: 'UTF-8')
+        # On close, the file system becomes the source of truth
+        @storage.write(relative_path, file_system_content, nil)
       end
 
       def on_text_document_did_save(_id, params)
-        analyze_and_send_offenses(text_document_uri(params))
+        analyze_and_send_offenses(text_document_uri(params)) if @configuration.check_on_save?
       end
 
       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_link_engine.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))
+        line = params.dig(:position, :line)
+        col = params.dig(:position, :character)
+        @bridge.send_response(id, @completion_engine.completions(relative_path, line, col))
+      end
+
+      def on_text_document_code_action(id, params)
+        absolute_path = text_document_uri(params)
+        start_position = range_element(params, :start)
+        end_position = range_element(params, :end)
+        only_code_action_kinds = params.dig(:context, :only) || []
+        @bridge.send_response(id, @code_action_engine.code_actions(
+          absolute_path,
+          start_position,
+          end_position,
+          only_code_action_kinds,
+        ))
+      end
+
+      def on_workspace_execute_command(id, params)
+        @bridge.send_response(id, @execute_command_engine.execute(
+          params[:command],
+          params[:arguments],
+        ))
+      end
+
+      def on_workspace_did_change_configuration(_id, _params)
+        @configuration.fetch(force: true)
       end
 
       private
@@ -101,16 +146,16 @@ module ThemeCheck
           ignored_patterns: config.ignored_patterns
         )
 
-        # Turn that into a hash of empty buffers
+        # Turn that into a hash of buffers
         files = fs.files
-          .map { |fn| [fn, ""] }
+          .map { |fn| [fn, fs.read(fn)] }
           .to_h
 
-        InMemoryStorage.new(files, config.root)
+        VersionedInMemoryStorage.new(files, config.root)
       end
 
       def text_document_uri(params)
-        file_path(params.dig('textDocument', 'uri'))
+        file_path(params.dig(:textDocument, :uri))
       end
 
       def relative_path_from_text_document_uri(params)
@@ -118,8 +163,8 @@ module ThemeCheck
       end
 
       def root_path_from_params(params)
-        root_uri = params["rootUri"]
-        root_path = params["rootPath"]
+        root_uri = params[:rootUri]
+        root_path = params[:rootPath]
         if root_uri
           file_path(root_uri)
         elsif root_path
@@ -128,11 +173,15 @@ module ThemeCheck
       end
 
       def text_document_text(params)
-        params.dig('textDocument', 'text')
+        params.dig(:textDocument, :text)
+      end
+
+      def text_document_version(params)
+        params.dig(:textDocument, :version)
       end
 
       def content_changes_text(params)
-        params.dig('contentChanges', 0, 'text')
+        params.dig(:contentChanges, 0, :text)
       end
 
       def config_for_path(path)
@@ -141,195 +190,21 @@ 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,
-          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?
-          send_work_done_progress_begin(token, "Full theme check")
-          log("Checking #{config.root}")
-          offenses = nil
-          time = Benchmark.measure do
-            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
-          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
-          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}")
-            send_work_done_progress_begin(token, "Partial theme check")
-            offenses = nil
-            time = Benchmark.measure do
-              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
-            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)
-        @completion_engine.completions(relative_path, line, col)
-      end
-
-      def document_links(relative_path)
-        @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_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_message(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_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
-        send_message(message)
+      def range_element(params, start_or_end)
+        [
+          params.dig(:range, start_or_end, :line),
+          params.dig(:range, start_or_end, :character),
+        ]
       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,112 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class IOMessenger < Messenger
+      def self.err_stream
+        if ThemeCheck.debug_log_file
+          File.open(ThemeCheck.debug_log_file, "w")
+        else
+          STDERR
+        end
+      end
+
+      def initialize(
+        in_stream: STDIN,
+        out_stream: STDOUT,
+        err_stream: IOMessenger.err_stream
+      )
+        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!
+      rescue IOError
+        raise DoneStreaming
+      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

@@ -3,54 +3,24 @@
 module ThemeCheck
   module LanguageServer
     class Messenger
-      def initialize
-        @responses = {}
-        @mutex = Mutex.new
-        @id = 0
+      def send_message
+        raise NotImplementedError
       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
+      def read_message
+        raise NotImplementedError
+      end
 
-        # cleanup when done
-        @responses.delete(id)
+      def log
+        raise NotImplementedError
+      end
 
-        # return the response
-        result
+      def close_input
+        raise NotImplementedError
       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
+      def close_output
+        raise NotImplementedError
       end
     end
   end

data/lib/theme_check/language_server/protocol.rb

@@ -37,5 +37,9 @@ module ThemeCheck
       FULL = 1
       INCREMENTAL = 2
     end
+
+    module ErrorCodes
+      INTERNAL_ERROR = -32603
+    end
   end
 end