theme-check 1.6.2 → 1.8.0

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class DiagnosticsEngine
+      include URIHelper
+
+      def initialize(bridge)
+        @diagnostics_lock = Mutex.new
+        @diagnostics_tracker = DiagnosticsTracker.new
+        @bridge = bridge
+        @token = 0
+      end
+
+      def first_run?
+        @diagnostics_tracker.first_run?
+      end
+
+      def analyze_and_send_offenses(absolute_path, config)
+        return unless @diagnostics_lock.try_lock
+        @token += 1
+        @bridge.send_create_work_done_progress_request(@token)
+        storage = ThemeCheck::FileSystemStorage.new(
+          config.root,
+          ignored_patterns: config.ignored_patterns
+        )
+        theme = ThemeCheck::Theme.new(storage)
+        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
+
+        if @diagnostics_tracker.first_run?
+          @bridge.send_work_done_progress_begin(@token, "Full theme check")
+          @bridge.log("Checking #{config.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, [absolute_path])
+          end
+        end
+        @diagnostics_lock.unlock
+      end
+
+      private
+
+      def send_diagnostics(offenses, analyzed_files = nil)
+        @diagnostics_tracker.build_diagnostics(offenses, analyzed_files: analyzed_files) do |path, diagnostic_offenses|
+          send_diagnostic(path, diagnostic_offenses)
+        end
+      end
+
+      def send_diagnostic(path, offenses)
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+        @bridge.send_notification('textDocument/publishDiagnostics', {
+          uri: file_uri(path),
+          diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
+        })
+      end
+
+      def offense_to_diagnostic(offense)
+        diagnostic = {
+          code: offense.code_name,
+          message: offense.message,
+          range: range(offense),
+          severity: severity(offense),
+          source: "theme-check",
+        }
+        diagnostic["codeDescription"] = code_description(offense) unless offense.doc.nil?
+        diagnostic
+      end
+
+      def code_description(offense)
+        {
+          href: offense.doc,
+        }
+      end
+
+      def severity(offense)
+        case offense.severity
+        when :error
+          1
+        when :suggestion
+          2
+        when :style
+          3
+        else
+          4
+        end
+      end
+
+      def range(offense)
+        {
+          start: {
+            line: offense.start_line,
+            character: offense.start_column,
+          },
+          end: {
+            line: offense.end_line,
+            character: offense.end_column,
+          },
+        }
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/handler.rb

@@ -7,6 +7,11 @@ module ThemeCheck
     class Handler
       include URIHelper
 
+      SERVER_INFO = {
+        name: $PROGRAM_NAME,
+        version: ThemeCheck::VERSION,
+      }
+
       CAPABILITIES = {
         completionProvider: {
           triggerCharacters: ['.', '{{ ', '{% '],
@@ -21,29 +26,34 @@ module ThemeCheck
         },
       }
 
-      def initialize(server)
-        @server = server
-        @diagnostics_tracker = DiagnosticsTracker.new
+      def initialize(bridge)
+        @bridge = bridge
       end
 
       def on_initialize(id, params)
         @root_path = root_path_from_params(params)
 
         # Tell the client we don't support anything if there's no rootPath
-        return send_response(id, { capabilities: {} }) if @root_path.nil?
+        return @bridge.send_response(id, { capabilities: {} }) if @root_path.nil?
+
+        @bridge.supports_work_done_progress = params.dig('capabilities', 'window', 'workDoneProgress') || false
         @storage = in_memory_storage(@root_path)
         @completion_engine = CompletionEngine.new(@storage)
         @document_link_engine = DocumentLinkEngine.new(@storage)
-        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
-        send_response(id, {
+        @diagnostics_engine = DiagnosticsEngine.new(@bridge)
+        @bridge.send_response(id, {
           capabilities: CAPABILITIES,
+          serverInfo: SERVER_INFO,
         })
       end
 
+      def on_shutdown(id, _params)
+        @bridge.send_response(id, nil)
+      end
+
       def on_exit(_id, _params)
         close!
       end
-      alias_method :on_shutdown, :on_exit
 
       def on_text_document_did_change(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
@@ -58,7 +68,7 @@ module ThemeCheck
       def on_text_document_did_open(_id, params)
         relative_path = relative_path_from_text_document_uri(params)
         @storage.write(relative_path, text_document_text(params))
-        analyze_and_send_offenses(text_document_uri(params)) if @diagnostics_tracker.first_run?
+        analyze_and_send_offenses(text_document_uri(params)) if @diagnostics_engine.first_run?
       end
 
       def on_text_document_did_save(_id, params)
@@ -67,14 +77,14 @@ module ThemeCheck
 
       def on_text_document_document_link(id, params)
         relative_path = relative_path_from_text_document_uri(params)
-        send_response(id, document_links(relative_path))
+        @bridge.send_response(id, document_links(relative_path))
       end
 
       def on_text_document_completion(id, params)
         relative_path = relative_path_from_text_document_uri(params)
         line = params.dig('position', 'line')
         col = params.dig('position', 'character')
-        send_response(id, completions(relative_path, line, col))
+        @bridge.send_response(id, completions(relative_path, line, col))
       end
 
       private
@@ -128,38 +138,10 @@ module ThemeCheck
       end
 
       def analyze_and_send_offenses(absolute_path)
-        config = config_for_path(absolute_path)
-        storage = ThemeCheck::FileSystemStorage.new(
-          config.root,
-          ignored_patterns: config.ignored_patterns
+        @diagnostics_engine.analyze_and_send_offenses(
+          absolute_path,
+          config_for_path(absolute_path)
         )
-        theme = ThemeCheck::Theme.new(storage)
-        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
-
-        if @diagnostics_tracker.first_run?
-          # Analyze the full theme on first run
-          log("Checking #{config.root}")
-          offenses = nil
-          time = Benchmark.measure do
-            offenses = analyzer.analyze_theme
-          end
-          log("Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s")
-          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
-            log("Checking #{relative_path}")
-            offenses = nil
-            time = Benchmark.measure do
-              offenses = analyzer.analyze_files([file])
-            end
-            log("Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s")
-            send_diagnostics(offenses, [absolute_path])
-          end
-        end
       end
 
       def completions(relative_path, line, col)
@@ -170,84 +152,8 @@ module ThemeCheck
         @document_link_engine.document_links(relative_path)
       end
 
-      def send_diagnostics(offenses, analyzed_files = nil)
-        @diagnostics_tracker.build_diagnostics(offenses, analyzed_files: analyzed_files) do |path, diagnostic_offenses|
-          send_diagnostic(path, diagnostic_offenses)
-        end
-      end
-
-      def send_diagnostic(path, offenses)
-        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
-        send_notification('textDocument/publishDiagnostics', {
-          uri: file_uri(path),
-          diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
-        })
-      end
-
-      def offense_to_diagnostic(offense)
-        diagnostic = {
-          code: offense.code_name,
-          message: offense.message,
-          range: range(offense),
-          severity: severity(offense),
-          source: "theme-check",
-        }
-        diagnostic["codeDescription"] = code_description(offense) unless offense.doc.nil?
-        diagnostic
-      end
-
-      def code_description(offense)
-        {
-          href: offense.doc,
-        }
-      end
-
-      def severity(offense)
-        case offense.severity
-        when :error
-          1
-        when :suggestion
-          2
-        when :style
-          3
-        else
-          4
-        end
-      end
-
-      def range(offense)
-        {
-          start: {
-            line: offense.start_line,
-            character: offense.start_column,
-          },
-          end: {
-            line: offense.end_line,
-            character: offense.end_column,
-          },
-        }
-      end
-
-      def send_message(message)
-        message[:jsonrpc] = '2.0'
-        @server.send_response(message)
-      end
-
-      def send_response(id, result = nil, error = nil)
-        message = { id: id }
-        message[:result] = result if result
-        message[:error] = error if error
-        send_message(message)
-      end
-
-      def send_notification(method, params)
-        message = { method: method }
-        message[:params] = params
-        send_message(message)
-      end
-
       def log(message)
-        @server.log(message)
+        @bridge.log(message)
       end
 
       def close!

data/lib/theme_check/language_server/io_messenger.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class IOMessenger < Messenger
+      def initialize(
+        in_stream: STDIN,
+        out_stream: STDOUT,
+        err_stream: STDERR
+      )
+        validate!([in_stream, out_stream, err_stream])
+
+        @in = in_stream
+        @out = out_stream
+        @err = err_stream
+
+        # Because programming is fun,
+        #
+        # Ruby on Windows turns \n into \r\n. Which means that \r\n
+        # gets turned into \r\r\n. Which means that the protocol
+        # breaks on windows unless we turn STDOUT into binary mode.
+        #
+        # Hours wasted: 9.
+        @out.binmode
+
+        @out.sync = true # do not buffer
+        @err.sync = true # do not buffer
+
+        # Lock for writing, otherwise messages might be interspersed.
+        @writer = Mutex.new
+      end
+
+      def read_message
+        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
+        content = ''
+        length_to_read = 2 + length # 2 is the empty line length (\r\n)
+        while content.length < length_to_read
+          chunk = @in.read(length_to_read - content.length)
+          raise DoneStreaming if chunk.nil?
+          content += chunk
+        end
+        content.lstrip!
+      rescue IOError
+        raise DoneStreaming
+      end
+
+      def send_message(message_body)
+        @writer.synchronize do
+          @out.write("Content-Length: #{message_body.bytesize}\r\n")
+          @out.write("\r\n")
+          @out.write(message_body)
+          @out.flush
+        end
+      end
+
+      def log(message)
+        @err.puts(message)
+        @err.flush
+      end
+
+      def close_input
+        @in.close unless @in.closed?
+      end
+
+      def close_output
+        @err.close
+        @out.close
+      end
+
+      private
+
+      def initial_line
+        # Scanning for lines that fit the protocol.
+        while true
+          initial_line = @in.gets
+          # gets returning nil means the stream was closed.
+          raise DoneStreaming if initial_line.nil?
+
+          if initial_line.match(/Content-Length: (\d+)/)
+            break
+          end
+        end
+        initial_line
+      end
+
+      def supported_io_classes
+        [IO, StringIO]
+      end
+
+      def validate!(streams = [])
+        streams.each do |stream|
+          unless supported_io_classes.find { |klass| stream.is_a?(klass) }
+            raise IncompatibleStream, incompatible_stream_message
+          end
+        end
+      end
+
+      def incompatible_stream_message
+        'if provided, in_stream, out_stream, and err_stream must be a kind of '\
+        "one of the following: #{supported_io_classes.join(', ')}"
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/messenger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Messenger
+      def send_message
+        raise NotImplementedError
+      end
+
+      def read_message
+        raise NotImplementedError
+      end
+
+      def log
+        raise NotImplementedError
+      end
+
+      def close_input
+        raise NotImplementedError
+      end
+
+      def close_output
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/protocol.rb

@@ -37,5 +37,9 @@ module ThemeCheck
       FULL = 1
       INCREMENTAL = 2
     end
+
+    module ErrorCodes
+      INTERNAL_ERROR = -32603
+    end
   end
 end