theme-check 0.10.2 → 1.3.0

data/lib/theme_check/html_visitor.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
-require "nokogumbo"
+require "nokogiri"
 require "forwardable"
 
 module ThemeCheck
   class HtmlVisitor
+    include RegexHelpers
     attr_reader :checks
 
     def initialize(checks)
       @checks = checks
+      @placeholder_values = []
     end
 
     def visit_template(template)
       doc = parse(template)
-      visit(HtmlNode.new(doc, template))
+      visit(HtmlNode.new(doc, template, @placeholder_values))
     rescue ArgumentError => e
       call_checks(:on_parse_error, e, template)
     end
@@ -20,7 +22,19 @@ module ThemeCheck
     private
 
     def parse(template)
-      Nokogiri::HTML5.fragment(template.source, max_tree_depth: 400, max_attributes: 400)
+      parseable_source = +template.source.clone
+
+      # Replace all liquid tags with {%#{i}######%} to prevent the HTML
+      # parser from freaking out. We transparently replace those placeholders in
+      # HtmlNode.
+      matches(parseable_source, LIQUID_TAG_OR_VARIABLE).each do |m|
+        value = m[0]
+        @placeholder_values.push(value)
+        key = (@placeholder_values.size - 1).to_s
+        parseable_source[m.begin(0)...m.end(0)] = "{%#{key.ljust(m.end(0) - m.begin(0) - 4, '#')}%}"
+      end
+
+      Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400)
     end
 
     def visit(node)

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)
-      offenses << Offense.new(check: self, message: message, markup: markup, line_number: line_number, template: template)
+    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)
     end
   end
 end

data/lib/theme_check/json_file.rb

@@ -1,29 +1,15 @@
 # frozen_string_literal: true
 require "json"
-require "pathname"
 
 module ThemeCheck
-  class JsonFile
+  class JsonFile < ThemeFile
     def initialize(relative_path, storage)
-      @relative_path = relative_path
-      @storage = storage
+      super
       @loaded = false
       @content = nil
       @parser_error = nil
     end
 
-    def path
-      @storage.path(@relative_path)
-    end
-
-    def relative_path
-      @relative_pathname ||= Pathname.new(@relative_path)
-    end
-
-    def source
-      @source ||= @storage.read(@relative_path)
-    end
-
     def content
       load!
       @content
@@ -34,23 +20,10 @@ module ThemeCheck
       @parser_error
     end
 
-    def name
-      relative_path.sub_ext('').to_s
-    end
-
     def json?
       true
     end
 
-    def liquid?
-      false
-    end
-
-    def ==(other)
-      other.is_a?(JsonFile) && relative_path == other.relative_path
-    end
-    alias_method :eql?, :==
-
     private
 
     def load!

data/lib/theme_check/json_printer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'json'
+
+module ThemeCheck
+  class JsonPrinter
+    def print(offenses)
+      json = offenses_by_path(offenses)
+      puts JSON.dump(json)
+    end
+
+    def offenses_by_path(offenses)
+      offenses
+        .map(&:to_h)
+        .group_by { |offense| offense[:path] }
+        .map do |(path, path_offenses)|
+          {
+            path: path,
+            offenses: path_offenses.map { |offense| offense.filter { |k, _v| k != :path } },
+            errorCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:error] },
+            suggestionCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:suggestion] },
+            styleCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:style] },
+          }
+        end
+    end
+  end
+end

data/lib/theme_check/language_server/constants.rb

@@ -10,5 +10,13 @@ module ThemeCheck
       ^\s*render\s+'(?<partial>[^']*)'|
       ^\s*render\s+"(?<partial>[^"]*)"
     }mix
+    ASSET_INCLUDE = %r{
+      \{\%-?\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
+      \{\%-?\s*"(?<partial>[^"]*)"\s*\|\s*asset_url|
+
+      # in liquid tags the whole line is white space until the asset partial
+      ^\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
+      ^\s*"(?<partial>[^"]*)"\s*\|\s*asset_url
+    }mix
   end
 end

data/lib/theme_check/language_server/document_link_engine.rb

@@ -13,7 +13,7 @@ module ThemeCheck
       def document_links(relative_path)
         buffer = @storage.read(relative_path)
         return [] unless buffer
