theme-check 1.4.0 → 1.6.0

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)
@@ -21,6 +25,7 @@ module ThemeCheck
             styleCount: path_offenses.count { |offense| offense[:severity] == Check::SEVERITY_VALUES[:style] },
           }
         end
+        .sort_by { |o| o[:path] }
     end
   end
 end

data/lib/theme_check/language_server/document_link_provider.rb

@@ -5,6 +5,7 @@ module ThemeCheck
     class DocumentLinkProvider
       include RegexHelpers
       include PositionHelper
+      include URIHelper
 
       class << self
         attr_accessor :partial_regexp, :destination_directory, :destination_postfix
@@ -63,7 +64,7 @@ module ThemeCheck
       end
 
       def file_link(partial)
-        "file://#{@storage.path(destination_directory + '/' + partial + destination_postfix)}"
+        file_uri(@storage.path(destination_directory + '/' + partial + destination_postfix))
       end
     end
   end

data/lib/theme_check/language_server/handler.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 require "benchmark"
-require "uri"
-require "cgi"
 
 module ThemeCheck
   module LanguageServer
     class Handler
+      include URIHelper
+
       CAPABILITIES = {
         completionProvider: {
           triggerCharacters: ['.', '{{ ', '{% '],
@@ -26,7 +27,7 @@ module ThemeCheck
       end
 
       def on_initialize(id, params)
-        @root_path = path_from_uri(params["rootUri"]) || params["rootPath"]
+        @root_path = root_path_from_params(params)
 
         # Tell the client we don't support anything if there's no rootPath
         return send_response(id, { capabilities: {} }) if @root_path.nil?
@@ -96,19 +97,23 @@ module ThemeCheck
       end
 
       def text_document_uri(params)
-        path_from_uri(params.dig('textDocument', 'uri'))
-      end
-
-      def path_from_uri(uri_string)
-        return if uri_string.nil?
-        uri = URI(uri_string)
-        CGI.unescape(uri.path)
+        file_path(params.dig('textDocument', 'uri'))
       end
 
       def relative_path_from_text_document_uri(params)
         @storage.relative_path(text_document_uri(params))
       end
 
+      def root_path_from_params(params)
+        root_uri = params["rootUri"]
+        root_path = params["rootPath"]
+        if root_uri
+          file_path(root_uri)
+        elsif root_path
+          root_path
+        end
+      end
+
       def text_document_text(params)
         params.dig('textDocument', 'text')
       end
@@ -174,7 +179,7 @@ module ThemeCheck
       def send_diagnostic(path, offenses)
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
         send_notification('textDocument/publishDiagnostics', {
-          uri: "file://#{path}",
+          uri: file_uri(path),
           diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
         })
       end

data/lib/theme_check/language_server/server.rb

@@ -25,6 +25,15 @@ module ThemeCheck
         @out = out_stream
         @err = err_stream
 
+        # 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.
+        #
+        # Hours wasted: 9.
+        @out.binmode
+
         @out.sync = true # do not buffer
         @err.sync = true # do not buffer
 
@@ -52,19 +61,8 @@ module ThemeCheck
         response_body = JSON.dump(response)
         log(JSON.pretty_generate(response)) if $DEBUG
 
-        # 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("Content-Length: #{response_body.bytesize}\r\n")
+        @out.write("\r\n")
         @out.write(response_body)
         @out.flush
       end

data/lib/theme_check/language_server/uri_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "uri"
+require "cgi"
+
+module ThemeCheck
+  module LanguageServer
+    module URIHelper
+      # Will URI.encode a string the same way VS Code would. There are two things
+      # to watch out for:
+      #
+      # 1. VS Code still uses the outdated '%20' for spaces
+      # 2. VS Code prefixes Windows paths with / (so /C:/Users/... is expected)
+      #
+      # Exists because of https://github.com/Shopify/theme-check/issues/360
+      def file_uri(absolute_path)
+        "file://" + absolute_path
+          .to_s
+          .split('/')
+          .map { |x| CGI.escape(x).gsub('+', '%20') }
+          .join('/')
+          .sub(%r{^/?}, '/') # Windows paths should be prefixed by /c:
+      end
+
+      def file_path(uri_string)
+        return if uri_string.nil?
+        uri = URI(uri_string)
+        path = CGI.unescape(uri.path)
+        # On Windows, VS Code sends the URLs as file:///C:/...
+        # /C:/1234 is not a valid path in ruby. So we strip the slash.
+        path = path.sub(%r{^/([a-z]:/)}i, '\1')
+        path
+      end
+    end
+  end
+end

data/lib/theme_check/language_server.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
 require_relative "language_server/constants"
+require_relative "language_server/uri_helper"
 require_relative "language_server/handler"
 require_relative "language_server/server"
 require_relative "language_server/tokens"

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.raw 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