theme-check 1.5.0 → 1.6.1

data/lib/theme_check/corrector.rb

@@ -7,25 +7,20 @@ module ThemeCheck
     end
 
     def insert_after(node, content)
-      line = @template.full_line(node.line_number)
-      line.insert(node.range[1] + 1, content)
+      @template.rewriter.insert_after(node, content)
     end
 
     def insert_before(node, content)
-      line = @template.full_line(node.line_number)
-      line.insert(node.range[0], content)
+      @template.rewriter.insert_before(node, content)
     end
 
     def replace(node, content)
-      line = @template.full_line(node.line_number)
-      line[node.range[0]..node.range[1]] = content
+      @template.rewriter.replace(node, content)
       node.markup = content
     end
 
     def wrap(node, insert_before, insert_after)
-      line = @template.full_line(node.line_number)
-      line.insert(node.range[0], insert_before)
-      line.insert(node.range[1] + 1 + insert_before.length, insert_after)
+      @template.rewriter.wrap(node, insert_before, insert_after)
     end
 
     def create(theme, relative_path, content)
@@ -34,7 +29,25 @@ module ThemeCheck
 
     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('{}')
+      theme.default_locale_json.update_contents({})
+    end
+
+    def remove(theme, relative_path)
+      theme.storage.remove(relative_path)
+    end
+
+    def mkdir(theme, relative_path)
+      theme.storage.mkdir(relative_path)
+    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)
     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

@@ -67,10 +67,10 @@ module ThemeCheck
     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,12 +9,11 @@ module ThemeCheck
 
     def initialize(checks)
       @checks = checks
-      @placeholder_values = []
     end
 
     def visit_template(template)
-      doc = parse(template)
-      visit(HtmlNode.new(doc, template, @placeholder_values))
+      doc, placeholder_values = parse(template)
+      visit(HtmlNode.new(doc, template, placeholder_values))
     rescue ArgumentError => e
       call_checks(:on_parse_error, e, template)
     end
@@ -22,19 +21,32 @@ module ThemeCheck
     private
 
     def parse(template)
+      placeholder_values = []
       parseable_source = +template.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

@@ -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_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/json_printer.rb

@@ -3,9 +3,13 @@ require 'json'
 
 module ThemeCheck
   class JsonPrinter
+    def initialize(out_stream = STDOUT)
+      @out = out_stream
+    end
+
     def print(offenses)
       json = offenses_by_path(offenses)
-      puts JSON.dump(json)
+      @out.puts JSON.dump(json)
     end
 
     def offenses_by_path(offenses)

data/lib/theme_check/node.rb

@@ -10,12 +10,14 @@ module ThemeCheck
       @value = value
       @parent = parent
       @template = template
+      @tag_markup = nil
+      @line_number_offset = 0
     end
 
     # The original source code of the node. Doesn't contain wrapping braces.
     def markup
       if tag?
-        @value.raw
+        tag_markup
       elsif @value.instance_variable_defined?(:@markup)
         @value.instance_variable_get(:@markup)
       end
@@ -64,6 +66,10 @@ module ThemeCheck
       @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)
@@ -92,7 +98,12 @@ module ThemeCheck
 
     # Most nodes have a line number, but it's not guaranteed.
     def line_number
-      @value.line_number if @value.respond_to?(: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
 
     # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
@@ -101,27 +112,48 @@ module ThemeCheck
       @type_name ||= StringHelpers.underscore(StringHelpers.demodulize(@value.class.name)).to_sym
     end
 
+    def source
+      template&.source
+    end
+
+    WHITESPACE = /\s/
+
     # Is this node inside a `{% liquid ... %}` block?
     def inside_liquid_tag?
-      if line_number
-        template.excerpt(line_number).start_with?("{%")
+      # 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? && line_number && 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 `{%- ... -%}`
-    def whitespace_trimmed?
-      if line_number
-        template.excerpt(line_number).start_with?("{%-")
+    # Is this node inside a tag or variable that starts by removing whitespace. i.e. {%- or {{-
+    def whitespace_trimmed_start?
+      @whitespace_trimmed_start ||= if line_number && 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
 
-    def range
-      start = template.full_line(line_number).index(markup)
-      [start, start + markup.length - 1]
+    # Is this node inside a tag or variable ends starts by removing whitespace. i.e. -%} or -}}
+    def whitespace_trimmed_end?
+      @whitespace_trimmed_end ||= if line_number && 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 position
@@ -139,5 +171,80 @@ module ThemeCheck
     def end_index
       position.end_index
     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
+
+    # 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 template.
+    def tag_markup
+      return @value.tag_name if @value.instance_variable_get('@markup').empty?
+      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_markup = @value.instance_variable_get('@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 %}
+      if (match = /#{@value.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 -= @value.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

data/lib/theme_check/offense.rb

@@ -144,6 +144,32 @@ module ThemeCheck
         corrector = Corrector.new(template: template)
         correction.call(corrector)
       end
+    rescue => e
+      ThemeCheck.bug(<<~EOS)
+        Exception while running `Offense#correct`:
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace.join("\n  ")}
+        ```
+
+        Offense:
+        ```
+        #{JSON.pretty_generate(to_h)}
+        ```
+        Check options:
+        ```
+        #{check.options.pretty_inspect}
+        ```
+        Markup:
+        ```
+        #{markup}
+        ```
+        Node.Markup:
+        ```
+        #{node&.markup}
+        ```
+      EOS
+      exit(2)
     end
 
     def whole_theme?

data/lib/theme_check/position.rb

@@ -16,22 +16,22 @@ module ThemeCheck
       @line_number_1_indexed = line_number_1_indexed
       @node_markup_offset = node_markup_offset
       @node_markup = node_markup
-      @strict_position = StrictPosition.new(
-        needle,
-        contents,
-        start_index,
-      )
     end
 
     def start_line_offset
-      from_row_column_to_index(contents, line_number, 0)
+      @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
+      @start_offset ||= compute_start_offset
+    end
+
+    def strict_position
+      @strict_position ||= StrictPosition.new(
+        needle,
+        contents,
+        start_index,
+      )
     end
 
     # 0-indexed, inclusive
@@ -41,39 +41,50 @@ module ThemeCheck
 
     # 0-indexed, exclusive
     def end_index
-      @strict_position.end_index
+      strict_position.end_index
     end
 
     # 0-indexed, inclusive
     def start_row
-      @strict_position.start_row
+      strict_position.start_row
     end
 
     # 0-indexed, inclusive
     def start_column
-      @strict_position.start_column
+      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
-      @strict_position.end_row
+      strict_position.end_row
     end
 
     def end_column
-      @strict_position.end_column
+      strict_position.end_column
     end
 
     private
 
+    def compute_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
+
     def contents
       return '' unless @contents.is_a?(String) && !@contents.empty?
       @contents
     end
 
+    def content_line_count
+      @content_line_count ||= contents.count("\n")
+    end
+
     def line_number
       return 0 if @line_number_1_indexed.nil?
-      bounded(0, @line_number_1_indexed - 1, contents.lines.size - 1)
+      bounded(0, @line_number_1_indexed - 1, content_line_count)
     end
 
     def needle