-        matches(buffer, PARTIAL_RENDER).map do |match|
+        snippet_matches = matches(buffer, PARTIAL_RENDER).map do |match|
           start_line, start_character = from_index_to_row_column(
             buffer,
             match.begin(:partial),
@@ -25,7 +25,7 @@ module ThemeCheck
           )
 
           {
-            target: link(match[:partial]),
+            target: snippet_link(match[:partial]),
             range: {
               start: {
                 line: start_line,
@@ -38,10 +38,46 @@ module ThemeCheck
             },
           }
         end
+        asset_matches = matches(buffer, ASSET_INCLUDE).map do |match|
+          start_line, start_character = from_index_to_row_column(
+            buffer,
+            match.begin(:partial),
+          )
+
+          end_line, end_character = from_index_to_row_column(
+            buffer,
+            match.end(:partial)
+          )
+
+          {
+            target: asset_link(match[:partial]),
+            range: {
+              start: {
+                line: start_line,
+                character: start_character,
+              },
+              end: {
+                line: end_line,
+                character: end_character,
+              },
+            },
+          }
+        end
+        snippet_matches + asset_matches
+      end
+
+      def snippet_link(partial)
+        file_link('snippets', partial, '.liquid')
       end
 
-      def link(partial)
-        "file://#{@storage.path('snippets/' + partial + '.liquid')}"
+      def asset_link(partial)
+        file_link('assets', partial, '')
+      end
+
+      private
+
+      def file_link(directory, partial, extension)
+        "file://#{@storage.path(directory + '/' + partial + extension)}"
       end
     end
   end

data/lib/theme_check/language_server/handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require "benchmark"
+require "uri"
+require "cgi"
 
 module ThemeCheck
   module LanguageServer
@@ -98,8 +100,10 @@ module ThemeCheck
         path_from_uri(params.dig('textDocument', 'uri'))
       end
 
-      def path_from_uri(uri)
-        uri&.sub('file://', '')
+      def path_from_uri(uri_string)
+        return if uri_string.nil?
+        uri = URI(uri_string)
+        CGI.unescape(uri.path)
       end
 
       def relative_path_from_text_document_uri(params)

data/lib/theme_check/language_server/server.rb

@@ -52,8 +52,19 @@ module ThemeCheck
         response_body = JSON.dump(response)
         log(JSON.pretty_generate(response)) if $DEBUG
 
-        @out.write("Content-Length: #{response_body.bytesize}\r\n")
-        @out.write("\r\n")
+        # 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 and
+        # set the encoding manually (yuk!) or we do this little hack
+        # here and put \n which gets transformed into \r\n on windows
+        # only...
+        #
+        # Hours wasted: 8.
+        eol = Gem.win_platform? ? "\n" : "\r\n"
+        @out.write("Content-Length: #{response_body.bytesize}#{eol}")
+        @out.write(eol)
         @out.write(response_body)
         @out.flush
       end

data/lib/theme_check/liquid_check.rb

@@ -5,17 +5,5 @@ module ThemeCheck
   class LiquidCheck < Check
     extend ChecksTracking
     include ParsingHelpers
-
-    # TODO: remove this once all regex checks are migrate to HtmlCheck# TODO: remove this once all regex checks are migrate to HtmlCheck
-    TAG = /#{Liquid::TagStart}.*?#{Liquid::TagEnd}/om
-    VARIABLE = /#{Liquid::VariableStart}.*?#{Liquid::VariableEnd}/om
-    START_OR_END_QUOTE = /(^['"])|(['"]$)/
-    QUOTED_LIQUID_ATTRIBUTE = %r{
-      '(?:#{TAG}|#{VARIABLE}|[^'])*'| # any combination of tag/variable or non straight quote inside straight quotes
-      "(?:#{TAG}|#{VARIABLE}|[^"])*"  # any combination of tag/variable or non double quotes inside double quotes
-    }omix
-    ATTR = /[a-z0-9-]+/i
-    HTML_ATTRIBUTE = /#{ATTR}(?:=#{QUOTED_LIQUID_ATTRIBUTE})?/omix
-    HTML_ATTRIBUTES = /(?:#{HTML_ATTRIBUTE}|\s)*/omix
   end
 end

data/lib/theme_check/node.rb

@@ -22,9 +22,7 @@ module ThemeCheck
     end
 
     def markup=(markup)
-      if tag?
-        @value.raw = markup
-      elsif @value.instance_variable_defined?(:@markup)
+      if @value.instance_variable_defined?(:@markup)
         @value.instance_variable_set(:@markup, markup)
       end
     end
@@ -127,7 +125,11 @@ module ThemeCheck
     end
 
     def position
-      @position ||= Position.new(markup, template&.source, line_number)
+      @position ||= Position.new(
+        markup,
+        template&.source,
+        line_number_1_indexed: line_number
+      )
     end
 
     def start_index

data/lib/theme_check/offense.rb

@@ -1,11 +1,32 @@
 # frozen_string_literal: true
 module ThemeCheck
   class Offense
+    include PositionHelper
+
     MAX_SOURCE_EXCERPT_SIZE = 120
 
     attr_reader :check, :message, :template, :node, :markup, :line_number, :correction
 
-    def initialize(check:, message: nil, template: nil, node: nil, markup: nil, line_number: nil, correction: nil)
+    def initialize(
+      check:, # instance of a ThemeCheck::Check
+      message: nil, # error message for the offense
+      template: nil, # Template
+      node: nil, # Node or HtmlNode
+      markup: nil, # string
+      line_number: nil, # line number of the error (1-indexed)
+      # node_markup_offset is the index inside node.markup to start
+      # looking for markup :mindblow:.
+      # This is so we can accurately highlight node substrings.
+      # e.g. if we have the following scenario in which we
+      # want to highlight the middle comma
+      #   * node.markup == "replace ',',', '"
+      #   * markup == ","
+      # Then we need some way of telling our Position class to start
+      # looking for the second comma. This is done with node_markup_offset.
+      # More context can be found in #376.
+      node_markup_offset: 0,
+      correction: nil # block
+    )
       @check = check
       @correction = correction
 
@@ -39,7 +60,13 @@ module ThemeCheck
         @node.line_number
       end
 
-      @position = Position.new(@markup, @template&.source, @line_number)
+      @position = Position.new(
+        @markup,
+        @template&.source,
+        line_number_1_indexed: @line_number,
+        node_markup_offset: node_markup_offset,
+        node_markup: node&.markup
+      )
     end
 
     def source_excerpt
@@ -103,8 +130,13 @@ module ThemeCheck
       tokens.join(":") if tokens.any?
     end
 
+    def location_range
+      tokens = [template&.relative_path, start_index, end_index].compact
+      tokens.join(":") if tokens.any?
+    end
+
     def correctable?
-      line_number && correction
+      !!correction
     end
 
     def correct
@@ -139,5 +171,26 @@ module ThemeCheck
         message
       end
     end
+
+    def to_s_range
+      if template
+        "#{message} at #{location_range}"
+      else
+        message
+      end
+    end
+
+    def to_h
+      {
+        check: check.code_name,
+        path: template&.relative_path,
+        severity: check.severity_value,
+        start_line: start_line,
+        start_column: start_column,
+        end_line: end_line,
+        end_column: end_column,
+        message: message,
+      }
+    end
   end
 end

data/lib/theme_check/parsing_helpers.rb

@@ -5,13 +5,16 @@ module ThemeCheck
     def outside_of_strings(markup)
       scanner = StringScanner.new(markup)
 
-      while scanner.scan(/.*?("|')/)
-        yield scanner.matched[0..-2]
+      while scanner.scan(/.*?("|')/m)
+        chunk_start = scanner.pre_match.size
+        yield scanner.matched[0..-2], chunk_start
+        quote = scanner.matched[-1] == "'" ? "'" : "\""
         # Skip to the end of the string
-        scanner.skip_until(scanner.matched[-1] == "'" ? /[^\\]'/ : /[^\\]"/)
+        # Check for empty string first, since follow regexp uses lookahead
+        scanner.skip(/#{quote}/) || scanner.skip_until(/[^\\]#{quote}/)
       end
 
-      yield scanner.rest if scanner.rest?
+      yield scanner.rest, scanner.charpos if scanner.rest?
     end
   end
 end

data/lib/theme_check/position.rb

@@ -4,42 +4,64 @@ module ThemeCheck
   class Position
     include PositionHelper
 
-    def initialize(needle, contents, line_number_1_indexed)
-      @needle = needle
-      @contents = contents
+    def initialize(
+      needle_arg,
+      contents_arg,
+      line_number_1_indexed: nil,
+      node_markup: nil,
+      node_markup_offset: 0 # the index of markup inside the node_markup
+    )
+      @needle = needle_arg
+      @contents = contents_arg
       @line_number_1_indexed = line_number_1_indexed
-      @start_row_column = nil
-      @end_row_column = nil
+      @node_markup_offset = node_markup_offset
+      @node_markup = node_markup
+      @strict_position = StrictPosition.new(
+        needle,
+        contents,
+        start_index,
+      )
     end
 
-    def start_line_index
+    def start_line_offset
       from_row_column_to_index(contents, line_number, 0)
     end
 
+    def start_offset
+      return start_line_offset if @node_markup.nil?
+      node_markup_start = contents.index(@node_markup, start_line_offset)
+      return start_line_offset if node_markup_start.nil?
+      node_markup_start + @node_markup_offset
+    end
+
     # 0-indexed, inclusive
     def start_index
-      contents.index(needle, start_line_index) || start_line_index
+      contents.index(needle, start_offset)
     end
 
     # 0-indexed, exclusive
     def end_index
-      start_index + needle.size
+      @strict_position.end_index
     end
 
+    # 0-indexed, inclusive
     def start_row
-      start_row_column[0]
+      @strict_position.start_row
     end
 
+    # 0-indexed, inclusive
     def start_column
-      start_row_column[1]
+      @strict_position.start_column
     end
 
+    # 0-indexed, exclusive (both taken together are) therefore you
+    # might end up on a newline character or the next line
     def end_row
-      end_row_column[0]
+      @strict_position.end_row
     end
 
     def end_column
-      end_row_column[1]
+      @strict_position.end_column
     end
 
     private
@@ -55,15 +77,77 @@ module ThemeCheck
     end
 
     def needle
-      if @needle.nil? && !contents.empty? && !@line_number_1_indexed.nil?
-        contents.lines(chomp: true)[line_number] || ''
+      if has_content_and_line_number_but_no_needle?
+        entire_line_needle
       elsif contents.empty? || @needle.nil?
         ''
+      elsif !can_find_needle?
+        entire_line_needle
       else
         @needle
       end
     end
 
+    def has_content_and_line_number_but_no_needle?
+      @needle.nil? && !contents.empty? && @line_number_1_indexed.is_a?(Integer)
+    end
+
+    def can_find_needle?
+      !!contents.index(@needle)
+    end
+
+    def entire_line_needle
+      contents.lines(chomp: true)[line_number] || ''
+    end
+  end
+
+  # This method is stricter than Position in the sense that it doesn't
+  # accept invalid inputs. Makes for code that is easier to understand.
+  class StrictPosition
+    include PositionHelper
+
+    attr_reader :needle, :contents
+
+    def initialize(needle, contents, start_index)
+      raise ArgumentError, 'Bad start_index' unless start_index.is_a?(Integer)
+      raise ArgumentError, 'Bad contents' unless contents.is_a?(String)
+      raise ArgumentError, 'Bad needle' unless needle.is_a?(String) || !contents.index(needle, start_index)
+
+      @needle = needle
+      @contents = contents
+      @start_index = start_index
+      @start_row_column = nil
+      @end_row_column = nil
+    end
+
+    # 0-indexed, inclusive
+    def start_index
+      @contents.index(needle, @start_index)
+    end
+
+    # 0-indexed, exclusive
+    def end_index
+      start_index + needle.size
+    end
+
+    def start_row
+      start_row_column[0]
+    end
+
+    def start_column
+      start_row_column[1]
+    end
+
+    def end_row
+      end_row_column[0]
+    end
+
+    def end_column
+      end_row_column[1]
+    end
+
+    private
+
     def start_row_column
       return @start_row_column unless @start_row_column.nil?
       @start_row_column = from_index_to_row_column(contents, start_index)