theme-check 1.6.1 → 1.7.2

data/lib/theme_check/disabled_checks.rb

@@ -11,8 +11,8 @@ module ThemeCheck
 
     def initialize
       @disabled_checks = Hash.new do |hash, key|
-        template, check_name = key
-        hash[key] = DisabledCheck.new(template, check_name)
+        theme_file, check_name = key
+        hash[key] = DisabledCheck.new(theme_file, check_name)
       end
     end
 
@@ -20,26 +20,26 @@ module ThemeCheck
       text = comment_text(node)
       if start_disabling?(text)
         checks_from_text(text).each do |check_name|
-          disabled = @disabled_checks[[node.template, check_name]]
+          disabled = @disabled_checks[[node.theme_file, check_name]]
           disabled.start_index = node.start_index
           disabled.first_line = true if node.line_number == 1
         end
       elsif stop_disabling?(text)
         checks_from_text(text).each do |check_name|
-          disabled = @disabled_checks[[node.template, check_name]]
+          disabled = @disabled_checks[[node.theme_file, check_name]]
           next unless disabled
           disabled.end_index = node.end_index
         end
       end
     end
 
-    def disabled?(check, template, check_name, index)
+    def disabled?(check, theme_file, check_name, index)
       return true if check.ignored_patterns&.any? do |pattern|
-        template.relative_path.fnmatch?(pattern)
+        theme_file.relative_path.fnmatch?(pattern)
       end
 
-      @disabled_checks[[template, :all]]&.disabled?(index) ||
-        @disabled_checks[[template, check_name]]&.disabled?(index)
+      @disabled_checks[[theme_file, :all]]&.disabled?(index) ||
+        @disabled_checks[[theme_file, check_name]]&.disabled?(index)
     end
 
     def checks_missing_end_index
@@ -51,7 +51,7 @@ module ThemeCheck
     def remove_disabled_offenses(checks)
       checks.disableable.each do |check|
         check.offenses.reject! do |offense|
-          disabled?(check, offense.template, offense.code_name, offense.start_index)
+          disabled?(check, offense.theme_file, offense.code_name, offense.start_index)
         end
       end
     end

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

@@ -2,18 +2,50 @@
 require "forwardable"
 
 module ThemeCheck
-  class HtmlNode
+  class HtmlNode < Node
     extend Forwardable
     include RegexHelpers
-    attr_reader :template, :parent
+    attr_reader :theme_file, :parent
 
-    def initialize(value, template, placeholder_values = [], parent = nil)
+    def initialize(value, theme_file, placeholder_values = [], parent = nil)
       @value = value
-      @template = template
+      @theme_file = theme_file
       @placeholder_values = placeholder_values
       @parent = parent
     end
 
+    # @value is not forwarded because we _need_ to replace the
+    # placeholders for the HtmlNode to make sense.
+    def value
+      if literal?
+        content
+      else
+        markup
+      end
+    end
+
+    def children
+      @children ||= @value
+        .children
+        .map { |child| HtmlNode.new(child, theme_file, @placeholder_values, self) }
+    end
+
+    def markup
+      @markup ||= replace_placeholders(@value.to_html)
+    end
+
+    def line_number
+      @value.line
+    end
+
+    def start_index
+      raise NotImplementedError
+    end
+
+    def end_index
+      raise NotImplementedError
+    end
+
     def literal?
       @value.name == "text"
     end
@@ -22,12 +54,6 @@ module ThemeCheck
       @value.element?
     end
 
-    def children
-      @children ||= @value
-        .children
-        .map { |child| HtmlNode.new(child, template, @placeholder_values, self) }
-    end
-
     def attributes
       @attributes ||= @value.attributes
         .map { |k, v| [replace_placeholders(k), replace_placeholders(v.value)] }
@@ -38,16 +64,6 @@ module ThemeCheck
       @content ||= replace_placeholders(@value.content)
     end
 
-    # @value is not forwarded because we _need_ to replace the
-    # placeholders for the HtmlNode to make sense.
-    def value
-      if literal?
-        content
-      else
-        markup
-      end
-    end
-
     def name
       if @value.name == "#document-fragment"
         "document"
