theme-check 1.7.2 → 1.9.2

data/lib/theme_check/checks/valid_schema.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 module ThemeCheck
   class ValidSchema < LiquidCheck
-    severity :suggestion
+    severity :error
     category :json
     doc docs_url(__FILE__)
 
     def on_schema(node)
-      JSON.parse(node.value.nodelist.join)
+      JSON.parse(node.inner_markup)
     rescue JSON::ParserError => e
       add_offense(format_json_parse_error(e), node: node)
     end

data/lib/theme_check/corrector.rb

@@ -2,52 +2,63 @@
 
 module ThemeCheck
   class Corrector
+    include JsonHelpers
+
     def initialize(theme_file:)
       @theme_file = theme_file
     end
 
-    def insert_after(node, content)
-      @theme_file.rewriter.insert_after(node, content)
+    def insert_after(node, content, character_range = nil)
+      @theme_file.rewriter.insert_after(node, content, character_range)
+    end
+
+    def insert_before(node, content, character_range = nil)
+      @theme_file.rewriter.insert_before(node, content, character_range)
     end
 
-    def insert_before(node, content)
-      @theme_file.rewriter.insert_before(node, content)
+    def remove(node)
+      @theme_file.rewriter.remove(node)
     end
 
-    def replace(node, content)
-      @theme_file.rewriter.replace(node, content)
+    def replace(node, content, character_range = nil)
+      @theme_file.rewriter.replace(node, content, character_range)
       node.markup = content
     end
 
+    def replace_inner_markup(node, content)
+      @theme_file.rewriter.replace_inner_markup(node, content)
+    end
+
+    def replace_inner_json(node, json, **pretty_json_opts)
+      replace_inner_markup(node, pretty_json(json, **pretty_json_opts))
+    end
+
     def wrap(node, insert_before, insert_after)
       @theme_file.rewriter.wrap(node, insert_before, insert_after)
     end
 
-    def create(theme, relative_path, content)
-      theme.storage.write(relative_path, content)
+    def create_file(storage, relative_path, content)
+      storage.write(relative_path, content)
     end
 
-    def create_default_locale_json(theme)
-      theme.default_locale_json = JsonFile.new("locales/#{theme.default_locale}.default.json", theme.storage)
-      theme.default_locale_json.update_contents({})
+    def remove_file(storage, relative_path)
+      storage.remove(relative_path)
     end
 
-    def remove(theme, relative_path)
-      theme.storage.remove(relative_path)
+    def mkdir(storage, relative_path)
+      storage.mkdir(relative_path)
     end
 
-    def mkdir(theme, relative_path)
-      theme.storage.mkdir(relative_path)
+    def add_translation(json_file, path, value)
+      hash = json_file.content
+      SchemaHelper.set(hash, path, value)
+      json_file.update_contents(hash)
     end
 
-    def add_default_translation_key(file, key, value)
-      hash = file.content
-      key.reduce(hash) do |pointer, token|
-        return pointer[token] = value if token == key.last
-        pointer[token] = {} unless pointer.key?(token)
-        pointer[token]
-      end
-      file.update_contents(hash)
+    def remove_translation(json_file, path)
+      hash = json_file.content
+      SchemaHelper.delete(hash, path)
+      json_file.update_contents(hash)
     end
   end
 end

data/lib/theme_check/file_system_storage.rb

@@ -36,13 +36,14 @@ module ThemeCheck
     end
 
     def mkdir(relative_path)
-      reset_memoizers unless file_exists?(relative_path)
-
-      file(relative_path).mkpath unless file(relative_path).directory?
+      return if file_exists?(relative_path)
+      reset_memoizers
+      file(relative_path).mkpath
     end
 
     def files
       @file_array ||= glob("**/*")
+        .reject { |path| File.directory?(path) }
         .map { |path| path.relative_path_from(@root).to_s }
     end
 

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,35 @@ module ThemeCheck
         .to_h
     end
 
+    def parseable_markup
+      return @parseable_source if @value.name == "#document-fragment"
+
+      start_index = from_row_column_to_index(@parseable_source, line_number - 1, 0)
+      @parseable_source
+        .match(/<\s*#{name}[^>]*>/im, start_index)[0]
+    rescue NoMethodError
+      # Don't know what's up with the following issue. Don't think
+      # null check is correct approach. This should give us more info.
+      # https://github.com/Shopify/theme-check/issues/528
+      ThemeCheck.bug(<<~MSG)
+        Can't find a parseable tag of name #{name} inside the parseable HTML.
+
+        Tag name:
+          #{@value.name.inspect}
+
+        File:
+          #{@theme_file.relative_path}
+
+        Line number:
+          #{line_number}
+
+        Excerpt:
+          ```
+          #{@parseable_source.lines[line_number - 1...line_number + 5]}
+          ```
+      MSG
+    end
+
     def content
       @content ||= replace_placeholders(@value.content)
     end
@@ -74,10 +182,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,15 +37,15 @@ module ThemeCheck
 
       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 = JSON.parse(message_body, symbolize_names: true)
+        @messenger.log(JSON.pretty_generate(message_json)) if ThemeCheck.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.log(JSON.pretty_generate(message_hash)) if ThemeCheck.debug?
         @messenger.send_message(message_body)
       end
 
@@ -68,11 +68,25 @@ module ThemeCheck
       # 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
+        if error
+          message[:error] = error
+        else
+          message[:result] = result
+        end
         send_message(message)
       end
 
+      # https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#responseError
+      def send_internal_error(id, e)
+        send_response(id, nil, {
+          code: ErrorCodes::INTERNAL_ERROR,
+          message: <<~EOS,
+            #{e.class}: #{e.message}
+              #{e.backtrace.join("\n  ")}
+          EOS
+        })
+      end
+
       # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
       def send_notification(method, params)
         message = { method: method }

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