theme-check 1.10.3 → 1.12.0

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CompletionContext
+      include PositionHelper
+
+      attr_reader :storage, :relative_path, :line, :col
+
+      def initialize(storage, relative_path, line, col)
+        @storage = storage
+        @relative_path = relative_path
+        @line = line
+        @col = col
+      end
+
+      def buffer
+        @buffer ||= storage.read(relative_path)
+      end
+
+      def buffer_until_previous_row
+        @buffer_without_current_row ||= buffer[0..absolute_cursor].lines[0...-1].join
+      end
+
+      def absolute_cursor
+        @absolute_cursor ||= from_row_column_to_index(buffer, line, col)
+      end
+
+      def cursor
+        @cursor ||= absolute_cursor - token&.start || 0
+      end
+
+      def content
+        @content ||= token&.content
+      end
+
+      def token
+        @token ||= Tokens.new(buffer).find do |t|
+          # Here we include the next character and exclude the first
+          # one becase when we want to autocomplete inside a token
+          # and at most 1 outside it since the cursor could be placed
+          # at the end of the token.
+          t.start < absolute_cursor && absolute_cursor <= t.end
+        end
+      end
+
+      def clone_and_overwrite(col:)
+        CompletionContext.new(storage, relative_path, line, col)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/completion_engine.rb

@@ -3,35 +3,29 @@
 module ThemeCheck
   module LanguageServer
     class CompletionEngine
-      include PositionHelper
-
-      def initialize(storage)
+      def initialize(storage, bridge = nil)
         @storage = storage
+        @bridge = bridge
         @providers = CompletionProvider.all.map { |x| x.new(storage) }
       end
 
       def completions(relative_path, line, col)
-        buffer = @storage.read(relative_path)
-        cursor = from_row_column_to_index(buffer, line, col)
-        token = find_token(buffer, cursor)
-        return [] if token.nil?
+        context = context(relative_path, line, col)
+
+        @providers
+          .flat_map { |provider| provider.completions(context) }
+          .uniq { |completion_item| completion_item[:label] }
+      rescue StandardError => error
+        @bridge || raise(error)
+
+        message = error.message
+        backtrace = error.backtrace.join("\n")
 
-        @providers.flat_map do |p|
-          p.completions(
-            token.content,
-            cursor - token.start
-          )
-        end
+        @bridge.log("[completion error] error: #{message}\n#{backtrace}")
       end
 
-      def find_token(buffer, cursor)
-        Tokens.new(buffer).find do |token|
-          # Here we include the next character and exclude the first
-          # one becase when we want to autocomplete inside a token
-          # and at most 1 outside it since the cursor could be placed
-          # at the end of the token.
-          token.start < cursor && cursor <= token.end
-        end
+      def context(relative_path, line, col)
+        CompletionContext.new(@storage, relative_path, line, col)
       end
     end
   end

data/lib/theme_check/language_server/completion_provider.rb

@@ -6,6 +6,10 @@ module ThemeCheck
       include CompletionHelper
       include RegexHelpers
 
+      attr_reader :storage
+
+      CurrentToken = Struct.new(:content, :cursor, :absolute_cursor, :buffer)
+
       class << self
         def all
           @all ||= []
@@ -20,9 +24,20 @@ module ThemeCheck
         @storage = storage
       end
 
-      def completions(content, cursor)
+      def completions(relative_path, line, col)
         raise NotImplementedError
       end
+
+      def doc_hash(content)
+        return {} if content.nil? || content.empty?
+
+        {
+          documentation: {
+            kind: MarkupKinds::MARKDOWN,
+            value: content,
+          },
+        }
+      end
     end
   end
 end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class AssignmentsCompletionProvider < CompletionProvider
+      def completions(context)
+        content = context.buffer_until_previous_row
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
+        return [] unless variable_lookup.lookups.empty?
+        return [] if context.content[context.cursor - 1] == "."
+
+        finder = VariableLookupFinder::AssignmentsFinder.new(content)
+        finder.find!
+
+        finder.assignments.map do |label, potential_lookup|
+          object, _property = VariableLookupTraverser.lookup_object_and_property(potential_lookup)
+          object_to_completion(label, object.name)
+        end
+      end
+
+      private
+
+      def object_to_completion(label, object)
+        content = ShopifyLiquid::Documentation.object_doc(object)
+
+        {
+          label: label,
+          kind: CompletionItemKinds::VARIABLE,
+          **doc_hash(content),
+        }
+      end
+    end
+  end
+end

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

@@ -4,11 +4,19 @@ module ThemeCheck
   module LanguageServer
     class FilterCompletionProvider < CompletionProvider
       NAMED_FILTER = /#{Liquid::FilterSeparator}\s*(\w+)/o
+      FILTER_SEPARATOR_INCLUDING_SPACES = /\s*#{Liquid::FilterSeparator}/
+      INPUT_TYPE_VARIABLE = 'variable'
 
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless can_complete?(content, cursor)
-        available_labels
-          .select { |w| w.start_with?(partial(content, cursor)) }
+
+        context = context_with_cursor_before_potential_filter_separator(context)
+        available_filters_for(determine_input_type(context))
+          .select { |w| w.name.start_with?(partial(content, cursor)) }
           .map { |filter| filter_to_completion(filter) }
       end
 
@@ -21,12 +29,41 @@ module ThemeCheck
 
       private
 
