theme-check 1.10.1 → 1.11.0

data/lib/theme_check/checks/missing_template.rb

@@ -28,7 +28,11 @@ module ThemeCheck
     private
 
     def ignore?(path)
-      @ignore_missing.any? { |pattern| File.fnmatch?(pattern, path) }
+      all_ignored_patterns.any? { |pattern| File.fnmatch?(pattern, path) }
+    end
+
+    def all_ignored_patterns
+      @all_ignored_patterns ||= @ignore_missing + ignored_patterns
     end
 
     def add_missing_offense(name, node:)

data/lib/theme_check/checks/translation_key_exists.rb

@@ -48,6 +48,7 @@ module ThemeCheck
 
     def key_exists?(key, pointer)
       key.split(".").each do |token|
+        return false unless pointer.is_a?(Hash)
         return false unless pointer.key?(token)
         pointer = pointer[token]
       end

data/lib/theme_check/checks/undefined_object.rb

@@ -55,7 +55,8 @@ module ThemeCheck
       end
     end
 
-    def initialize(exclude_snippets: true)
+    def initialize(config_type: :default, exclude_snippets: true)
+      @config_type = config_type
       @exclude_snippets = exclude_snippets
       @files = {}
     end
@@ -111,6 +112,9 @@ module ThemeCheck
       shopify_plus_objects = ThemeCheck::ShopifyLiquid::Object.plus_labels
       shopify_plus_objects.freeze
 
+      theme_app_extension_objects = ThemeCheck::ShopifyLiquid::Object.theme_app_extension_labels
+      theme_app_extension_objects.freeze
+
       each_template do |(name, info)|
         if 'templates/customers/reset_password' == name
           # NOTE: `email` is exceptionally exposed as a theme object in
@@ -121,6 +125,8 @@ module ThemeCheck
           #       the checkout template
           # https://shopify.dev/docs/themes/theme-templates/checkout-liquid#optional-objects
           check_object(info, all_global_objects + shopify_plus_objects)
+        elsif config_type == :theme_app_extension
+          check_object(info, all_global_objects + theme_app_extension_objects)
         else
           check_object(info, all_global_objects)
         end
@@ -129,6 +135,8 @@ module ThemeCheck
 
     private
 
+    attr_reader :config_type
+
     def ignore?(node)
       @exclude_snippets && node.theme_file.snippet?
     end

data/lib/theme_check/checks/unused_assign.rb

@@ -39,7 +39,12 @@ module ThemeCheck
     end
 
     def on_variable_lookup(node)
-      @templates[node.theme_file.name].used_assigns << node.value.name
+      @templates[node.theme_file.name].used_assigns << case node.value.name
+      when Liquid::VariableLookup
+        node.value.name.name
+      else
+        node.value.name
+      end
     end
 
     def on_end

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
@@ -209,7 +209,8 @@ module ThemeCheck
 
     def resolve_requires
       self["require"]&.each do |path|
-        require(File.join(@root, path))
+        file_to_require = @root.join(path).realpath
+        require(file_to_require.to_s)
       end
     end
   end

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/json_printer.rb

@@ -25,7 +25,7 @@ module ThemeCheck
             styleCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:style] },
           }
         end
-        .sort_by { |o| o[:path] }
+        .sort_by { |o| o[:path] || Pathname.new('') }
     end
   end
 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