@@ -56,14 +72,6 @@ module ThemeCheck
       end
     end
 
-    def markup
-      @markup ||= replace_placeholders(@value.to_html)
-    end
-
-    def line_number
-      @value.line
-    end
-
     private
 
     def replace_placeholders(string)

data/lib/theme_check/html_visitor.rb

@@ -11,18 +11,18 @@ module ThemeCheck
       @checks = checks
     end
 
-    def visit_template(template)
-      doc, placeholder_values = parse(template)
-      visit(HtmlNode.new(doc, template, placeholder_values))
+    def visit_liquid_file(liquid_file)
+      doc, placeholder_values = parse(liquid_file)
+      visit(HtmlNode.new(doc, liquid_file, placeholder_values))
     rescue ArgumentError => e
-      call_checks(:on_parse_error, e, template)
+      call_checks(:on_parse_error, e, liquid_file)
     end
 
     private
 
-    def parse(template)
+    def parse(liquid_file)
       placeholder_values = []
-      parseable_source = +template.source.clone
+      parseable_source = +liquid_file.source.clone
 
       # Replace all non-empty liquid tags with ≬{i}######≬ to prevent the HTML
       # parser from freaking out. We transparently replace those placeholders in

data/lib/theme_check/in_memory_storage.rb

@@ -2,7 +2,7 @@
 
 # An in-memory storage is not written to disk. The reasons why you'd
 # want to do that are your own. The idea is to not write to disk
-# something that doesn't need to be there. If you have your template
+# something that doesn't need to be there. If you have your theme
 # as a big hash already, leave it like that and save yourself some IO.
 module ThemeCheck
   class InMemoryStorage < Storage

data/lib/theme_check/json_check.rb

@@ -4,8 +4,8 @@ module ThemeCheck
   class JsonCheck < Check
     extend ChecksTracking
 
-    def add_offense(message, markup: nil, line_number: nil, template: nil, &block)
-      offenses << Offense.new(check: self, message: message, markup: markup, line_number: line_number, template: template, correction: block)
+    def add_offense(message, markup: nil, line_number: nil, theme_file: nil, &block)
+      offenses << Offense.new(check: self, message: message, markup: markup, line_number: line_number, theme_file: theme_file, correction: block)
     end
   end
 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/diagnostics_tracker.rb

@@ -19,22 +19,22 @@ module ThemeCheck
         new_single_file_offenses = {}
         analyzed_files = analyzed_files.map { |path| Pathname.new(path) } if analyzed_files
 
-        offenses.group_by(&:template).each do |template, template_offenses|
-          next unless template
+        offenses.group_by(&:theme_file).each do |theme_file, template_offenses|
+          next unless theme_file
           reported_offenses = template_offenses
-          previous_offenses = @single_files_offenses[template.path]
-          if analyzed_files.nil? || analyzed_files.include?(template.path)
+          previous_offenses = @single_files_offenses[theme_file.path]
+          if analyzed_files.nil? || analyzed_files.include?(theme_file.path)
             # We re-analyzed the file, so we know the template_offenses are update to date.
             reported_single_file_offenses = reported_offenses.select(&:single_file?)
             if reported_single_file_offenses.any?
-              new_single_file_offenses[template.path] = reported_single_file_offenses
+              new_single_file_offenses[theme_file.path] = reported_single_file_offenses
             end
           elsif previous_offenses
             # Merge in the previous ones, if some
             reported_offenses |= previous_offenses
           end
-          yield template.path, reported_offenses
-          reported_files << template.path
+          yield theme_file.path, reported_offenses
+          reported_files << theme_file.path
         end
 
         @single_files_offenses.each do |path, _|
@@ -51,7 +51,7 @@ module ThemeCheck
           reported_files << path
         end
 
-        # Publish diagnostics with empty array if all issues on a previously reported template
+        # Publish diagnostics with empty array if all issues on a previously reported theme_file
         # have been fixed.
         (@previously_reported_files - reported_files).each do |path|
           yield path, []