theme-check 1.8.0 → 1.9.0

data/lib/theme_check/html_node.rb

@@ -5,12 +5,75 @@ module ThemeCheck
   class HtmlNode < Node
     extend Forwardable
     include RegexHelpers
+    include PositionHelper
     attr_reader :theme_file, :parent
 
-    def initialize(value, theme_file, placeholder_values = [], parent = nil)
+    class << self
+      include RegexHelpers
+
+      def parse(liquid_file)
+        placeholder_values = []
+        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
+        # HtmlNode.
+        #
+        # We're using base36 to prevent index bleeding on 36^3 tags.
+        # `{{x}}` -> `≬#{i}≬` would properly be transformed for 46656 tags in a single file.
+        # Should be enough.
+        #
+        # The base10 alternative would have overflowed at 1000 (`{{x}}` -> `≬1000≬`) which seemed more likely.
+        #
+        # Didn't go with base64 because of the `=` character that would have messed with HTML parsing.
+        #
+        # (Note, we're also maintaining newline characters in there so
+        # that line numbers match the source...)
+        matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
+          value = m[0]
+          next unless value.size > 4 # skip empty tags/variables {%%} and {{}}
+          placeholder_values.push(value)
+          key = (placeholder_values.size - 1).to_s(36)
+
+          # Doing shenanigans so that line numbers match... Ugh.
+          keyed_placeholder = parseable_source[m.begin(0)...m.end(0)]
+
+          # First and last chars are ≬
+          keyed_placeholder[0] = "≬"
+          keyed_placeholder[-1] = "≬"
+
+          # Non newline characters are #
+          keyed_placeholder.gsub!(/[^\n≬]/, '#')
+
+          # First few # are replaced by the base10 ID of the tag
+          i = -1
+          keyed_placeholder.gsub!('#') do
+            i += 1
+            if i > key.size - 1
+              '#'
+            else
+              key[i]
+            end
+          end
+
+          # Replace source by placeholder
+          parseable_source[m.begin(0)...m.end(0)] = keyed_placeholder
+        end
+
+        new(
+          Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
+          liquid_file,
+          placeholder_values,
+          parseable_source
+        )
+      end
+    end
+
+    def initialize(value, theme_file, placeholder_values, parseable_source, parent = nil)
       @value = value
       @theme_file = theme_file
       @placeholder_values = placeholder_values
+      @parseable_source = parseable_source
       @parent = parent
     end
 
@@ -27,11 +90,11 @@ module ThemeCheck
     def children
       @children ||= @value
         .children
-        .map { |child| HtmlNode.new(child, theme_file, @placeholder_values, self) }
+        .map { |child| HtmlNode.new(child, theme_file, @placeholder_values, @parseable_source, self) }
     end
 
     def markup
-      @markup ||= replace_placeholders(@value.to_html)
+      @markup ||= replace_placeholders(parseable_markup)
     end
 
     def line_number
@@ -39,11 +102,27 @@ module ThemeCheck
     end
 
     def start_index
-      raise NotImplementedError
+      position.start_index
     end
 
     def end_index
-      raise NotImplementedError
+      position.end_index
+    end
+
+    def start_row
+      position.start_row
+    end
+
+    def start_column
+      position.start_column
+    end
+
+    def end_row
+      position.end_row
+    end
+
+    def end_column
+      position.end_column
     end
 
     def literal?
@@ -60,6 +139,12 @@ module ThemeCheck
         .to_h
     end
 
