theme-check 1.10.3 → 1.11.0

data/lib/theme_check/checks/unused_snippet.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module ThemeCheck
@@ -11,16 +12,22 @@ module ThemeCheck
       @used_snippets = Set.new
     end
 
-    def on_include(node)
+    def on_render(node)
       if node.value.template_name_expr.is_a?(String)
         @used_snippets << "snippets/#{node.value.template_name_expr}"
+
+      elsif might_have_a_block_as_variable_lookup?(node)
+        # We ignore this case, because that's a "proper" use case for
+        # the render tag with OS 2.0
+        # {% render block %} shouldn't turn off the UnusedSnippet check
+
       else
         # Can't reliably track unused snippets if an expression is used, ignore this check
         @used_snippets.clear
         ignore!
       end
     end
-    alias_method :on_render, :on_include
+    alias_method :on_include, :on_render
 
     def on_end
       missing_snippets.each do |theme_file|
@@ -33,5 +40,46 @@ module ThemeCheck
     def missing_snippets
       theme.snippets.reject { |t| @used_snippets.include?(t.name) }
     end
+
+    private
+
+    # This function returns true when the render node passed might have a
+    # variable lookup that refers to a block as template_name_expr.
+    #
+    # e.g.
+    #
+    # {% for block in col %}
+    #   {% render block %}
+    # {% endfor %}
+    #
+    # In this case, the `block` variable_lookup in the render tag might be
+    # a Block because col might be an array of blocks.
+    #
+    # @param node [Node]
+    def might_have_a_block_as_variable_lookup?(node)
+      return false unless node.type_name == :render
+
+      return false unless node.value.template_name_expr.is_a?(Liquid::VariableLookup)
+
+      name = node.value.template_name_expr.name
+      return false unless name.is_a?(String)
+
+      # We're going through all the parents of the nodes until we find
+      # a For node with variable_name === to the template_name_expr's name
+      find_parent(node.parent) do |parent_node|
+        next false unless parent_node.type_name == :for
+
+        parent_node.value.variable_name == name
+      end
+    end
+
+    # @param node [Node]
+    def find_parent(node, &pred)
+      return nil unless node
+
+      return node if yield node
+
+      find_parent(node.parent, &pred)
+    end
   end
 end

data/lib/theme_check/config.rb

@@ -126,14 +126,14 @@ module ThemeCheck
         options_for_check = options.transform_keys(&:to_sym)
         options_for_check.delete(:enabled)
         severity = options_for_check.delete(:severity)
-        ignored_patterns = options_for_check.delete(:ignore) || []
+        check_ignored_patterns = options_for_check.delete(:ignore) || []
         check = if options_for_check.empty?
           check_class.new
         else
           check_class.new(**options_for_check)
         end
         check.severity = severity.to_sym if severity
-        check.ignored_patterns = ignored_patterns
+        check.ignored_patterns = check_ignored_patterns + ignored_patterns
         check.options = options_for_check
         check
       end.compact

data/lib/theme_check/disabled_checks.rb

@@ -34,14 +34,16 @@ module ThemeCheck
         # We want to disable checks inside comments
         # (e.g. html checks inside {% comment %})
         disabled = @disabled_checks[[node.theme_file, :all]]
-        disabled.start_index = node.inner_markup_start_index
-        disabled.end_index = node.inner_markup_end_index
+        unless disabled.first_line
+          disabled.start_index = node.inner_markup_start_index
+          disabled.end_index = node.inner_markup_end_index
+        end
       end
     end
 
     def disabled?(check, theme_file, check_name, index)
       return true if check.ignored_patterns&.any? do |pattern|
-        theme_file.relative_path.fnmatch?(pattern)
+        theme_file&.relative_path&.fnmatch?(pattern)
       end
 
       @disabled_checks[[theme_file, :all]]&.disabled?(index) ||
@@ -65,7 +67,12 @@ module ThemeCheck
     private
 
     def comment_text(node)
