theme-check 1.5.1 → 1.6.2

data/lib/theme_check/disabled_check.rb

@@ -4,11 +4,11 @@
 # We'll use the node position to figure out if the test is disabled or not.
 module ThemeCheck
   class DisabledCheck
-    attr_reader :name, :template, :ranges
+    attr_reader :name, :theme_file, :ranges
     attr_accessor :first_line
 
-    def initialize(template, name)
-      @template = template
+    def initialize(theme_file, name)
+      @theme_file = theme_file
       @name = name
       @ranges = []
       @first_line = false

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

@@ -16,14 +16,25 @@ module ThemeCheck
     end
 
     def read(relative_path)
-      file(relative_path).read
+      file(relative_path).read(mode: 'rb', encoding: 'UTF-8')
     end
 
     def write(relative_path, content)
       reset_memoizers unless file_exists?(relative_path)
 
       file(relative_path).dirname.mkpath unless file(relative_path).dirname.directory?
-      file(relative_path).write(content)
+      file(relative_path).write(content, mode: 'w+b', encoding: 'UTF-8')
+    end
+
+    def remove(relative_path)
+      file(relative_path).delete
+      reset_memoizers
+    end
+
+    def mkdir(relative_path)
+      reset_memoizers unless file_exists?(relative_path)
+
+      file(relative_path).mkpath unless file(relative_path).directory?
     end
 
     def files

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,21 +72,13 @@ module ThemeCheck
       end
     end
 
-    def markup
-      @markup ||= replace_placeholders(@value.to_html)
-    end
-
-    def line_number
-      @value.line
-    end
-
     private
 
     def replace_placeholders(string)
-      # Replace all {%#{i}####%} with the actual content.
-      string.gsub(LIQUID_TAG) do |match|
-        key = /\d+/.match(match)[0]
-        @placeholder_values[key.to_i]
+      # Replace all ≬{i}####≬ with the actual content.
+      string.gsub(HTML_LIQUID_PLACEHOLDER) do |match|
+        key = /[0-9a-z]+/.match(match)[0]
+        @placeholder_values[key.to_i(36)]
       end
     end
   end

data/lib/theme_check/html_visitor.rb

@@ -9,32 +9,44 @@ module ThemeCheck
 
     def initialize(checks)
       @checks = checks
-      @placeholder_values = []
     end
 
-    def visit_template(template)
-      doc = 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)
-      parseable_source = +template.source.clone
+    def parse(liquid_file)
+      placeholder_values = []
+      parseable_source = +liquid_file.source.clone
 
-      # Replace all liquid tags with {%#{i}######%} to prevent the HTML
+      # 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]
-        @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, '#')}%}"
+        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)
+      [
+        Nokogiri::HTML5.fragment(parseable_source, max_tree_depth: 400, max_attributes: 400),
+        placeholder_values,
+      ]
     end
 
     def visit(node)

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
@@ -23,6 +23,14 @@ module ThemeCheck
       @files[relative_path] = content
     end
 
+    def remove(relative_path)
+      @files.delete(relative_path)
+    end
+
+    def mkdir(relative_path)
+      @files[relative_path] = nil
+    end
+
     def files
       @files.keys
     end

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

@@ -20,14 +20,19 @@ module ThemeCheck
       @parser_error
     end
 
-    def update_contents(new_content = '{}')
+    def update_contents(new_content = {})
+      raise ArgumentError if new_content.is_a?(String)
       @content = new_content
     end
 
     def write
-      if source != @content
-        @storage.write(@relative_path, content)
-        @source = content
+      pretty = JSON.pretty_generate(@content)
+      if source.rstrip != pretty.rstrip
+        # Most editors add a trailing \n at the end of files. Here we
+        # try to maintain the convention.
+        eof = source.end_with?("\n") ? "\n" : ""
+        @storage.write(@relative_path, pretty.gsub("\n", @eol) + eof)
+        @source = pretty
       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, []

data/lib/theme_check/{template.rb → liquid_file.rb}

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module ThemeCheck
-  class Template < ThemeFile
+  class LiquidFile < ThemeFile
     def write
-      content = updated_content
+      content = rewriter.to_s
       if source != content
-        @storage.write(@relative_path, content)
+        @storage.write(@relative_path, content.gsub("\n", @eol))
         @source = content
+        @rewriter = nil
       end
     end
 
@@ -26,19 +27,8 @@ module ThemeCheck
       name.start_with?('snippets')
     end
 
-    def lines
-      # Retain trailing newline character
-      @lines ||= source.split("\n", -1)
-    end
-
-    # Not entirely obvious but lines is mutable, corrections are to be
-    # applied on @lines.
-    def updated_content
-      lines.join("\n")
-    end
-
-    def excerpt(line)
-      lines[line - 1].strip
+    def rewriter
+      @rewriter ||= ThemeFileRewriter.new(@relative_path, source)
     end
 
     def source_excerpt(line)
