theme-check 1.7.2 → 1.9.2

data/lib/theme_check/language_server/document_link_provider.rb

@@ -37,12 +37,12 @@ module ThemeCheck
 
       def document_links(buffer)
         matches(buffer, partial_regexp).map do |match|
-          start_line, start_character = from_index_to_row_column(
+          start_row, start_column = from_index_to_row_column(
             buffer,
             match.begin(:partial),
           )
 
-          end_line, end_character = from_index_to_row_column(
+          end_row, end_column = from_index_to_row_column(
             buffer,
             match.end(:partial)
           )
@@ -51,12 +51,12 @@ module ThemeCheck
             target: file_link(match[:partial]),
             range: {
               start: {
-                line: start_line,
-                character: start_character,
+                line: start_row,
+                character: start_column,
               },
               end: {
-                line: end_line,
-                character: end_character,
+                line: end_row,
+                character: end_column,
               },
             },
           }

data/lib/theme_check/language_server/execute_command_engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ExecuteCommandEngine
+      def initialize
+        @providers = {}
+      end
+
+      def <<(provider)
+        @providers[provider.command] = provider
+      end
+
+      def execute(command, arguments)
+        @providers[command].execute(arguments)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/execute_command_provider.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ExecuteCommandProvider
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+
+        def command(cmd = nil)
+          @command = cmd unless cmd.nil?
+          @command
+        end
+      end
+
+      def execute(arguments)
+        raise NotImplementedError
+      end
+
+      def command
+        self.class.command
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/execute_command_providers/correction_execute_command_provider.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CorrectionExecuteCommandProvider < ExecuteCommandProvider
+      include URIHelper
+
+      command "correction"
+
+      attr_reader :storage, :bridge, :diagnostics_manager
+
+      def initialize(storage, bridge, diagnostics_manager)
+        @storage = storage
+        @bridge = bridge
+        @diagnostics_manager = diagnostics_manager
+      end
+
+      # The arguments passed to this method are the ones forwarded
+      # from the selected CodeAction by the client.
+      #
+      # @param diagnostic_hashes [Array] - of diagnostics
+      def execute(diagnostic_hashes)
+        # attempt to apply the document changes
+        workspace_edit = diagnostics_manager.workspace_edit(diagnostic_hashes)
+        result = bridge.send_request('workspace/applyEdit', {
+          label: 'Theme Check correction',
+          edit: workspace_edit,
+        })
+
+        # Bail if unable to apply changes
+        return unless result[:applied]
+
+        # Clean up internal representation of fixed diagnostics
+        diagnostics_update = diagnostics_manager.delete_applied(diagnostic_hashes)
+
+        # Send updated diagnostics to client
+        diagnostics_update
+          .map do |relative_path, diagnostics|
+            bridge.send_notification('textDocument/publishDiagnostics', {
+              uri: file_uri(storage.path(relative_path)),
+              diagnostics: diagnostics.map(&:to_h),
+            })
+            storage.path(relative_path)
+          end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/execute_command_providers/run_checks_execute_command_provider.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class RunChecksExecuteCommandProvider < ExecuteCommandProvider
+      include URIHelper
+
+      command "runChecks"
+
+      def initialize(diagnostics_engine, root_path, root_config)
+        @diagnostics_engine = diagnostics_engine
+        @root_path = root_path
+        @root_config = root_config
+      end
+
+      def execute(_args)
+        @diagnostics_engine.analyze_and_send_offenses(@root_path, @root_config, force: true)
+        nil
+      end
+    end
+  end
+end

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,
@@ -36,52 +45,94 @@ module ThemeCheck
         # Tell the client we don't support anything if there's no rootPath
         return @bridge.send_response(id, { capabilities: {} }) if @root_path.nil?
 
-        @bridge.supports_work_done_progress = params.dig('capabilities', 'window', 'workDoneProgress') || false
+        @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)
-        @diagnostics_engine = DiagnosticsEngine.new(@bridge)
+        @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_engine.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)
-        @bridge.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')
-        @bridge.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
@@ -95,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)
@@ -112,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
@@ -122,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,12 +196,11 @@ module ThemeCheck
         )
       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)
+      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)

data/lib/theme_check/language_server/io_messenger.rb

@@ -3,10 +3,18 @@
 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: STDERR
+        err_stream: IOMessenger.err_stream
       )
         validate!([in_stream, out_stream, err_stream])
 
@@ -40,6 +48,8 @@ module ThemeCheck
           content += chunk
         end
         content.lstrip!
+      rescue IOError
+        raise DoneStreaming
       end
 
       def send_message(message_body)

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

data/lib/theme_check/language_server/server.rb

@@ -37,7 +37,7 @@ module ThemeCheck
         @handlers = []
 
         # The error queue holds blocks the main thread. When filled, we exit the program.
-        @error = SizedQueue.new(1)
+        @error = SizedQueue.new(number_of_threads)
 
         @should_raise_errors = should_raise_errors
       end
@@ -55,9 +55,9 @@ module ThemeCheck
         @json_rpc_thread = Thread.new do
           loop do
             message = @bridge.read_message
-            if message['method'] == 'initialize'
+            if message[:method] == 'initialize'
               handle_message(message)
-            elsif message.key?('result')
+            elsif message.key?(:result)
               # Responses are handled on the main thread to prevent
               # a potential deadlock caused by all handlers waiting
               # for a responses.
