theme-check 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 943f8cb722f6c19c1c41e494622922e608a99b50e4ad67f2288a2ed99f406ff3
-  data.tar.gz: a8fd83f054895fd366bba2512ff6431d8c470bb3e013ff6c6bf9f6be5366bf38
+  metadata.gz: 0c0071563941bd1e62d174c317667f7b1258a5154fdd0b9e65531a667aafbb53
+  data.tar.gz: fba3428de01a76fc042ee5c9fefe5acdcc1b446c02eafd5a2d187d503d863433
 SHA512:
-  metadata.gz: fb37aed715f2b9f2dd0a8c17f2abf69110d583280d88508ef3f6ee439989c63fe9819025d870cfc1ed64a8deaac19586ac48ab261495e7a371575d9971754980
-  data.tar.gz: 64727b7c9684fa094ce498c09a2a3f1dc06ce10fa99aed066af2aa327bd4de70fcc728f76ad127fd08d7b1b6e28b42b06acf96d83b26193814e7eed1b19a2008
+  metadata.gz: 9ebf3e7d3f24ca2d5d4f7b815199755bc997b94e870b3e60a2d24bc39f863974f7838f69548d11ccca9882335b3cf1522384b56f4bd3184d526ca968909cb192
+  data.tar.gz: dd9d5079b4adc9be6c13eb9cdf42e049e87988337e7881631eb0ee1163c8680930cb6efee863856221b1f8fd76fc81d9d848cd10969752f170cd032e371a42d0

data/CHANGELOG.md

@@ -1,4 +1,11 @@
 
