theme-check 1.10.3 → 1.12.0

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)
@@ -50,12 +67,17 @@ module ThemeCheck
         @bridge.supports_work_done_progress = @client_capabilities.supports_work_done_progress?
         @storage = in_memory_storage(@root_path)
         @diagnostics_manager = DiagnosticsManager.new
-        @completion_engine = CompletionEngine.new(@storage)
+        @completion_engine = CompletionEngine.new(@storage, @bridge)
         @document_link_engine = DocumentLinkEngine.new(@storage)
         @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,8 +87,11 @@ module ThemeCheck
 
       def on_initialized(_id, _params)
         return unless @configuration
+
         @configuration.fetch
         @configuration.register_did_change_capability
+
+        ShopifyLiquid::SourceManager.download_or_refresh_files
       end
 
       def on_shutdown(id, _params)
@@ -91,9 +116,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 +158,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 +238,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 +268,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

data/lib/theme_check/language_server/protocol.rb

@@ -41,5 +41,14 @@ module ThemeCheck
     module ErrorCodes
       INTERNAL_ERROR = -32603
     end
+
+    module MarkupKinds
+      PLAIN_TEXT = 'plaintext'
+      MARKDOWN = 'markdown'
+    end
+
+    module CompletionItemTag
+      DEPRECATED = 1
+    end
   end
 end

data/lib/theme_check/language_server/server.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 require 'json'
 require 'stringio'
+require 'timeout'
 
 module ThemeCheck
   module LanguageServer
@@ -45,10 +47,29 @@ module ThemeCheck
       def listen
         start_handler_threads
         start_json_rpc_thread
-        status_code = status_code_from_error(@error.pop)
+        err = @error.pop
+        status_code = status_code_from_error(err)
+
+        if status_code > 0
+          # For a reason I can't comprehend, this hangs but prints
+          # anyway. So it's wrapped in this ugly timeout...
+          Timeout.timeout(1) do
+            $stderr.puts err.full_message
+          end
+
+          # Warn user of error, otherwise server might restart
+          # without telling you.
+          @bridge.send_notification("window/showMessage", {
+            type: 1,
+            message: "A theme-check-language-server error has occurred, search OUTPUT logs for details.",
+          })
+        end
+
         cleanup(status_code)
       rescue SignalException
         0
+      rescue StandardError
+        2
       end
 
       def start_json_rpc_thread
@@ -65,36 +86,43 @@ module ThemeCheck
             else
               @queue << message
             end
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            break @error << e
           end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @bridge.log("rescuing #{e.class} in jsonrpc thread")
+          @error << e
         end
       end
 
       def start_handler_threads
         @number_of_threads.times do
           @handlers << Thread.new do
-            loop do
-              message = @queue.pop
-              break if @queue.closed? && @queue.empty?
-              handle_message(message)
-            rescue Exception => e # rubocop:disable Lint/RescueException
-              break @error << e
-            end
+            handle_messages
           end
         end
       end
 
+      def handle_messages
+        loop do
+          message = @queue.pop
+          return if @queue.closed? && @queue.empty?
+
+          handle_message(message)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        @bridge.log("rescuing #{e.class} in handler thread")
+        @error << e
+      end
+
       def status_code_from_error(e)
         raise e
 
       # support ctrl+c and stuff
       rescue SignalException, DoneStreaming
         0
-
       rescue Exception => e # rubocop:disable Lint/RescueException
         raise e if should_raise_errors
-        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+
+        @bridge.log("Fatal #{e.class}")
         2
       end
 
@@ -109,15 +137,14 @@ module ThemeCheck
         if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
-
       rescue DoneStreaming => e
         raise e
       rescue StandardError => e
         is_request = id
         raise e unless is_request
+
         # Errors obtained in request handlers should be sent
         # back as internal errors instead of closing the program.
-        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
         @bridge.send_internal_error(id, e)
       end
 
@@ -132,6 +159,7 @@ module ThemeCheck
       end
 
       def cleanup(status_code)
+        @bridge.log("Closing server... status code = #{status_code}")
         # Stop listenting to RPC calls
         @messenger.close_input
         # Wait for rpc loop to close