-      node.value.nodelist.join
+      case node.type_name
+      when :comment
+        node.value.nodelist.join
+      when :inline_comment
+        node.markup.sub(/\s*#+\s*/, '')
+      end
     end
 
     def start_disabling?(text)

data/lib/theme_check/file_system_storage.rb

@@ -21,6 +21,8 @@ module ThemeCheck
 
     def read(relative_path)
       file(relative_path).read(mode: 'rb', encoding: 'UTF-8')
+    rescue Errno::ENOENT
+      nil
     end
 
     def write(relative_path, content)

data/lib/theme_check/in_memory_storage.rb

@@ -9,7 +9,7 @@ module ThemeCheck
     attr_reader :root
 
     def initialize(files = {}, root = "/dev/null")
-      @files = files
+      @files = files # Hash<String, String>
       @root = Pathname.new(root)
     end
 

data/lib/theme_check/language_server/bridge.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 # This class exists as a bridge (or boundary) between our handlers and the outside world.
 #
 # It is concerned with all the Language Server Protocol constructs. i.e.
@@ -29,6 +31,9 @@ module ThemeCheck
 
         # Whether the client supports work done progress notifications
         @supports_work_done_progress = false
+
+        @work_done_progress_mutex = Mutex.new
+        @work_done_progress_token = 1
       end
 
       def log(message)
@@ -78,12 +83,17 @@ module ThemeCheck
 
       # https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#responseError
       def send_internal_error(id, e)
+        # For a reason I can't comprehend, sometimes
+        # e.full_message _hangs_ and brings your CPU to 100%.
+        # It's wrapped in here because it prints anyway...
+        # This shit is weird, yo.
+        Timeout.timeout(1) do
+          $stderr.puts e.full_message
+        end
+      ensure
         send_response(id, nil, {
           code: ErrorCodes::INTERNAL_ERROR,
-          message: <<~EOS,
-            #{e.class}: #{e.message}
-              #{e.backtrace.join("\n  ")}
-          EOS
+          message: "A theme-check-language-server has occured, inspect OUTPUT logs for details.",
         })
       end
 
@@ -103,15 +113,28 @@ module ThemeCheck
         @supports_work_done_progress
       end
 
-      def send_create_work_done_progress_request(token)
-        return unless supports_work_done_progress?
+      def send_create_work_done_progress_request
+        # This isn't necessary, but it kind of is to make it obvious
+        # that this variable is not thread safe. Don't try to refactor
+        # this with @work_done_progress_token because you're going to
+        # have a hard time.
+        token = @work_done_progress_mutex.synchronize do
+          @work_done_progress_token += 1
+        end
+
+        return token unless supports_work_done_progress?
+
+        # We're going to wait for a response here...
         send_request("window/workDoneProgress/create", {
           token: token,
         })
+
+        token
       end
 
       def send_work_done_progress_begin(token, title)
         return unless supports_work_done_progress?
+
         send_progress(token, {
           kind: 'begin',
           title: title,
@@ -122,6 +145,7 @@ module ThemeCheck
 
       def send_work_done_progress_report(token, message, percentage)
         return unless supports_work_done_progress?
+
         send_progress(token, {
           kind: 'report',
           message: message,
@@ -132,6 +156,7 @@ module ThemeCheck
 
       def send_work_done_progress_end(token, message)
         return unless supports_work_done_progress?
+
         send_progress(token, {
           kind: 'end',
           message: message,

data/lib/theme_check/language_server/diagnostics_engine.rb

@@ -12,57 +12,103 @@ module ThemeCheck
         @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, only_single_file: false)
+      def analyze_and_send_offenses(absolute_path_or_paths, config, force: false, only_single_file: 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 (!only_single_file && @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)
-          @bridge.log(end_message)
-          send_diagnostics(offenses)
+        if !only_single_file && (@diagnostics_manager.first_run? || force)
+          run_full_theme_check(analyzer)
         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], only_single_file: only_single_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], only_single_file: only_single_file)
-          end
+          run_partial_theme_check(absolute_path_or_paths, theme, analyzer, only_single_file)
+        end
+
+        @diagnostics_lock.unlock
+      end
+
+      def clear_diagnostics(relative_paths)
+        return unless @diagnostics_lock.try_lock
+
+        as_array(relative_paths).each do |relative_path|
+          send_clearing_diagnostics(relative_path)
         end
+
         @diagnostics_lock.unlock
       end
 
       private
 
+      def run_full_theme_check(analyzer)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        token = @bridge.send_create_work_done_progress_request
+        @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)
+        @bridge.log(end_message)
+        send_diagnostics(offenses)
+      end
+
+      def run_partial_theme_check(absolute_path_or_paths, theme, analyzer, only_single_file)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        relative_paths = as_array(absolute_path_or_paths).map do |absolute_path|
+          Pathname.new(storage.relative_path(absolute_path))
+        end
+
+        theme_files = relative_paths
+          .map { |relative_path| theme[relative_path] }
+          .reject(&:nil?)
+
+        deleted_relative_paths = relative_paths - theme_files.map(&:relative_path)
+        deleted_relative_paths
+          .each { |p| send_clearing_diagnostics(p) }
+
+        token = @bridge.send_create_work_done_progress_request
+        @bridge.send_work_done_progress_begin(token, "Partial theme check")
+        offenses = nil
+        time = Benchmark.measure do
+          offenses = analyzer.analyze_files(theme_files, only_single_file: only_single_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, theme_files.map(&:relative_path), only_single_file: only_single_file)
+      end
+
+      def send_clearing_diagnostics(relative_path)
+        raise 'Unsafe operation' unless @diagnostics_lock.owned?
+
+        relative_path = Pathname.new(relative_path) unless relative_path.is_a?(Pathname)
+        @diagnostics_manager.clear_diagnostics(relative_path)
+        send_diagnostic(relative_path, DiagnosticsManager::NO_DIAGNOSTICS)
+      end
+
+      def as_array(maybe_array)
+        case maybe_array
+        when Array
+          maybe_array
+        else
+          [maybe_array]
+        end
+      end
+
       def send_diagnostics(offenses, analyzed_files = nil, only_single_file: false)
         @diagnostics_manager.build_diagnostics(
           offenses,

data/lib/theme_check/language_server/diagnostics_manager.rb

@@ -4,6 +4,11 @@ require "logger"
 module ThemeCheck
   module LanguageServer
     class DiagnosticsManager
+      # The empty array is used in the protocol to mean that no
+      # diagnostics exist for this file. It's not always evident when
+      # reading code.
+      NO_DIAGNOSTICS = [].freeze
+
       # This class exists to facilitate LanguageServer diagnostics tracking.
       #
       # Motivations:
@@ -49,27 +54,27 @@ module ThemeCheck
             # When doing single file checks, we keep the whole theme old
             # ones and accept the new single ones
             if only_single_file && analyzed_paths.include?(path)
-              single_file_diagnostics = current_diagnostics[path] || []
-              whole_theme_diagnostics = whole_theme_diagnostics(path) || []
+              single_file_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
+              whole_theme_diagnostics = whole_theme_diagnostics(path) || NO_DIAGNOSTICS
               [path, single_file_diagnostics + whole_theme_diagnostics]
 
             # If doing single file checks that are not in the
             # analyzed_paths array then we just keep the old
             # diagnostics
             elsif only_single_file
-              [path, previous_diagnostics(path) || []]
+              [path, previous_diagnostics(path) || NO_DIAGNOSTICS]
 
             # When doing a full_check, we either send the current
             # diagnostics or an empty array to clear the diagnostics
             # for that file.
             elsif full_check
-              [path, current_diagnostics[path] || []]
+              [path, current_diagnostics[path] || NO_DIAGNOSTICS]
 
             # 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] || []
+              new_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
               should_use_cached_results = !analyzed_paths.include?(path)
               old_diagnostics = should_use_cached_results ? single_file_diagnostics(path) : []
               [path, new_diagnostics + old_diagnostics]
@@ -113,6 +118,13 @@ module ThemeCheck
         end.to_h
       end
 
+      # For when you know there shouldn't be anything on that file
+      # anymore. (e.g. file delete or file rename)
+      def clear_diagnostics(relative_path)
+        relative_path = sanitize_path(relative_path)
+        @latest_diagnostics.delete(relative_path)
+      end
+
       private
 
       def sanitize(diagnostics)
@@ -120,8 +132,17 @@ module ThemeCheck
         diagnostics
       end
 
+      def sanitize_path(relative_path)
+        case relative_path
+        when String
+          Pathname.new(relative_path)
+        else
+          relative_path
+        end
+      end
+
       def delete(relative_path, diagnostic)
-        relative_path = Pathname.new(relative_path) if relative_path.is_a?(String)
+        relative_path = sanitize_path(relative_path)
         @mutex.synchronize do
           @latest_diagnostics[relative_path]&.delete(diagnostic)
           @latest_diagnostics.delete(relative_path) if @latest_diagnostics[relative_path]&.empty?

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

@@ -7,17 +7,18 @@ module ThemeCheck
 
       command "runChecks"
 
-      def initialize(diagnostics_engine, root_path, root_config)
+      def initialize(diagnostics_engine, storage, linter_config, language_server_config)
         @diagnostics_engine = diagnostics_engine
-        @root_path = root_path
-        @root_config = root_config
+        @storage = storage
+        @linter_config = linter_config
+        @language_server_config = language_server_config
       end
 
       def execute(_args)
         @diagnostics_engine.analyze_and_send_offenses(
-          @root_path,
-          @root_config,
-          only_single_file: false,
+          @storage.opened_files.map { |relative_path| @storage.path(relative_path) },
+          @linter_config,
+          only_single_file: @language_server_config.only_single_file?,
           force: true
         )
         nil

data/lib/theme_check/language_server/handler.rb

@@ -12,6 +12,16 @@ module ThemeCheck
         version: ThemeCheck::VERSION,
       }
 
+      # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#fileOperationFilter
+      FILE_OPERATION_FILTER = {
+        filters: [{
+          scheme: 'file',
+          pattern: {
+            glob: '**/*',
+          },
+        }],
+      }
+
       CAPABILITIES = {
         completionProvider: {
           triggerCharacters: ['.', '{{ ', '{% '],
@@ -33,6 +43,13 @@ module ThemeCheck
           willSave: false,
           save: true,
         },
+        workspace: {
+          fileOperations: {
+            didCreate: FILE_OPERATION_FILTER,
+            didDelete: FILE_OPERATION_FILTER,
+            willRename: FILE_OPERATION_FILTER,
+          },
+        },
       }
 
       def initialize(bridge)
@@ -55,7 +72,12 @@ module ThemeCheck
         @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))
+        @execute_command_engine << RunChecksExecuteCommandProvider.new(
+          @diagnostics_engine,
+          @storage,
+          config_for_path(@root_path),
+          @configuration,
+        )
         @code_action_engine = CodeActionEngine.new(@storage, @diagnostics_manager)
         @bridge.send_response(id, {
           capabilities: CAPABILITIES,
@@ -65,6 +87,7 @@ module ThemeCheck
 
       def on_initialized(_id, _params)
         return unless @configuration
+
         @configuration.fetch
         @configuration.register_did_change_capability
       end
@@ -91,9 +114,17 @@ module ThemeCheck
 
       def on_text_document_did_close(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
-        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)
+        begin
+          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)
+
+        # the file no longer exists because either the user deleted it, or the user renamed it.
+        rescue Errno::ENOENT
+          @storage.remove(relative_path)
+        ensure
+          @diagnostics_engine.clear_diagnostics(relative_path) if @configuration.only_single_file?
+        end
       end
 
       def on_text_document_did_save(_id, params)
@@ -125,6 +156,52 @@ module ThemeCheck
         ))
       end
 