+v1.7.1 / 2021-09-24
+===================
+
+  * Handle Errno::EADDRNOTAVAIL in RemoteAsset ([#465](https://github.com/shopify/theme-check/issues/465))
+  * Complete end tags ([#277](https://github.com/shopify/theme-check/issues/277))
+  * Do not flag shopify translations as missing or extra ([#407](https://github.com/shopify/theme-check/issues/407))
+
 v1.7.0 / 2021-09-20
 ===================
 

data/data/shopify_liquid/tags.yml

@@ -2,28 +2,28 @@
 - assign
 - break
 - capture
-- case
-- comment
+- case: endcase
+- comment: endcomment
 - continue
 - cycle
 - decrement
 - echo
 - else
 - elsif
-- for
-- form
-- if
+- for: endfor
+- form: endform
+- if: endif
 - ifchanged
 - increment
-- javascript
+- javascript: endjavascript
 - layout
 - liquid
-- paginate
+- paginate: endpaginate
 - raw
 - render
-- schema
+- schema: endschema
 - section
-- style
+- style: endstyle
 - stylesheet
 - tablerow
 - unless

data/lib/theme_check/checks/translation_key_exists.rb

@@ -1,17 +1,5 @@
 # frozen_string_literal: true
 module ThemeCheck
-  module SystemTranslations
-    extend self
-
-    def translations
-      @translations ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_translation_keys.yml")).to_set
-    end
-
-    def include?(key)
-      translations.include?(key)
-    end
-  end
-
   class TranslationKeyExists < LiquidCheck
     severity :error
     category :translation
@@ -24,7 +12,7 @@ module ThemeCheck
       return unless (key_node = node.children.first)
       return unless key_node.value.is_a?(String)
 
-      unless key_exists?(key_node.value) || SystemTranslations.include?(key_node.value)
+      unless key_exists?(key_node.value) || ShopifyLiquid::SystemTranslations.include?(key_node.value)
         add_offense(
           "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}'",
           node: node,

data/lib/theme_check/exceptions.rb

@@ -22,6 +22,7 @@ module ThemeCheck
     Errno::EAGAIN,
     Errno::EHOSTUNREACH,
     Errno::ENETUNREACH,
+    Errno::EADDRNOTAVAIL,
   ]
 
   NET_HTTP_EXCEPTIONS = [

data/lib/theme_check/file_system_storage.rb

@@ -11,6 +11,10 @@ module ThemeCheck
       @files = {}
     end
 
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
+
     def path(relative_path)
       @root.join(relative_path)
     end

data/lib/theme_check/language_server/bridge.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# 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.
+#
+#   - sending Hash messages as JSON
+#   - reading JSON messages as Hashes
+#   - preparing, sending and resolving requests
+#   - preparing and sending responses
+#   - preparing and sending notifications
+#   - preparing and sending progress notifications
+#
+# But it _not_ concerned by _how_ those messages are sent to the
+# outside world. That's the job of the messenger.
+#
+# This enables us to have all the language server protocol logic
+# in here living independently of how we communicate with the
+# client (STDIO or websocket)
+module ThemeCheck
+  module LanguageServer
+    class Bridge
+      attr_writer :supports_work_done_progress
+
+      def initialize(messenger)
+        # The messenger is responsible for IO.
+        # Could be STDIO or WebSockets or Mock.
+        @messenger = messenger
+
+        # Whether the client supports work done progress notifications
+        @supports_work_done_progress = false
+      end
+
+      def log(message)
+        @messenger.log(message)
+      end
+
+      def read_message
+        message_body = @messenger.read_message
+        message_json = JSON.parse(message_body)
+        @messenger.log(JSON.pretty_generate(message_json)) if $DEBUG
+        message_json
+      end
+
+      def send_message(message_hash)
+        message_hash[:jsonrpc] = '2.0'
+        message_body = JSON.dump(message_hash)
+        @messenger.log(JSON.pretty_generate(message_hash)) if $DEBUG
+        @messenger.send_message(message_body)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#requestMessage
+      def send_request(method, params = nil)
+        channel = Channel.create
+        message = { id: channel.id }
+        message[:method] = method
+        message[:params] = params if params
+        send_message(message)
+        channel.pop
+      ensure
+        channel.close
+      end
+
+      def receive_response(id, result)
+        Channel.by_id(id) << result
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
+      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
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+      def send_notification(method, params)
+        message = { method: method }
+        message[:params] = params
+        send_message(message)
+      end
+
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#progress
+      def send_progress(token, value)
+        send_notification("$/progress", token: token, value: value)
+      end
+
+      def supports_work_done_progress?
+        @supports_work_done_progress
+      end
+
+      def send_create_work_done_progress_request(token)
+        return unless supports_work_done_progress?
+        send_request("window/workDoneProgress/create", {
+          token: token,
+        })
+      end
+
+      def send_work_done_progress_begin(token, title)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'begin',
+          title: title,
+          cancellable: false,
+          percentage: 0,
+        })
+      end
+
+      def send_work_done_progress_report(token, message, percentage)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'report',
+          message: message,
+          cancellable: false,
+          percentage: percentage,
+        })
+      end
+
+      def send_work_done_progress_end(token, message)
+        return unless supports_work_done_progress?
+        send_progress(token, {
+          kind: 'end',
+          message: message,
+        })
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/channel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    # How you'd use this class:
+    #
+    # In thread #1:
+    #   def foo
+    #     chan = Channel.create
+    #     send_request(chan.id, ...)
+    #     result = chan.pop
+    #     do_stuff_with_result(result)
+    #   ensure
+    #     chan.close
+    #   end
+    #
+    # In thread #2:
+    #   Channel.by_id(id) << result
+    class Channel
+      MUTEX = Mutex.new
+      CHANNELS = {}
+
+      class << self
+        def create
+          id = new_id
+          CHANNELS[id] = new(id)
+          CHANNELS[id]
+        end
+
+        def by_id(id)
+          CHANNELS[id]
+        end
+
+        def close(id)
+          CHANNELS.delete(id)
+        end
+
+        private
+
+        def new_id
+          MUTEX.synchronize do
+            @id ||= 0
+            @id += 1
+          end
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+        @response = SizedQueue.new(1)
+      end
+
+      def pop
+        @response.pop
+      end
+
+      def <<(value)
+        @response << value
+      end
+
+      def close
+        @response.close
+        Channel.close(id)
+      end
+    end
+  end
+end

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

@@ -26,28 +26,22 @@ module ThemeCheck
         },
       }
 
-      def initialize(server)
-        @server = server
-        @diagnostics_tracker = DiagnosticsTracker.new
-        @diagnostics_lock = Mutex.new
-        @supports_progress = false
-      end
-
-      def supports_progress_notifications?
-        @supports_progress
+      def initialize(bridge)
+        @bridge = bridge
       end
 
       def on_initialize(id, params)
         @root_path = root_path_from_params(params)
-        @supports_progress = params.dig('capabilities', 'window', 'workDoneProgress')
 
         # 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,
         })