data/lib/theme_check/language_server/type_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module TypeHelper
+      def input_type_of(literal)
+        case literal
+        when String
+          'string'
+        when Numeric
+          'number'
+        when TrueClass, FalseClass
+          'boolean'
+        when NilClass
+          'nil'
+        else
+          'untyped'
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/node_handler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class NodeHandler
+          def on_assign(node, scope)
+            # When a variable is redefined in a new scope we
+            # no longer can guarantee the type in the global scope
+            #
+            # Example:
+            # ```liquid
+            # {%- liquid
+            #   assign var1 = some_value
+            #
+            #   if condition
+            #     assign var1 = another_value
+            #            ^^^^ from here we no longer can guarantee
+            #                 the type of `var1` in the global scope
+            # -%}
+            # ```
+            p_scope = scope
+            while (p_scope = p_scope.parent)
+              p_scope.variables.delete(node.value.to)
+            end
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Table row tags do not rely on blocks to define scopes,
+          # so we index their value here
+          def on_table_row(node, scope)
+            scope = scope.new_child
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Define a new scope every time a new block is created
+          def on_block_body(node, scope)
+            scope = scope.new_child
+
+            ##
+            # 'for' tags handle blocks flattenly and differently
+            # than the other tags (if, unless, case).
+            #
+            # The scope of 'for' tags exists only in the first
+            # block, as the following one refers to the else
+            # statement of the iteration.
+            parent = node.parent
+
+            scope << parent if parent.type_name == :for && parent.children.first == node
+            scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/scope.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class Scope < Struct.new(:variables, :parent)
+          include TypeHelper
+
+          def new_child
+            child_scope = dup
+            child_scope.variables = variables.dup
+            child_scope.parent = self
+            child_scope
+          end
+
+          def <<(node)
+            tag = node.value
+
+            case tag
+            when Liquid::Assign
+              variable_name = tag.to
+              variables[variable_name] = assign_tag_as_potential_lookup(tag)
+            when Liquid::For, Liquid::TableRow
+              variable_name = tag.variable_name
+              variables[variable_name] = iteration_tag_as_potential_lookup(tag)
+            end
+          end
+
+          private
+
+          def assign_tag_as_potential_lookup(tag)
+            variable_lookup = tag.from.name
+
+            unless variable_lookup.is_a?(Liquid::VariableLookup)
+              return PotentialLookup.new(input_type_of(variable_lookup), [], variables)
+            end
+
+            name = variable_lookup.name
+            lookups = variable_lookup.lookups
+
+            PotentialLookup.new(name, lookups, variables)
+          end
+
+          def iteration_tag_as_potential_lookup(tag)
+            variable_lookup = tag.collection_name
+
+            name = variable_lookup.name
+            lookups = [*variable_lookup.lookups, 'first']
+
+            PotentialLookup.new(name, lookups, variables)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder/scope_visitor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class ScopeVisitor
+          attr_reader :global_scope, :current_scope
+
+          def initialize
+            @node_handler = NodeHandler.new
+            @global_scope = Scope.new({})
+            @current_scope = Scope.new({})
+          end
+
+          def visit_template(template)
+            return unless template
+
+            visit(liquid_node(template), global_scope)
+          end
+
+          private
+
+          def visit(node, scope)
+            return if node.type_name == :variable_lookup
+
+            method = :"on_#{node.type_name}"
+            scope = @node_handler.send(method, node, scope) if @node_handler.respond_to?(method)
+
+            @current_scope = scope
+
+            node.children.each { |child| visit(child, scope) }
+          end
+
+          def liquid_node(template)
+            LiquidNode.new(template.root, nil, template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder/assignments_finder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        include RegexHelpers
+
+        attr_reader :content, :scope_visitor
+
+        def initialize(content)
+          @content = close_tag(content)
+          @scope_visitor = ScopeVisitor.new
+        end
+
+        def find!
+          template = parse(content)
+
+          if template
+            visit_template(template)
+            return
+          end
+
+          liquid_tags.each do |tag|
+            visit_template(last_line_parse(tag))
+          end
+        end
+
+        def assignments
+          current_scope = scope_visitor.current_scope
+          current_scope.variables
+        end
+
+        private
+
+        def visit_template(template)
+          scope_visitor.visit_template(template)
+        end
+
+        def liquid_tags
+          matches(content, LIQUID_TAG_OR_VARIABLE)
+            .flat_map { |match| match[0] }
+        end
+
+        def parse(content)
+          regular_parse(content) || tolerant_parse(content)
+        end
+
+        def regular_parse(content)
+          Liquid::Template.parse(content)
+        rescue Liquid::SyntaxError
+          # Ignore syntax errors at the regular parse phase
+        end
+
+        def tolerant_parse(content)
+          TolerantParser::Template.parse(content)
+        rescue StandardError
+          # Ignore any error at the tolerant parse phase
+        end
+
+        def last_line_parse(content)
+          parsable_content = LiquidFixer.new(content).parsable
+
+          regular_parse(parsable_content)
+        end
+
+        def close_tag(content)
+          lines = content.lines
+          end_tag = lines.last =~ VARIABLE_START ? ' }}' : ' %}'
+
+          content + end_tag
+        end
+      end
+    end
+  end
+end