theme-check 1.7.0 → 1.9.0

data/lib/theme_check/language_server/code_action_provider.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CodeActionProvider
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+
+        def kind(k = nil)
+          @kind = k unless k.nil?
+          @kind
+        end
+      end
+
+      attr_reader :storage
+      attr_reader :diagnostics_manager
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @diagnostics_manager = diagnostics_manager
+      end
+
+      def kind
+        self.class.kind
+      end
+
+      def base_kind
+        kind.split('.')[0]
+      end
+
+      def code_actions(relative_path, range)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_providers/quickfix_code_action_provider.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class QuickfixCodeActionProvider < CodeActionProvider
+      kind "quickfix"
+
+      def code_actions(relative_path, range)
+        correctable_diagnostics = diagnostics_manager
+          .diagnostics(relative_path)
+          .filter(&:correctable?)
+          .reject do |diagnostic|
+            # We cannot quickfix if the buffer was modified. This means
+            # our diagnostics and InMemoryStorage are out of sync.
+            diagnostic.file_version != storage.version(diagnostic.relative_path)
+          end
+
+        diagnostics_under_cursor = correctable_diagnostics
+          .filter { |diagnostic| diagnostic.offense.in_range?(range) }
+
+        return [] if diagnostics_under_cursor.empty?
+
+        (
+          quickfix_cursor_code_actions(diagnostics_under_cursor) +
+          quickfix_all_of_type_code_actions(diagnostics_under_cursor, correctable_diagnostics) +
+          quickfix_all_code_action(correctable_diagnostics)
+        )
+      end
+
+      private
+
+      def quickfix_cursor_code_actions(diagnostics)
+        diagnostics.map do |diagnostic|
+          {
+            title: "Fix this #{diagnostic.code} problem: #{diagnostic.message}",
+            kind: kind,
+            diagnostics: [diagnostic.to_h],
+            isPreferred: true,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: [diagnostic.to_h],
+            },
+          }
+        end
+      end
+
+      def quickfix_all_of_type_code_actions(cursor_diagnostics, correctable_diagnostics)
+        codes = Set.new(cursor_diagnostics.map(&:code))
+        correctable_diagnostics_by_code = correctable_diagnostics.group_by(&:code)
+        codes.flat_map do |code|
+          diagnostics = correctable_diagnostics_by_code[code].map(&:to_h)
+          return [] unless diagnostics.size > 1
+          {
+            title: "Fix all #{code} problems",
+            kind: kind,
+            diagnostics: diagnostics,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics,
+            },
+          }
+        end
+      end
+
+      def quickfix_all_code_action(diagnostics)
+        return [] unless diagnostics.size > 1
+        diagnostics = diagnostics.map(&:to_h)
+        [{
+          title: "Fix all auto-fixable problems",
+          kind: kind,
+          diagnostics: diagnostics,
+          command: {
+            title: 'quickfix',
+            command: CorrectionExecuteCommandProvider.command,
+            arguments: diagnostics,
+          },
+        }]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_providers/source_fix_all_code_action_provider.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class SourceFixAllCodeActionProvider < CodeActionProvider
+      kind "source.fixAll"
+
+      def code_actions(relative_path, _)
+        diagnostics = diagnostics_manager
+          .diagnostics(relative_path)
+          .filter(&:correctable?)
+          .reject do |diagnostic|
+            # We cannot quickfix if the buffer was modified. This means
+            # our diagnostics and InMemoryStorage are out of sync.
+            diagnostic.file_version != storage.version(diagnostic.relative_path)
+          end
+          .map(&:to_h)
+        diagnostics_to_code_action(diagnostics)
+      end
+
+      private
+
+      def diagnostics_to_code_action(diagnostics)
+        return [] if diagnostics.empty?
+        [
+          {
+            title: "Fix all Theme Check auto-fixable problems",
+            kind: kind,
+            diagnostics: diagnostics,
+            command: {
+              title: 'fixAll.file',
+              command: LanguageServer::CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics,
+            },
+          },
+        ]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_providers/tag_completion_provider.rb

@@ -6,7 +6,9 @@ module ThemeCheck
       def completions(content, cursor)
         return [] unless can_complete?(content, cursor)
         partial = first_word(content) || ''
-        ShopifyLiquid::Tag.labels
+        labels = ShopifyLiquid::Tag.labels
+        labels += ShopifyLiquid::Tag.end_labels
+        labels
           .select { |w| w.start_with?(partial) }
           .map { |tag| tag_to_completion(tag) }
       end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DiagnosticsEngine
+      include URIHelper
+
+      attr_reader :storage
+
+      def initialize(storage, bridge, diagnostics_manager = DiagnosticsManager.new)
+        @diagnostics_lock = Mutex.new
+        @diagnostics_manager = diagnostics_manager
+        @storage = storage
+        @bridge = bridge
+        @token = 0
+      end
+
+      def first_run?
+        @diagnostics_manager.first_run?
+      end
+
+      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)
+        theme = ThemeCheck::Theme.new(storage)
+        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
+
+        if @diagnostics_manager.first_run? || force
+          @bridge.send_work_done_progress_begin(@token, "Full theme check")
+          @bridge.log("Checking #{storage.root}")
+          offenses = nil
+          time = Benchmark.measure do
+            offenses = analyzer.analyze_theme do |path, i, total|
+              @bridge.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"
+          @bridge.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
+            @bridge.send_work_done_progress_begin(@token, "Partial theme check")
+            offenses = nil
+            time = Benchmark.measure do
+              offenses = analyzer.analyze_files([file]) do |path, i, total|
+                @bridge.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"
+            @bridge.send_work_done_progress_end(@token, end_message)
+            @bridge.log(end_message)
+            send_diagnostics(offenses, [relative_path])
+          end
+        end
+        @diagnostics_lock.unlock
+      end
+
+      private
+
+      def send_diagnostics(offenses, analyzed_files = nil)
+        @diagnostics_manager.build_diagnostics(offenses, analyzed_files: analyzed_files).each do |relative_path, diagnostics|
+          send_diagnostic(relative_path, diagnostics)
+        end
+      end
+
+      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(storage.path(relative_path)),
+          diagnostics: diagnostics.map(&:to_h),
+        })
+      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