@@ -94,27 +94,36 @@ module ThemeCheck
 
       rescue Exception => e # rubocop:disable Lint/RescueException
         raise e if should_raise_errors
-        @bridge.log(e)
-        @bridge.log(e.backtrace)
+        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
         2
       end
 
       private
 
       def handle_message(message)
-        id = message['id']
-        method_name = message['method']
+        id = message[:id]
+        method_name = message[:method]
         method_name &&= "on_#{to_snake_case(method_name)}"
-        params = message['params']
+        params = message[:params]
 
         if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
+
+      rescue DoneStreaming => e
+        raise e
+      rescue StandardError => e
+        is_request = id
+        raise e unless is_request
+        # Errors obtained in request handlers should be sent
+        # back as internal errors instead of closing the program.
+        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+        @bridge.send_internal_error(id, e)
       end
 
       def handle_response(message)
-        id = message['id']
-        result = message['result']
+        id = message[:id]
+        result = message[:result]
         @bridge.receive_response(id, result)
       end
 
@@ -135,7 +144,16 @@ module ThemeCheck
 
         # Hijack the status_code if an error occurred while cleaning up.
         # 👀 unit tests.
-        return status_code_from_error(@error.pop) unless @error.empty?
+        until @error.empty?
+          code = status_code_from_error(@error.pop)
+          # Promote the status_code to ERROR if one of the threads
+          # resulted in an error, otherwise leave the status_code as
+          # is. That's because one thread could end successfully in a
+          # DoneStreaming error while the other failed with an
+          # internal error. If we had an internal error, we should
+          # return with a status_code that fits.
+          status_code = code if code > status_code
+        end
         status_code
       ensure
         @messenger.close_output

data/lib/theme_check/language_server/uri_helper.rb

@@ -15,6 +15,7 @@ module ThemeCheck
       #
       # Exists because of https://github.com/Shopify/theme-check/issues/360
       def file_uri(absolute_path)
+        return if absolute_path.nil?
         "file://" + absolute_path
           .to_s
           .split('/')

data/lib/theme_check/language_server/versioned_in_memory_storage.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class VersionedInMemoryStorage < InMemoryStorage
+    Version = Struct.new(:id, :version)
+
+    attr_reader :versions
+
+    def initialize(files, root = "/dev/null")
+      super(files, root)
+      @versions = {}
+      @mutex = Mutex.new
+    end
+
+    # Motivations:
+    #   - Need way for LanguageServer to know on which version of a file
+    #     the check was run on, because we need to know where the
+    #     TextEdit goes. If the text changed, our TextEdit might not be
+    #     in the right spot. e.g.
+    #
+    #     Example:
+    #
+    #     ```
+    #     Hi
+    #     {{world}}
+    #     ```
+    #
+    #     Would produce two "SpaceInsideBrace" errors:
+    #
+    #     - One after {{ at index 5 to 6
+    #     - One before }} at index 10 to 11
+    #
+    #     If the user goes in and changes Hi to Sup, and _then_
+    #     right clicks to apply the code edit at index 5 to 6, he'd
+    #     get the following:
+    #
+    #     ```
+    #     Sup
+    #     { {world}}
+    #     ```
+    #
+    #     Which is not a fix at all.
+    #
+    # Solution:
+    #   - Have the LanguageServer store the version on textDocument/did{Open,Change,Close}
+    #   - Have ThemeFile store the version right after @storage.read.
+    #   - Add version to the diagnostic meta data
+    #   - Use diagnostic meta data to determine if we can make a code edit or not
+    #   - Only offer fixes on "clean" files (or offer the change but specify the version so the editor knows what to do with it)
+    def write(relative_path, content, version)
+      @mutex.synchronize do
+        @versions[relative_path] = version
+        super(relative_path, content)
+      end
+    end
+
+    def read_version(relative_path)
+      @mutex.synchronize { [read(relative_path), version(relative_path)] }
+    end
+
+    def versioned?
+      true
+    end
+
+    def version(relative_path)
+      @versions[relative_path.to_s]
+    end
+  end
+end

data/lib/theme_check/language_server.rb

@@ -1,31 +1,49 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
 require_relative "language_server/constants"
+require_relative "language_server/configuration"
 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"
 require_relative "language_server/tokens"
 require_relative "language_server/variable_lookup_finder"
+require_relative "language_server/diagnostic"
+require_relative "language_server/diagnostics_manager"
+require_relative "language_server/diagnostics_engine"
+require_relative "language_server/document_change_corrector"
+require_relative "language_server/versioned_in_memory_storage"
+require_relative "language_server/client_capabilities"
+
 require_relative "language_server/completion_helper"
 require_relative "language_server/completion_provider"
 require_relative "language_server/completion_engine"
+Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
+  require file
+end
+
 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/document_link_providers/*.rb"].each do |file|
+  require file
+end
 
-Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
+require_relative "language_server/execute_command_provider"
+require_relative "language_server/execute_command_engine"
+Dir[__dir__ + "/language_server/execute_command_providers/*.rb"].each do |file|
   require file
 end
 
-Dir[__dir__ + "/language_server/document_link_providers/*.rb"].each do |file|
+require_relative "language_server/code_action_provider"
+require_relative "language_server/code_action_engine"
+Dir[__dir__ + "/language_server/code_action_providers/*.rb"].each do |file|
   require file
 end
 
+require_relative "language_server/handler"
+
 module ThemeCheck
   module LanguageServer
     def self.start