+      def on_workspace_did_create_files(_id, params)
+        paths = params[:files]
+          &.map { |file| file[:uri] }
+          &.map { |uri| file_path(uri) }
+        return unless paths
+
+        paths.each do |path|
+          relative_path = @storage.relative_path(path)
+          file_system_content = Pathname.new(path).read(mode: 'rb', encoding: 'UTF-8')
+          @storage.write(relative_path, file_system_content, nil)
+        end
+      end
+
+      def on_workspace_did_delete_files(_id, params)
+        absolute_paths = params[:files]
+          &.map { |file| file[:uri] }
+          &.map { |uri| file_path(uri) }
+        return unless absolute_paths
+
+        absolute_paths.each do |path|
+          relative_path = @storage.relative_path(path)
+          @storage.remove(relative_path)
+        end
+
+        analyze_and_send_offenses(absolute_paths)
+      end
+
+      # We're using workspace/willRenameFiles here because we want this to run
+      # before textDocument/didOpen and textDocumetn/didClose of the files
+      # (which might trigger another theme analysis).
+      def on_workspace_will_rename_files(id, params)
+        relative_paths = params[:files]
+          &.map { |file| [file[:oldUri], file[:newUri]] }
+          &.map { |(old_uri, new_uri)| [relative_path_from_uri(old_uri), relative_path_from_uri(new_uri)] }
+        return @bridge.send_response(id, nil) unless relative_paths
+
+        relative_paths.each do |(old_path, new_path)|
+          @storage.write(new_path, @storage.read(old_path), nil)
+          @storage.remove(old_path)
+        end
+        @bridge.send_response(id, nil)
+
+        absolute_paths = relative_paths.flatten(2).map { |p| @storage.path(p) }
+        analyze_and_send_offenses(absolute_paths)
+      end
+
       def on_workspace_execute_command(id, params)
         @bridge.send_response(id, @execute_command_engine.execute(
           params[:command],
@@ -159,6 +236,10 @@ module ThemeCheck
         file_path(params.dig(:textDocument, :uri))
       end
 
+      def relative_path_from_uri(uri)
+        @storage.relative_path(file_path(uri))
+      end
+
       def relative_path_from_text_document_uri(params)
         @storage.relative_path(text_document_uri(params))
       end
@@ -185,15 +266,16 @@ module ThemeCheck
         params.dig(:contentChanges, 0, :text)
       end
 
-      def config_for_path(path)
+      def config_for_path(path_or_paths)
+        path = path_or_paths.is_a?(Array) ? path_or_paths[0] : path_or_paths
         root = ThemeCheck::Config.find(path) || @root_path
         ThemeCheck::Config.from_path(root)
       end
 
-      def analyze_and_send_offenses(absolute_path, only_single_file: nil)
+      def analyze_and_send_offenses(absolute_path_or_paths, only_single_file: nil)
         @diagnostics_engine.analyze_and_send_offenses(
-          absolute_path,
-          config_for_path(absolute_path),
+          absolute_path_or_paths,
+          config_for_path(absolute_path_or_paths),
           only_single_file: only_single_file.nil? ? @configuration.only_single_file? : only_single_file
         )
       end