@@ -71,7 +65,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)
@@ -80,14 +74,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
@@ -141,50 +135,10 @@ module ThemeCheck
       end
 
       def analyze_and_send_offenses(absolute_path)
-        return unless @diagnostics_lock.try_lock
-        token = send_create_work_done_progress_request
-        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?
-          send_work_done_progress_begin(token, "Full theme check")
-          log("Checking #{config.root}")
-          offenses = nil
-          time = Benchmark.measure do
-            offenses = analyzer.analyze_theme do |path, i, total|
-              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"
-          log(end_message)
-          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
-            log("Checking #{relative_path}")
-            send_work_done_progress_begin(token, "Partial theme check")
-            offenses = nil
-            time = Benchmark.measure do
-              offenses = analyzer.analyze_files([file]) do |path, i, total|
-                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"
-            send_work_done_progress_end(token, end_message)
-            log(end_message)
-            send_diagnostics(offenses, [absolute_path])
-          end
-        end
-        @diagnostics_lock.unlock
       end
 
       def completions(relative_path, line, col)
@@ -195,141 +149,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_create_work_done_progress_request
-        return unless supports_progress_notifications?
-        token = nil
-        @server.request do |id|
-          token = id # we'll reuse the RQID as token
-          send_message({
-            id: id,
-            method: "window/workDoneProgress/create",
-            params: {
-              token: id,
-            },
-          })
-        end
-        token
-      end
-
-      def send_work_done_progress_begin(token, title)
-        return unless supports_progress_notifications?
-        send_progress(token, {
-          kind: 'begin',
-          title: title,
-          cancellable: false,
-          percentage: 0,
-        })
-      end
-
-      def send_work_done_progress_report(token, message, percentage)
-        return unless supports_progress_notifications?
-        send_progress(token, {
-          kind: 'report',
-          message: message,
-          cancellable: false,
-          percentage: percentage,
-        })
-      end
-
-      def send_work_done_progress_end(token, message)
-        return unless supports_progress_notifications?
-        send_progress(token, {
-          kind: 'end',
-          message: message,
-        })
-      end
-
-      def send_progress(token, value)
-        send_notification("$/progress", token: token, value: value)
-      end
-
-      def send_message(message)
-        message[:jsonrpc] = '2.0'
-        @server.send_message(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_request(method, params = nil)
-        @server.request do |id|
-          message = { id: id }
-          message[:method] = method
-          message[:params] = params if params
-          send_message(message)
-        end
-      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,97 @@
+# 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
+      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!
+      end
+
+      def send_message(message_body)
+        @out.write("Content-Length: #{message_body.bytesize}\r\n")
+        @out.write("\r\n")
+        @out.write(message_body)
+        @out.flush
+      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

@@ -3,54 +3,24 @@
 module ThemeCheck
   module LanguageServer
     class Messenger
-      def initialize
-        @responses = {}
-        @mutex = Mutex.new
-        @id = 0
+      def send_message
+        raise NotImplementedError
       end
 
-      # Here's how you'd use this:
-      #
-      # def some_method_that_communicates_both_ways
-      #
-      #   # this will block until the JSON rpc loop has an answer
-      #   token = @server.request do |id|
-      #     send_create_work_done_progress_request(id, ...)
-      #   end
-      #
-      #   send_create_work_done_begin_notification(token, "...")
-      #
-      #   do_stuff do |file, i, total|
-      #     send_create_work_done_progress_notification(token, "...")
-      #   end
-      #
-      #   send_create_work_done_end_notification(token, "...")
-      #
-      # end
-      def request(&block)
-        id = @mutex.synchronize { @id += 1 }
-        @responses[id] = SizedQueue.new(1)
-
-        # Execute the block in the parent thread with an ID
-        # So that we're able to relinquish control in the right
-        # place when we have a response.
-        block.call(id)
-
-        # this call is blocking until we get a response from somewhere
-        result = @responses[id].pop
+      def read_message
+        raise NotImplementedError
+      end
 
-        # cleanup when done
-        @responses.delete(id)
+      def log
+        raise NotImplementedError
+      end
 
-        # return the response
-        result
+      def close_input
+        raise NotImplementedError
       end
 
-      # In the JSONRPC loop, when we find the response to the
-      # request, we unblock the thread that made the request with the
-      # response.
-      def respond(id, value)
-        @responses[id] << value
+      def close_output
+        raise NotImplementedError
       end
     end
   end

data/lib/theme_check/language_server/server.rb

@@ -13,30 +13,18 @@ module ThemeCheck
       attr_reader :should_raise_errors
 
       def initialize(
-        in_stream: STDIN,
-        out_stream: STDOUT,
-        err_stream: STDERR,
+        messenger:,
         should_raise_errors: false,
         number_of_threads: 2
       )
-        validate!([in_stream, out_stream, err_stream])
+        # This is what does the IO
+        @messenger = messenger
 
-        @handler = Handler.new(self)
-        @in = in_stream
-        @out = out_stream
-        @err = err_stream
+        # This is what you use to communicate with the language client
+        @bridge = Bridge.new(@messenger)
 
-        # 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
+        # The handler handles messages from the language client
+        @handler = Handler.new(@bridge)
 
         # The queue holds the JSON RPC messages
         @queue = Queue.new
@@ -48,10 +36,6 @@ module ThemeCheck
         @number_of_threads = number_of_threads
         @handlers = []
 
-        # The messenger permits requests to be made from the handler
-        # to the language client and for those messages to be resolved in place.
-        @messenger = Messenger.new
-
         # The error queue holds blocks the main thread. When filled, we exit the program.
         @error = SizedQueue.new(1)
 
@@ -61,19 +45,23 @@ module ThemeCheck
       def listen
         start_handler_threads
         start_json_rpc_thread
-        status_code_from_error(@error.pop)
+        status_code = status_code_from_error(@error.pop)
+        cleanup(status_code)
       rescue SignalException
         0
-      ensure
-        cleanup
       end
 
       def start_json_rpc_thread
         @json_rpc_thread = Thread.new do
           loop do
-            message = read_json_rpc_message
+            message = @bridge.read_message
             if message['method'] == 'initialize'
               handle_message(message)
+            elsif message.key?('result')
+              # Responses are handled on the main thread to prevent
+              # a potential deadlock caused by all handlers waiting
+              # for a responses.
+              handle_response(message)
             else
               @queue << message
             end
@@ -106,103 +94,37 @@ module ThemeCheck
 
       rescue Exception => e # rubocop:disable Lint/RescueException
         raise e if should_raise_errors
-        log(e)
-        log(e.backtrace)
+        @bridge.log(e)
+        @bridge.log(e.backtrace)
         2
       end
 
-      def request(&block)
-        @messenger.request(&block)
-      end
-
-      def send_message(message)
-        message_body = JSON.dump(message)
-        log(JSON.pretty_generate(message)) if $DEBUG
-
-        @out.write("Content-Length: #{message_body.bytesize}\r\n")
-        @out.write("\r\n")
-        @out.write(message_body)
-        @out.flush
-      end
-
-      def log(message)
-        @err.puts(message)
-        @err.flush
-      end
-
       private
 
-      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
-
-      def read_json_rpc_message
-        message_body = read_new_content
-        message_json = JSON.parse(message_body)
-        log(JSON.pretty_generate(message_json)) if $DEBUG
-        message_json
-      end
-
       def handle_message(message)
         id = message['id']
         method_name = message['method']
         method_name &&= "on_#{to_snake_case(method_name)}"
         params = message['params']
-        result = message['result']
 
-        if message.key?('result')
-          @messenger.respond(id, result)
-        elsif @handler.respond_to?(method_name)
+        if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
       end
 
-      def to_snake_case(method_name)
-        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
-      end
-
-      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
+      def handle_response(message)
+        id = message['id']
+        result = message['result']
+        @bridge.receive_response(id, result)
       end
 
-      def read_new_content
-        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
-        content = ''
-        while content.length < length + 2
-          # Why + 2? Because \r\n
-          content += @in.read(length + 2)
-          raise DoneStreaming if @in.closed?
-        end
-
-        content
+      def to_snake_case(method_name)
+        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
       end
 
-      def cleanup
+      def cleanup(status_code)
         # Stop listenting to RPC calls
-        @in.close unless @in.closed?
+        @messenger.close_input
         # Wait for rpc loop to close
         @json_rpc_thread&.join if @json_rpc_thread&.alive?
         # Close the queue
@@ -210,9 +132,13 @@ module ThemeCheck
         # Give 10 seconds for the handlers to wrap up what they were
         # doing/emptying the queue. 👀 unit tests.
         @handlers.each { |thread| thread.join(10) if thread.alive? }
+
+        # Hijack the status_code if an error occurred while cleaning up.
+        # 👀 unit tests.
+        return status_code_from_error(@error.pop) unless @error.empty?
+        status_code
       ensure
-        @err.close
-        @out.close
+        @messenger.close_output
       end
     end
   end

data/lib/theme_check/language_server.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
-require_relative "language_server/messenger"
 require_relative "language_server/constants"
+require_relative "language_server/channel"
+require_relative "language_server/messenger"
+require_relative "language_server/io_messenger"
+require_relative "language_server/bridge"
 require_relative "language_server/uri_helper"
 require_relative "language_server/handler"
 require_relative "language_server/server"
@@ -13,6 +16,7 @@ require_relative "language_server/completion_engine"
 require_relative "language_server/document_link_provider"
 require_relative "language_server/document_link_engine"
 require_relative "language_server/diagnostics_tracker"
+require_relative "language_server/diagnostics_engine"
 
 Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
   require file
@@ -25,7 +29,7 @@ end
 module ThemeCheck
   module LanguageServer
     def self.start
-      Server.new.listen
+      Server.new(messenger: IOMessenger.new).listen
     end
   end
 end

data/lib/theme_check/locale_diff.rb

@@ -46,10 +46,12 @@ module ThemeCheck
       other = {} unless other.is_a?(Hash)
       return if pluralization?(default) && pluralization?(other)
 
-      @extra_keys += (other.keys - default.keys).map { |key| path + [key] }
+      shopify_translations = system_translations(path)
+
+      @extra_keys += (other.keys - default.keys - shopify_translations.keys).map { |key| path + [key] }
 
       default.each do |key, default_value|
-        translated_value = other[key]
+        translated_value = other[key] || shopify_translations[key]
         new_path = path + [key]
 
         if translated_value.nil?
@@ -65,5 +67,10 @@ module ThemeCheck
         PLURALIZATION_KEYS.include?(key) && !value.is_a?(Hash)
       end
     end
+
+    def system_translations(path)
+      return ShopifyLiquid::SystemTranslations.translations_hash if path.empty?
+      ShopifyLiquid::SystemTranslations.translations_hash.dig(*path) || {}
+    end
   end
 end

data/lib/theme_check/shopify_liquid/system_translations.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ThemeCheck
+  module ShopifyLiquid
+    module SystemTranslations
+      extend self
+
+      def translations
+        @translations ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_translation_keys.yml")).to_set
+      end
+
+      def translations_hash
+        @translations_hash ||= translations.reduce({}) do |acc, k|
+          dig_set(acc, k.split('.'), "")
+        end
+      end
+
+      def include?(key)
+        translations.include?(key)
+      end
+
+      private
+
+      def dig_set(obj, keys, value)
+        key = keys.first
+        if keys.length == 1
+          obj[key] = value
+        else
+          obj[key] = {} unless obj[key]
+          dig_set(obj[key], keys.slice(1..-1), value)
+        end
+        obj
+      end
+    end
+  end
+end

data/lib/theme_check/shopify_liquid/tag.rb

@@ -7,10 +7,17 @@ module ThemeCheck
       extend self
 
       def labels
-        @tags ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/tags.yml"))
+        @labels ||= tags_file_contents
+          .map { |x| to_label(x) }
           .to_set
       end
 
+      def end_labels
+        @end_labels ||= tags_file_contents
+          .select { |x| x.is_a?(Hash) }
+          .map { |x| x.values[0] }
+      end
+
       def tag_regex(tag)
         return unless labels.include?(tag)
         @tag_regexes ||= {}
@@ -22,6 +29,17 @@ module ThemeCheck
         @tag_liquid_regexes ||= {}
         @tag_liquid_regexes[tag] ||= /^\s*#{tag}/m
       end
+
+      private
+
+      def to_label(label)
+        return label if label.is_a?(String)
+        label.keys[0]
+      end
+
+      def tags_file_contents
+        @tags_file_contents ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/tags.yml"))
+      end
     end
   end
 end

data/lib/theme_check/shopify_liquid.rb

@@ -3,3 +3,4 @@ require_relative 'shopify_liquid/deprecated_filter'
 require_relative 'shopify_liquid/filter'
 require_relative 'shopify_liquid/object'
 require_relative 'shopify_liquid/tag'
+require_relative 'shopify_liquid/system_translations'

data/lib/theme_check/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ThemeCheck
-  VERSION = "1.7.0"
+  VERSION = "1.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: theme-check
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Marc-André Cournoyer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-20 00:00:00.000000000 Z
+date: 2021-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -201,6 +201,8 @@ files:
 - lib/theme_check/json_helpers.rb
 - lib/theme_check/json_printer.rb
 - lib/theme_check/language_server.rb
+- lib/theme_check/language_server/bridge.rb
+- lib/theme_check/language_server/channel.rb
 - lib/theme_check/language_server/completion_engine.rb
 - lib/theme_check/language_server/completion_helper.rb
 - lib/theme_check/language_server/completion_provider.rb
@@ -209,6 +211,7 @@ files:
 - lib/theme_check/language_server/completion_providers/render_snippet_completion_provider.rb
 - lib/theme_check/language_server/completion_providers/tag_completion_provider.rb
 - lib/theme_check/language_server/constants.rb
+- lib/theme_check/language_server/diagnostics_engine.rb
 - lib/theme_check/language_server/diagnostics_tracker.rb
 - lib/theme_check/language_server/document_link_engine.rb
 - lib/theme_check/language_server/document_link_provider.rb
@@ -217,6 +220,7 @@ files:
 - lib/theme_check/language_server/document_link_providers/render_document_link_provider.rb
 - lib/theme_check/language_server/document_link_providers/section_document_link_provider.rb
 - lib/theme_check/language_server/handler.rb
+- lib/theme_check/language_server/io_messenger.rb
 - lib/theme_check/language_server/messenger.rb
 - lib/theme_check/language_server/protocol.rb
 - lib/theme_check/language_server/server.rb
@@ -242,6 +246,7 @@ files:
 - lib/theme_check/shopify_liquid/deprecated_filter.rb
 - lib/theme_check/shopify_liquid/filter.rb
 - lib/theme_check/shopify_liquid/object.rb
+- lib/theme_check/shopify_liquid/system_translations.rb
 - lib/theme_check/shopify_liquid/tag.rb
 - lib/theme_check/storage.rb
 - lib/theme_check/string_helpers.rb