theme-check 1.7.2 → 1.9.2

data/lib/theme_check/language_server/configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Configuration
+      CHECK_ON_OPEN = :"themeCheck.checkOnOpen"
+      CHECK_ON_SAVE = :"themeCheck.checkOnSave"
+      CHECK_ON_CHANGE = :"themeCheck.checkOnChange"
+
+      def initialize(bridge, capabilities)
+        @bridge = bridge
+        @capabilities = capabilities
+        @mutex = Mutex.new
+        @initialized = false
+        @config = {
+          CHECK_ON_OPEN => @capabilities.initialization_option(CHECK_ON_OPEN) || true,
+          CHECK_ON_SAVE => @capabilities.initialization_option(CHECK_ON_SAVE) || true,
+          CHECK_ON_CHANGE => @capabilities.initialization_option(CHECK_ON_CHANGE) || true,
+        }
+      end
+
+      def fetch(force: nil)
+        @mutex.synchronize do
+          return unless @capabilities.supports_workspace_configuration?
+          return if initialized? && !force
+          check_on_open, check_on_save, check_on_change = @bridge.send_request(
+            "workspace/configuration",
+            items: [
+              { section: CHECK_ON_OPEN },
+              { section: CHECK_ON_SAVE },
+              { section: CHECK_ON_CHANGE },
+            ],
+          )
+          @config[CHECK_ON_OPEN] = check_on_open unless check_on_open.nil?
+          @config[CHECK_ON_CHANGE] = check_on_change unless check_on_change.nil?
+          @config[CHECK_ON_SAVE] = check_on_save unless check_on_save.nil?
+          @initialized = true
+        end
+      end
+
+      def register_did_change_capability
+        return unless @capabilities.supports_workspace_did_change_configuration_dynamic_registration?
+        @bridge.send_request('client/registerCapability', registrations: [{
+          id: "workspace/didChangeConfiguration",
+          method: "workspace/didChangeConfiguration",
+        }])
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      def check_on_open?
+        fetch # making sure we have an initialized value
+        @config[CHECK_ON_OPEN]
+      end
+
+      def check_on_save?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_SAVE]
+      end
+
+      def check_on_change?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_CHANGE]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/diagnostic.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Diagnostic
+      include URIHelper
+
+      attr_reader :offense
+
+      def initialize(offense)
+        @offense = offense
+        @diagnostic = nil
+      end
+
+      def ==(other)
+        case other
+        when Hash, Diagnostic
+          to_h == other.to_h
+        else
+          raise ArgumentError
+        end
+      end
+
+      def to_h
+        return @diagnostic unless @diagnostic.nil?
+        @diagnostic = {
+          source: "theme-check",
+          code: code,
+          message: message,
+          range: range,
+          severity: severity,
+          data: data,
+        }
+        @diagnostic[:codeDescription] = code_description unless offense.doc.nil?
+        @diagnostic
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      def single_file?
+        offense.single_file?
+      end
+
+      def correctable?
+        offense.correctable?
+      end
+
+      def code
+        offense.code_name
+      end
+
+      def message
+        offense.message
+      end
+
+      def code_description
+        {
+          href: offense.doc,
+        }
+      end
+
+      def severity
+        case offense.severity
+        when :error
+          1
+        when :suggestion
+          2
+        when :style
+          3
+        else
+          4
+        end
+      end
+
+      def range
+        {
+          start: {
+            line: offense.start_row,
+            character: offense.start_column,
+          },
+          end: {
+            line: offense.end_row,
+            character: offense.end_column,
+          },
+        }
+      end
+
+      def start_index
+        offense.start_index
+      end
+
+      def end_index
+        offense.end_index
+      end
+
+      def absolute_path
+        @absolute_path ||= offense&.theme_file&.path
+      end
+
+      def relative_path
+        @relative_path ||= offense&.theme_file&.relative_path
+      end
+
+      def uri
+        @uri ||= absolute_path && file_uri(absolute_path)
+      end
+
+      def file_version
+        @version ||= offense&.version
+      end
+
+      def data
+        {
+          absolute_path: absolute_path.to_s,
+          relative_path: relative_path.to_s,
+          uri: uri,
+          version: file_version,
+        }
+      end
+    end
+  end
+end

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