theme-check 1.8.0 → 1.9.0

data/lib/theme_check/language_server/diagnostics_engine.rb

@@ -5,31 +5,30 @@ module ThemeCheck
     class DiagnosticsEngine
       include URIHelper
 
-      def initialize(bridge)
+      attr_reader :storage
+
+      def initialize(storage, bridge, diagnostics_manager = DiagnosticsManager.new)
         @diagnostics_lock = Mutex.new
-        @diagnostics_tracker = DiagnosticsTracker.new
+        @diagnostics_manager = diagnostics_manager
+        @storage = storage
         @bridge = bridge
         @token = 0
       end
 
       def first_run?
-        @diagnostics_tracker.first_run?
+        @diagnostics_manager.first_run?
       end
 
-      def analyze_and_send_offenses(absolute_path, config)
+      def analyze_and_send_offenses(absolute_path, config, force: false)
         return unless @diagnostics_lock.try_lock
         @token += 1
         @bridge.send_create_work_done_progress_request(@token)
-        storage = ThemeCheck::FileSystemStorage.new(
-          config.root,
-          ignored_patterns: config.ignored_patterns
-        )
         theme = ThemeCheck::Theme.new(storage)
         analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
 
-        if @diagnostics_tracker.first_run?
+        if @diagnostics_manager.first_run? || force
           @bridge.send_work_done_progress_begin(@token, "Full theme check")
-          @bridge.log("Checking #{config.root}")
+          @bridge.log("Checking #{storage.root}")
           offenses = nil
           time = Benchmark.measure do
             offenses = analyzer.analyze_theme do |path, i, total|
@@ -55,7 +54,7 @@ module ThemeCheck
             end_message = "Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s"
             @bridge.send_work_done_progress_end(@token, end_message)
             @bridge.log(end_message)
-            send_diagnostics(offenses, [absolute_path])
+            send_diagnostics(offenses, [relative_path])
           end
         end
         @diagnostics_lock.unlock
@@ -64,62 +63,18 @@ module ThemeCheck
       private
 
       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)
+        @diagnostics_manager.build_diagnostics(offenses, analyzed_files: analyzed_files).each do |relative_path, diagnostics|
+          send_diagnostic(relative_path, diagnostics)
         end
       end
 
-      def send_diagnostic(path, offenses)
+      def send_diagnostic(relative_path, diagnostics)
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
         @bridge.send_notification('textDocument/publishDiagnostics', {
-          uri: file_uri(path),
-          diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
+          uri: file_uri(storage.path(relative_path)),
+          diagnostics: diagnostics.map(&:to_h),
         })
       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
     end
   end
 end