-      def available_labels
-        @labels ||= ShopifyLiquid::Filter.labels - ShopifyLiquid::DeprecatedFilter.labels
+      def context_with_cursor_before_potential_filter_separator(context)
+        content = context.content
+        diff = content.index(FILTER_SEPARATOR_INCLUDING_SPACES) - context.cursor
+
+        return context unless content.scan(FILTER_SEPARATOR_INCLUDING_SPACES).size == 1
+
+        context.clone_and_overwrite(col: context.col + diff)
+      end
+
+      def determine_input_type(context)
+        variable_lookup = VariableLookupFinder.lookup(context)
+
+        if variable_lookup
+          object, property = VariableLookupTraverser.lookup_object_and_property(variable_lookup)
+          return property.return_type if property
+          return object.name if object
+        end
+      end
+
+      def available_filters_for(input_type)
+        filters = ShopifyLiquid::SourceIndex.filters
+          .select { |filter| input_type.nil? || filter.input_type == input_type }
+        return all_labels if filters.empty?
+        return filters if input_type == INPUT_TYPE_VARIABLE
+
+        filters + available_filters_for(INPUT_TYPE_VARIABLE)
+      end
+
+      def all_labels
+        available_filters_for(nil)
       end
 
       def cursor_on_filter?(content, cursor)
         return false unless content.match?(NAMED_FILTER)
+
         matches(content, NAMED_FILTER).any? do |match|
           match.begin(1) <= cursor && cursor < match.end(1) + 1 # including next character
         end
@@ -34,17 +71,23 @@ module ThemeCheck
 
       def partial(content, cursor)
         return '' unless content.match?(NAMED_FILTER)
+
         partial_match = matches(content, NAMED_FILTER).find do |match|
           match.begin(1) <= cursor && cursor < match.end(1) + 1 # including next character
         end
         return '' if partial_match.nil?
+
         partial_match[1]
       end
 
       def filter_to_completion(filter)
+        content = ShopifyLiquid::Documentation.render_doc(filter)
+
         {
-          label: filter,
+          label: filter.name,
           kind: CompletionItemKinds::FUNCTION,
+          tags: filter.deprecated? ? [CompletionItemTag::DEPRECATED] : [],
+          **doc_hash(content),
         }
       end
     end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ObjectAttributeCompletionProvider < CompletionProvider
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
+        return [] if content[cursor - 1] == "." && content[cursor - 2] == "."
+
+        # Navigate through lookups until the last valid [object, property] level
+        object, property = VariableLookupTraverser.lookup_object_and_property(variable_lookup)
+
+        # If the last lookup level is incomplete/invalid, use the partial term
+        # to filter object properties.
+        partial = partial_property_name(property, variable_lookup)
+
+        return [] unless object
+
+        object
+          .properties
+          .select { |prop| partial.nil? || prop.name.start_with?(partial) }
+          .map { |prop| property_to_completion(prop) }
+      end
+
+      private
+
+      def partial_property_name(property, variable_lookup)
+        last_property = variable_lookup.lookups.last
+        last_property if last_property != property&.name
+      end
+
+      def property_to_completion(prop)
+        content = ShopifyLiquid::Documentation.render_doc(prop)
+
+        {
+          label: prop.name,
+          kind: CompletionItemKinds::PROPERTY,
+          **doc_hash(content),
+        }
+      end
+    end
+  end
+end

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

@@ -3,19 +3,19 @@
 module ThemeCheck
   module LanguageServer
     class ObjectCompletionProvider < CompletionProvider
-      def completions(content, cursor)
-        return [] unless (variable_lookup = variable_lookup_at_cursor(content, cursor))
+      def completions(context)
+        content = context.content
+
+        return [] if content.nil?
+        return [] unless (variable_lookup = VariableLookupFinder.lookup(context))
         return [] unless variable_lookup.lookups.empty?
-        return [] if content[cursor - 1] == "."
+        return [] if content[context.cursor - 1] == "."
+
         ShopifyLiquid::Object.labels
           .select { |w| w.start_with?(partial(variable_lookup)) }
           .map { |object| object_to_completion(object) }
       end
 
-      def variable_lookup_at_cursor(content, cursor)
-        VariableLookupFinder.lookup(content, cursor)
-      end
-
       def partial(variable_lookup)
         variable_lookup.name || ''
       end
@@ -23,9 +23,12 @@ module ThemeCheck
       private
 
       def object_to_completion(object)
+        content = ShopifyLiquid::Documentation.object_doc(object)
+
         {
           label: object,
           kind: CompletionItemKinds::VARIABLE,
+          **doc_hash(content),
         }
       end
     end

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

@@ -3,7 +3,11 @@
 module ThemeCheck
   module LanguageServer
     class RenderSnippetCompletionProvider < CompletionProvider
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless cursor_on_quoted_argument?(content, cursor)
         partial = snippet(content) || ''
         snippets

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

@@ -3,7 +3,11 @@
 module ThemeCheck
   module LanguageServer
     class TagCompletionProvider < CompletionProvider
-      def completions(content, cursor)
+      def completions(context)
+        content = context.content
+        cursor = context.cursor
+
+        return [] if content.nil?
         return [] unless can_complete?(content, cursor)
         partial = first_word(content) || ''
         labels = ShopifyLiquid::Tag.labels
@@ -23,9 +27,12 @@ module ThemeCheck
       private
 
       def tag_to_completion(tag)
+        content = ShopifyLiquid::Documentation.tag_doc(tag)
+
         {
           label: tag,
           kind: CompletionItemKinds::KEYWORD,
+          **doc_hash(content),
         }
       end
     end

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,