@@ -46,10 +36,6 @@ module ThemeCheck
       original_lines[line - 1].strip
     end
 
-    def full_line(line)
-      lines[line - 1]
-    end
-
     def parse
       @ast ||= self.class.parse(source)
     end

data/lib/theme_check/liquid_node.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  # A node from the Liquid AST, the result of parsing a liquid file.
+  class LiquidNode < Node
+    attr_reader :value, :parent, :theme_file
+
+    def initialize(value, parent, theme_file)
+      raise ArgumentError, "Expected a Liquid AST Node" if value.is_a?(LiquidNode)
+      @value = value
+      @parent = parent
+      @theme_file = theme_file
+      @tag_markup = nil
+      @line_number_offset = 0
+    end
+
+    # Array of children nodes.
+    def children
+      @children ||= begin
+        nodes =
+          if comment?
+            []
+          elsif defined?(@value.class::ParseTreeVisitor)
+            @value.class::ParseTreeVisitor.new(@value, {}).children
+          elsif @value.respond_to?(:nodelist)
+            Array(@value.nodelist)
+          else
+            []
+          end
+        # Work around a bug in Liquid::Variable::ParseTreeVisitor that doesn't return
+        # the args in a hash as children nodes.
+        nodes = nodes.flat_map do |node|
+          case node
+          when Hash
+            node.values
+          else
+            node
+          end
+        end
+        nodes.map { |node| LiquidNode.new(node, self, @theme_file) }
+      end
+    end
+
+    # The original source code of the node. Doesn't contain wrapping braces.
+    def markup
+      if tag?
+        tag_markup
+      elsif @value.instance_variable_defined?(:@markup)
+        @value.instance_variable_get(:@markup)
+      end
+    end
+
+    def markup=(markup)
+      if @value.instance_variable_defined?(:@markup)
+        @value.instance_variable_set(:@markup, markup)
+      end
+    end
+
+    # Most nodes have a line number, but it's not guaranteed.
+    def line_number
+      if tag? && @value.respond_to?(:line_number)
+        markup # initialize the line_number_offset
+        @value.line_number - @line_number_offset
+      elsif @value.respond_to?(:line_number)
+        @value.line_number
+      end
+    end
+
+    def start_index
+      position.start_index
+    end
+
+    def end_index
+      position.end_index
+    end
+
+    # Literals are hard-coded values in the liquid file.
+    def literal?
+      @value.is_a?(String) || @value.is_a?(Integer)
+    end
+
+    # A {% tag %} node?
+    def tag?
+      @value.is_a?(Liquid::Tag)
+    end
+
+    def variable?
+      @value.is_a?(Liquid::Variable)
+    end
+
+    # A {% comment %} block node?
+    def comment?
+      @value.is_a?(Liquid::Comment)
+    end
+
+    # Top level node of every liquid_file.
+    def document?
+      @value.is_a?(Liquid::Document)
+    end
+    alias_method :root?, :document?
+
+    # A {% tag %}...{% endtag %} node?
+    def block_tag?
+      @value.is_a?(Liquid::Block)
+    end
+
+    # The body of blocks
+    def block_body?
+      @value.is_a?(Liquid::BlockBody)
+    end
+
+    # A block of type of node?
+    def block?
+      block_tag? || block_body? || document?
+    end
+
+    # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
+    # and `after_<type_name>` check methods.
+    def type_name
+      @type_name ||= StringHelpers.underscore(StringHelpers.demodulize(@value.class.name)).to_sym
+    end
+
+    def source
+      theme_file&.source
+    end
+
+    WHITESPACE = /\s/
+
+    # Is this node inside a `{% liquid ... %}` block?
+    def inside_liquid_tag?
+      # What we're doing here is starting at the start of the tag and
+      # backtrack on all the whitespace until we land on something. If
+      # that something is {% or %-, then we can safely assume that
+      # we're inside a full tag and not a liquid tag.
+      @inside_liquid_tag ||= if tag? && start_index && source
+        i = 1
+        i += 1 while source[start_index - i] =~ WHITESPACE && i < start_index
+        first_two_backtracked_characters = source[(start_index - i - 1)..(start_index - i)]
+        first_two_backtracked_characters != "{%" && first_two_backtracked_characters != "%-"
+      else
+        false
+      end
+    end
+
+    # Is this node inside a tag or variable that starts by removing whitespace. i.e. {%- or {{-
+    def whitespace_trimmed_start?
+      @whitespace_trimmed_start ||= if start_index && source && !inside_liquid_tag?
+        i = 1
+        i += 1 while source[start_index - i] =~ WHITESPACE && i < start_index
+        source[start_index - i] == "-"
+      else
+        false
+      end
+    end
+
+    # Is this node inside a tag or variable ends starts by removing whitespace. i.e. -%} or -}}
+    def whitespace_trimmed_end?
+      @whitespace_trimmed_end ||= if end_index && source && !inside_liquid_tag?
+        i = 0
+        i += 1 while source[end_index + i] =~ WHITESPACE && i < source.size
+        source[end_index + i] == "-"
+      else
+        false
+      end
+    end
+
+    def start_token
+      return "" if inside_liquid_tag?
+      output = ""
+      output += "{{" if variable?
+      output += "{%" if tag?
+      output += "-" if whitespace_trimmed_start?
+      output
+    end
+
+    def end_token
+      return "" if inside_liquid_tag?
+      output = ""
+      output += "-" if whitespace_trimmed_end?
+      output += "}}" if variable?
+      output += "%}" if tag?
+      output
+    end
+
+    private
+
+    def position
+      @position ||= Position.new(
+        markup,
+        theme_file&.source,
+        line_number_1_indexed: line_number
+      )
+    end
+
+    # Here we're hacking around a glorious bug in Liquid that makes it so the
+    # line_number and markup of a tag is wrong if there's whitespace
+    # between the tag_name and the markup of the tag.
+    #
+    # {%
+    #   render
+    #   'foo'
+    # %}
+    #
+    # Returns a raw value of "render 'foo'\n".
+    # The "\n  " between render and 'foo' got replaced by a single space.
+    #
+    # And the line number is the one of 'foo'\n%}. Yay!
+    #
+    # This breaks any kind of position logic we have since that string
+    # does not exist in the theme_file.
+    def tag_markup
+      return @tag_markup if @tag_markup
+
+      l = 1
+      scanner = StringScanner.new(source)
+      scanner.scan_until(/\n/) while l < @value.line_number && (l += 1)
+      start = scanner.charpos
+
+      tag_name = @value.tag_name
+      tag_markup = @value.instance_variable_get('@markup')
+
+      # This is tricky, if the tag_markup is empty, then the tag could
+      # either start on a previous line, or the tag could start on the
+      # same line.
+      #
+      # Consider this:
+      # 1 {%
+      # 2 comment
+      # 3 %}{% endcomment %}{%comment%}
+      #
+      # Both comments would markup == "" AND line_number == 3
+      #
+      # There's no way to determine which one is the correct one, but
+      # we'll try our best to at least give you one.
+      #
+      # To screw with you even more, the name of the tag could be
+      # outside of a tag on the same line :) But I won't do anything
+      # about that (yet?).
+      #
+      # {% comment
+      # %}comment{% endcomment %}
+      if tag_markup.empty?
+        eol = source.index("\n", start) || source.size
+
+        # OK here I'm trying one of two things. Either tag_start is on
+        # the same line OR tag_start is on a previous line. The line
+        # number would be at the end of the whitespace after tag_name.
+        unless (tag_start = source.index(tag_name, start)) && tag_start < eol
+          tag_start = start
+          tag_start -= 1 while source[tag_start - 1] =~ WHITESPACE
+          tag_start -= @value.tag_name.size
+
+          # keep track of the error in line_number
+          @line_number_offset = source[tag_start...start].count("\n")
+        end
+        tag_end = tag_start + tag_name.size
+        tag_end += 1 while source[tag_end] =~ WHITESPACE
+
+        # return the real raw content
+        @tag_markup = source[tag_start...tag_end]
+        return @tag_markup
+
+      # See https://github.com/Shopify/theme-check/pull/423/files#r701936559 for a detailed explanation
+      # of why we're doing the check below.
+      #
+      # TL;DR it's because line_numbers are not enough to accurately
+      # determine the position of the raw markup and because that
+      # markup could be present on the same line outside of a Tag. e.g.
+      #
+      # uhoh {% if uhoh %}
+      elsif (match = /#{tag_name} +#{Regexp.escape(tag_markup)}/.match(source, start))
+        return @tag_markup = match[0]
+      end
+
+      # find the markup
+      markup_start = source.index(tag_markup, start)
+      markup_end = markup_start + tag_markup.size
+
+      # go back until you find the tag_name
+      tag_start = markup_start
+      tag_start -= 1 while source[tag_start - 1] =~ WHITESPACE
+      tag_start -= tag_name.size
+
+      # keep track of the error in line_number
+      @line_number_offset = source[tag_start...markup_start].count("\n")
+
+      # return the real raw content
+      @tag_markup = source[tag_start...markup_end]
+    end
+  end
+end