+    def parseable_markup
+      start_index = from_row_column_to_index(@parseable_source, line_number - 1, 0)
+      @parseable_source
+        .match(/<\s*#{@value.name}[^>]*>/im, start_index)[0]
+    end
+
     def content
       @content ||= replace_placeholders(@value.content)
     end
@@ -74,10 +159,18 @@ module ThemeCheck
 
     private
 
+    def position
+      @position ||= Position.new(
+        markup,
+        theme_file.source,
+        line_number_1_indexed: line_number,
+      )
+    end
+
     def replace_placeholders(string)
       # Replace all ≬{i}####≬ with the actual content.
       string.gsub(HTML_LIQUID_PLACEHOLDER) do |match|
-        key = /[0-9a-z]+/.match(match)[0]
+        key = /[0-9a-z]+/.match(match.gsub("\n", ''))[0]
         @placeholder_values[key.to_i(36)]
       end
     end

data/lib/theme_check/html_visitor.rb

@@ -4,7 +4,6 @@ require "forwardable"
 
 module ThemeCheck
   class HtmlVisitor
-    include RegexHelpers
     attr_reader :checks
 
     def initialize(checks)
@@ -12,43 +11,13 @@ module ThemeCheck
     end
 
     def visit_liquid_file(liquid_file)
-      doc, placeholder_values = parse(liquid_file)
-      visit(HtmlNode.new(doc, liquid_file, placeholder_values))
+      visit(HtmlNode.parse(liquid_file))
     rescue ArgumentError => e
       call_checks(:on_parse_error, e, liquid_file)
     end
 
     private
 
-    def parse(liquid_file)
-      placeholder_values = []
-      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
-      # HtmlNode.
-      #
-      # We're using base36 to prevent index bleeding on 36^3 tags.
-      # `{{x}}` -> `≬#{i}≬` would properly be transformed for 46656 tags in a single file.
-      # Should be enough.
-      #
-      # The base10 alternative would have overflowed at 1000 (`{{x}}` -> `≬1000≬`) which seemed more likely.
-      #
-      # Didn't go with base64 because of the `=` character that would have messed with HTML parsing.
-      matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
-        value = m[0]
-        next unless value.size > 4 # skip empty tags/variables {%%} and {{}}
-        placeholder_values.push(value)
-        key = (placeholder_values.size - 1).to_s(36)
-        parseable_source[m.begin(0)...m.end(0)] = "≬#{key.ljust(m.end(0) - m.begin(0) - 2, '#')}≬"
-      end
-
-      [
-        Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
-        placeholder_values,
-      ]
-    end
-
     def visit(node)
       call_checks(:on_element, node) if node.element?
       call_checks(:"on_#{node.name}", node)

data/lib/theme_check/in_memory_storage.rb

@@ -6,6 +6,8 @@
 # as a big hash already, leave it like that and save yourself some IO.
 module ThemeCheck
   class InMemoryStorage < Storage
+    attr_reader :root
+
     def initialize(files = {}, root = "/dev/null")
       @files = files
       @root = Pathname.new(root)
@@ -29,6 +31,7 @@ module ThemeCheck
 
     def mkdir(relative_path)
       @files[relative_path] = nil
+      reset_memoizers
     end
 
     def files
@@ -46,5 +49,11 @@ module ThemeCheck
     def relative_path(absolute_path)
       Pathname.new(absolute_path).relative_path_from(@root).to_s
     end
+
+    private
+
+    def reset_memoizers
+      @directories = nil
+    end
   end
 end

data/lib/theme_check/json_helpers.rb

@@ -5,5 +5,19 @@ module ThemeCheck
       message = error.message[/\d+: (.+)$/, 1] || 'Invalid syntax'
       "#{message} in JSON"
     end
+
+    def pretty_json(hash, start_level: 1, indent: "  ")
+      start_indent = indent * start_level
+
+      <<~JSON
+
+        #{start_indent}#{JSON.pretty_generate(
+          hash,
+          indent: indent,
+          array_nl: "\n#{start_indent}",
+          object_nl: "\n#{start_indent}",
+        )}
+      JSON
+    end
   end
 end

data/lib/theme_check/language_server/bridge.rb

@@ -37,7 +37,7 @@ module ThemeCheck
 
       def read_message
         message_body = @messenger.read_message
-        message_json = JSON.parse(message_body)
+        message_json = JSON.parse(message_body, symbolize_names: true)
         @messenger.log(JSON.pretty_generate(message_json)) if ThemeCheck.debug?
         message_json
       end