data/lib/theme_check/language_server/diagnostics_manager.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+require "logger"
+
+module ThemeCheck
+  module LanguageServer
+    class DiagnosticsManager
+      # This class exists to facilitate LanguageServer diagnostics tracking.
+      #
+      # Motivations:
+      #   1. The first time we lint, we want all the errors from all the files.
+      #   2. If we fix all the errors in a file, we have to send an empty array for that file.
+      #   3. If we do a partial check, we should consider the whole theme diagnostics as valid, and return cached results
+      #   4. We should be able to create WorkspaceEdits from diagnostics, so that the ExecuteCommandEngine can do its job
+      #   5. We should clean up diagnostics that were applied by the client
+      def initialize
+        @latest_diagnostics = {} # { [Pathname(relative_path)] => Diagnostic[] }
+        @mutex = Mutex.new
+        @first_run = true
+      end
+
+      def first_run?
+        @first_run
+      end
+
+      def diagnostics(relative_path)
+        relative_path = Pathname.new(relative_path) if relative_path.is_a?(String)
+        @mutex.synchronize { @latest_diagnostics[relative_path] || [] }
+      end
+
+      def build_diagnostics(offenses, analyzed_files: nil)
+        @mutex.synchronize do
+          full_check = analyzed_files.nil?
+          analyzed_paths = analyzed_files.map { |path| Pathname.new(path) } unless full_check
+
+          # When analyzed_files is nil, contains all offenses.
+          # When analyzed_files is !nil, contains all whole theme offenses and single file offenses of the analyzed_files.
+          current_diagnostics = offenses
+            .select(&:theme_file)
+            .group_by(&:theme_file)
+            .transform_keys { |theme_file| Pathname.new(theme_file.relative_path) }
+            .transform_values do |theme_file_offenses|
+              theme_file_offenses.map { |o| Diagnostic.new(o) }
+            end
+
+          previous_paths = paths(@latest_diagnostics)
+          current_paths = paths(current_diagnostics)
+
+          diagnostics_update = (current_paths + previous_paths).map do |path|
+            # When doing a full_check, we either send the current
+            # diagnostics or an empty array to clear the diagnostics
+            # for that file.
+            if full_check
+              [path, current_diagnostics[path] || []]
+
+            # When doing a partial check, the single file diagnostics
+            # from the previous runs should be sent. Otherwise the
+            # latest results are the good ones.
+            else
+              new_diagnostics = current_diagnostics[path] || []
+              should_use_cached_results = !analyzed_paths.include?(path)
+              old_diagnostics = should_use_cached_results ? single_file_diagnostics(path) : []
+              [path, new_diagnostics + old_diagnostics]
+            end
+          end.to_h
+
+          @latest_diagnostics = diagnostics_update.reject { |_, v| v.empty? }
+          @first_run = false
+          diagnostics_update
+        end
+      end
+
+      def workspace_edit(diagnostics)
+        diagnostics = sanitize(diagnostics)
+          .select(&:correctable?)
+
+        {
+          documentChanges: document_changes(diagnostics),
+        }
+      end
+
+      def delete_applied(diagnostics)
+        diagnostics = sanitize(diagnostics)
+          .select(&:correctable?)
+
+        previous_paths = paths(@latest_diagnostics)
+
+        diagnostics.each do |diagnostic|
+          delete(diagnostic.relative_path, diagnostic)
+        end
+
+        current_paths = paths(@latest_diagnostics)
+
+        (current_paths + previous_paths).map do |path|
+          [path, @latest_diagnostics[path] || []]
+        end.to_h
+      end
+
+      private
+
+      def sanitize(diagnostics)
+        diagnostics = diagnostics.map { |hash| find(hash) }.reject(&:nil?) if diagnostics[0]&.is_a?(Hash)
+        diagnostics
+      end
+
+      def delete(relative_path, diagnostic)
+        relative_path = Pathname.new(relative_path) if relative_path.is_a?(String)
+        @mutex.synchronize do
+          @latest_diagnostics[relative_path]&.delete(diagnostic)
+          @latest_diagnostics.delete(relative_path) if @latest_diagnostics[relative_path]&.empty?
+        end
+      end
+
+      def find(diagnostic_hash)
+        diagnostics(diagnostic_hash.dig(:data, :relative_path))
+          .find { |d| d == diagnostic_hash }
+      end
+
+      def document_changes(diagnostics)
+        corrector = DocumentChangeCorrector.new
+        diagnostics.each do |diagnostic|
+          offense = diagnostic.offense
+          offense.correct(corrector)
+        end
+        corrector.document_changes
+      end
+
+      def paths(diagnostics)
+        (diagnostics || {}).keys.map { |path| Pathname.new(path) }.to_set
+      end
+
+      def single_file_diagnostics(relative_path)
+        @latest_diagnostics[relative_path]&.select(&:single_file?) || []
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/document_change_corrector.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DocumentChangeCorrector
+      include URIHelper
+      include JsonHelpers
+
+      def initialize
+        @json_edits = {}
+        @json_file_edits = {}
+        @text_document_edits = {}
+        @create_files = []
+        @rename_files = []
+        @delete_files = []
+      end
+
+      def document_changes
+        apply_json_edits
+        apply_json_file_edits
+        @create_files + @rename_files + @text_document_edits.values + @delete_files
+      end
+
+      # @param node [Node]
+      def insert_before(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: {
+            start: start_location(position || node),
+            end: start_location(position || node),
+          },
+          newText: content,
+        }
+      end
+
+      # @param node [Node]
+      def insert_after(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: {
+            start: end_location(position || node),
+            end: end_location(position || node),
+          },
+          newText: content,
+        }
+      end
+
+      def replace(node, content, character_range = nil)
+        position = character_range_position(node, character_range) if character_range
+        edits(node) << {
+          range: range(position || node),
+          newText: content,
+        }
+      end
+
+      # @param node [LiquidNode]
+      def remove(node)
+        edits(node) << {
+          range: {
+            start: { line: node.outer_markup_start_row, character: node.outer_markup_start_column },
+            end: { line: node.outer_markup_end_row, character: node.outer_markup_end_column },
+          },
+          newText: '',
+        }
+      end
+
+      def replace_inner_markup(node, content)
+        edits(node) << {
+          range: {
+            start: {
+              line: node.inner_markup_start_row,
+              character: node.inner_markup_start_column,
+            },
+            end: {
+              line: node.inner_markup_end_row,
+              character: node.inner_markup_end_column,
+            },
+          },
+          newText: content,
+        }
+      end
+
+      def replace_inner_json(node, json, **pretty_json_opts)
+        # Kind of brittle alert: We're assuming that modifications are
+        # made directly on the same json hash (e.g. schema). As such,
+        # if this assumption is true, then it follows that the
+        # "correct" JSON is the _last_ one that we defined.
+        #
+        # We're going to append those changes to the text edit when
+        # we're done.
+        #
+        # We're doing this because no language client will accept
+        # text modifications that occur on the same range. So we need
+        # to dedup our JSON edits for the client to accept our change.
+        #
+        # What we're doing here is overwriting the json edit for a
+        # node to the latest one that is called. If all the edits
+        # occur on the same hash, this final hash will have all the
+        # edits in it.
+        @json_edits[node] = [json, pretty_json_opts]
+      end
+
+      def wrap(node, insert_before, insert_after)
+        edits(node) << {
+          range: range(node),
+          newText: insert_before + node.markup + insert_after,
+        }
+      end
+
+      def create_file(storage, relative_path, contents = nil, overwrite: false)
+        uri = file_uri(storage.path(relative_path))
+        @create_files << create_file_change(uri, overwrite)
+        return if contents.nil?
+        text_document = { uri: uri, version: nil }
+        @text_document_edits[text_document] = {
+          textDocument: text_document,
+          edits: [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: 0 },
+            },
+            newText: contents,
+          }],
+        }
+      end
+
+      def remove_file(storage, relative_path)
+        uri = file_uri(storage.path(relative_path))
+        @delete_files << delete_file_change(uri)
+      end
+
+      def mkdir(storage, relative_path)
+        path = Pathname.new(relative_path).join("tmp").to_s
+        # The LSP doesn't have a concept for directories, so what we
+        # do is create a file and then delete it.
+        #
+        # It does the job :upside_down_smile:.
+        create_file(storage, path)
+        remove_file(storage, path)
+      end
+
+      def add_translation(file, path, value)
+        raise ArgumentError unless file.is_a?(JsonFile)
+        hash = file.content
+        SchemaHelper.set(hash, path, value)
+        @json_file_edits[file] = hash
+      end
+
+      def remove_translation(file, path)
+        raise ArgumentError unless file.is_a?(JsonFile)
+        hash = file.content
+        SchemaHelper.delete(hash, path)
+        @json_file_edits[file] = hash
+      end
+
+      private
+
+      def apply_json_edits
+        @json_edits.each do |node, (json, pretty_json_opts)|
+          replace_inner_markup(node, pretty_json(json, **pretty_json_opts))
+        end
+      end
+
+      def apply_json_file_edits
+        @json_file_edits.each do |file, hash|
+          replace_entire_file(file, JSON.pretty_generate(hash))
+        end
+      end
+
+      def replace_entire_file(file, contents)
+        text_document = to_text_document(file)
+        position = ThemeCheck::StrictPosition.new(file.source, file.source, 0)
+        @text_document_edits[text_document] = {
+          textDocument: text_document,
+          edits: [{
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: position.end_row, character: position.end_column },
+            },
+            newText: contents,
+          }],
+        }
+      end
+
+      # @param node [Node]
+      def text_document_edit(node)
+        text_document = to_text_document(node)
+        @text_document_edits[text_document] ||= {
+          textDocument: text_document,
+          edits: [],
+        }
+      end
+
+      def create_file_change(uri, overwrite = false)
+        change = {}
+        change[:kind] = 'create'
+        change[:uri] = uri
+        change[:options] = { overwrite: overwrite } if overwrite
+        change
+      end
+
+      def delete_file_change(uri)
+        {
+          kind: 'delete',
+          uri: uri,
+        }
+      end
+
+      def edits(node)
+        text_document_edit(node)[:edits]
+      end
+
+      def to_text_document(thing)
+        case thing
+        when Node
+          {
+            uri: file_uri(thing.theme_file&.path),
+            version: thing.theme_file&.version,
+          }
+        when ThemeFile
+          {
+            uri: file_uri(thing.path),
+            version: thing.version,
+          }
+        else
+          raise ArgumentError
+        end
+      end
+
+      def absolute_path(node)
+        node.theme_file&.path
+      end
+
+      def character_range_position(node, character_range)
+        return unless character_range
+        source = node.theme_file.source
+        StrictPosition.new(
+          source[character_range],
+          source,
+          character_range.begin,
+        )
+      end
+
+      # @param node [ThemeCheck::Node]
+      def range(node)
+        {
+          start: start_location(node),
+          end: end_location(node),
+        }
+      end
+
+      def start_location(node)
+        {
+          line: node.start_row,
+          character: node.start_column,
+        }
+      end
+
+      def end_location(node)
+        {
+          line: node.end_row,
+          character: node.end_column,
+        }
+      end
+    end
+  end
+end

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