data/lib/theme_check/language_server/client_capabilities.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class ClientCapabilities
+      def initialize(capabilities)
+        @capabilities = capabilities
+      end
+
+      def supports_work_done_progress?
+        @capabilities.dig(:window, :workDoneProgress) || false
+      end
+
+      def supports_workspace_configuration?
+        @capabilities.dig(:workspace, :configuration) || false
+      end
+
+      def supports_workspace_did_change_configuration_dynamic_registration?
+        @capabilities.dig(:workspace, :didChangeConfiguration, :dynamicRegistration) || false
+      end
+
+      def initialization_option(key)
+        @capabilities.dig(:initializationOptions, key)
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CodeActionEngine
+      include PositionHelper
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @providers = CodeActionProvider.all.map { |c| c.new(storage, diagnostics_manager) }
+      end
+
+      def code_actions(absolute_path, start_position, end_position, only_kinds = [])
+        relative_path = @storage.relative_path(absolute_path)
+        buffer = @storage.read(relative_path)
+        start_index = from_row_column_to_index(buffer, start_position[0], start_position[1])
+        end_index = from_row_column_to_index(buffer, end_position[0], end_position[1])
+        range = (start_index...end_index)
+
+        @providers
+          .filter do |provider|
+            only_kinds.empty? ||
+            only_kinds.include?(provider.kind) ||
+            only_kinds.include?(provider.base_kind)
+          end
+          .flat_map do |provider|
+            provider.code_actions(relative_path, range)
+          end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_provider.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class CodeActionProvider
+      class << self
+        def all
+          @all ||= []
+        end
+
+        def inherited(subclass)
+          all << subclass
+        end
+
+        def kind(k = nil)
+          @kind = k unless k.nil?
+          @kind
+        end
+      end
+
+      attr_reader :storage
+      attr_reader :diagnostics_manager
+
+      def initialize(storage, diagnostics_manager)
+        @storage = storage
+        @diagnostics_manager = diagnostics_manager
+      end
+
+      def kind
+        self.class.kind
+      end
+
+      def base_kind
+        kind.split('.')[0]
+      end
+
+      def code_actions(relative_path, range)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_providers/quickfix_code_action_provider.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class QuickfixCodeActionProvider < CodeActionProvider
+      kind "quickfix"
+
+      def code_actions(relative_path, range)
+        correctable_diagnostics = diagnostics_manager
+          .diagnostics(relative_path)
+          .filter(&:correctable?)
+          .reject do |diagnostic|
+            # We cannot quickfix if the buffer was modified. This means
+            # our diagnostics and InMemoryStorage are out of sync.
+            diagnostic.file_version != storage.version(diagnostic.relative_path)
+          end
+
+        diagnostics_under_cursor = correctable_diagnostics
+          .filter { |diagnostic| diagnostic.offense.in_range?(range) }
+
+        return [] if diagnostics_under_cursor.empty?
+
+        (
+          quickfix_cursor_code_actions(diagnostics_under_cursor) +
+          quickfix_all_of_type_code_actions(diagnostics_under_cursor, correctable_diagnostics) +
+          quickfix_all_code_action(correctable_diagnostics)
+        )
+      end
+
+      private
+
+      def quickfix_cursor_code_actions(diagnostics)
+        diagnostics.map do |diagnostic|
+          {
+            title: "Fix this #{diagnostic.code} problem: #{diagnostic.message}",
+            kind: kind,
+            diagnostics: [diagnostic.to_h],
+            isPreferred: true,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: [diagnostic.to_h],
+            },
+          }
+        end
+      end
+
+      def quickfix_all_of_type_code_actions(cursor_diagnostics, correctable_diagnostics)
+        codes = Set.new(cursor_diagnostics.map(&:code))
+        correctable_diagnostics_by_code = correctable_diagnostics.group_by(&:code)
+        codes.flat_map do |code|
+          diagnostics = correctable_diagnostics_by_code[code].map(&:to_h)
+          return [] unless diagnostics.size > 1
+          {
+            title: "Fix all #{code} problems",
+            kind: kind,
+            diagnostics: diagnostics,
+            command: {
+              title: 'quickfix',
+              command: CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics,
+            },
+          }
+        end
+      end
+
+      def quickfix_all_code_action(diagnostics)
+        return [] unless diagnostics.size > 1
+        diagnostics = diagnostics.map(&:to_h)
+        [{
+          title: "Fix all auto-fixable problems",
+          kind: kind,
+          diagnostics: diagnostics,
+          command: {
+            title: 'quickfix',
+            command: CorrectionExecuteCommandProvider.command,
+            arguments: diagnostics,
+          },
+        }]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/code_action_providers/source_fix_all_code_action_provider.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class SourceFixAllCodeActionProvider < CodeActionProvider
+      kind "source.fixAll"
+
+      def code_actions(relative_path, _)
+        diagnostics = diagnostics_manager
+          .diagnostics(relative_path)
+          .filter(&:correctable?)
+          .reject do |diagnostic|
+            # We cannot quickfix if the buffer was modified. This means
+            # our diagnostics and InMemoryStorage are out of sync.
+            diagnostic.file_version != storage.version(diagnostic.relative_path)
+          end
+          .map(&:to_h)
+        diagnostics_to_code_action(diagnostics)
+      end
+
+      private
+
+      def diagnostics_to_code_action(diagnostics)
+        return [] if diagnostics.empty?
+        [
+          {
+            title: "Fix all Theme Check auto-fixable problems",
+            kind: kind,
+            diagnostics: diagnostics,
+            command: {
+              title: 'fixAll.file',
+              command: LanguageServer::CorrectionExecuteCommandProvider.command,
+              arguments: diagnostics,
+            },
+          },
+        ]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Configuration
+      CHECK_ON_OPEN = :"themeCheck.checkOnOpen"
+      CHECK_ON_SAVE = :"themeCheck.checkOnSave"
+      CHECK_ON_CHANGE = :"themeCheck.checkOnChange"
+
+      def initialize(bridge, capabilities)
+        @bridge = bridge
+        @capabilities = capabilities
+        @mutex = Mutex.new
+        @initialized = false
+        @config = {
+          CHECK_ON_OPEN => @capabilities.initialization_option(CHECK_ON_OPEN) || true,
+          CHECK_ON_SAVE => @capabilities.initialization_option(CHECK_ON_SAVE) || true,
+          CHECK_ON_CHANGE => @capabilities.initialization_option(CHECK_ON_CHANGE) || true,
+        }
+      end
+
+      def fetch(force: nil)
+        @mutex.synchronize do
+          return unless @capabilities.supports_workspace_configuration?
+          return if initialized? && !force
+          check_on_open, check_on_save, check_on_change = @bridge.send_request(
+            "workspace/configuration",
+            items: [
+              { section: CHECK_ON_OPEN },
+              { section: CHECK_ON_SAVE },
+              { section: CHECK_ON_CHANGE },
+            ],
+          )
+          @config[CHECK_ON_OPEN] = check_on_open unless check_on_open.nil?
+          @config[CHECK_ON_CHANGE] = check_on_change unless check_on_change.nil?
+          @config[CHECK_ON_SAVE] = check_on_save unless check_on_save.nil?
+          @initialized = true
+        end
+      end
+
+      def register_did_change_capability
+        return unless @capabilities.supports_workspace_did_change_configuration_dynamic_registration?
+        @bridge.send_request('client/registerCapability', registrations: [{
+          id: "workspace/didChangeConfiguration",
+          method: "workspace/didChangeConfiguration",
+        }])
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      def check_on_open?
+        fetch # making sure we have an initialized value
+        @config[CHECK_ON_OPEN]
+      end
+
+      def check_on_save?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_SAVE]
+      end
+
+      def check_on_change?
+        fetch # making sure we have for an initialized value
+        @config[CHECK_ON_CHANGE]
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/diagnostic.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    class Diagnostic
+      include URIHelper
+
+      attr_reader :offense
+
+      def initialize(offense)
+        @offense = offense
+        @diagnostic = nil
+      end
+
+      def ==(other)
+        case other
+        when Hash, Diagnostic
+          to_h == other.to_h
+        else
+          raise ArgumentError
+        end
+      end
+
+      def to_h
+        return @diagnostic unless @diagnostic.nil?
+        @diagnostic = {
+          source: "theme-check",
+          code: code,
+          message: message,
+          range: range,
+          severity: severity,
+          data: data,
+        }
+        @diagnostic[:codeDescription] = code_description unless offense.doc.nil?
+        @diagnostic
+      end
+
+      def to_s
+        to_h.to_s
+      end
+
+      def single_file?
+        offense.single_file?
+      end
+
+      def correctable?
+        offense.correctable?
+      end
+
+      def code
+        offense.code_name
+      end
+
+      def message
+        offense.message
+      end
+
+      def code_description
+        {
+          href: offense.doc,
+        }
+      end
+
+      def severity
+        case offense.severity
+        when :error
+          1
+        when :suggestion
+          2
+        when :style
+          3
+        else
+          4
+        end
+      end
+
+      def range
+        {
+          start: {
+            line: offense.start_row,
+            character: offense.start_column,
+          },
+          end: {
+            line: offense.end_row,
+            character: offense.end_column,
+          },
+        }
+      end
+
+      def start_index
+        offense.start_index
+      end
+
+      def end_index
+        offense.end_index
+      end
+
+      def absolute_path
+        @absolute_path ||= offense&.theme_file&.path
+      end
+
+      def relative_path
+        @relative_path ||= offense&.theme_file&.relative_path
+      end
+
+      def uri
+        @uri ||= absolute_path && file_uri(absolute_path)
+      end
+
+      def file_version
+        @version ||= offense&.version
+      end
+
+      def data
+        {
+          absolute_path: absolute_path.to_s,
+          relative_path: relative_path.to_s,
+          uri: uri,
+          version: file_version,
+        }
+      end
+    end
+  end
+end