theme-check 1.5.2 → 1.7.0

data/lib/theme_check/checks/unused_assign.rb

@@ -25,21 +25,21 @@ module ThemeCheck
     end
 
     def on_document(node)
-      @templates[node.template.name] = TemplateInfo.new(Set.new, {}, Set.new)
+      @templates[node.theme_file.name] = TemplateInfo.new(Set.new, {}, Set.new)
     end
 
     def on_assign(node)
-      @templates[node.template.name].assign_nodes[node.value.to] = node
+      @templates[node.theme_file.name].assign_nodes[node.value.to] = node
     end
 
     def on_include(node)
       if node.value.template_name_expr.is_a?(String)
-        @templates[node.template.name].includes << "snippets/#{node.value.template_name_expr}"
+        @templates[node.theme_file.name].includes << "snippets/#{node.value.template_name_expr}"
       end
     end
 
     def on_variable_lookup(node)
-      @templates[node.template.name].used_assigns << node.value.name
+      @templates[node.theme_file.name].used_assigns << node.value.name
     end
 
     def on_end

data/lib/theme_check/checks/unused_snippet.rb

@@ -8,28 +8,30 @@ module ThemeCheck
     doc docs_url(__FILE__)
 
     def initialize
-      @used_templates = Set.new
+      @used_snippets = Set.new
     end
 
     def on_include(node)
       if node.value.template_name_expr.is_a?(String)
-        @used_templates << "snippets/#{node.value.template_name_expr}"
+        @used_snippets << "snippets/#{node.value.template_name_expr}"
       else
         # Can't reliably track unused snippets if an expression is used, ignore this check
-        @used_templates.clear
+        @used_snippets.clear
         ignore!
       end
     end
     alias_method :on_render, :on_include
 
     def on_end
-      missing_snippets.each do |template|
-        add_offense("This template is not used", template: template)
+      missing_snippets.each do |theme_file|
+        add_offense("This snippet is not used", theme_file: theme_file) do |corrector|
+          corrector.remove(@theme, theme_file.relative_path.to_s)
+        end
       end
     end
 
     def missing_snippets
-      theme.snippets.reject { |t| @used_templates.include?(t.name) }
+      theme.snippets.reject { |t| @used_snippets.include?(t.name) }
     end
   end
 end

data/lib/theme_check/checks/valid_json.rb

@@ -8,7 +8,7 @@ module ThemeCheck
     def on_file(file)
       if file.parse_error
         message = format_json_parse_error(file.parse_error)
-        add_offense(message, template: file)
+        add_offense(message, theme_file: file)
       end
     end
   end

data/lib/theme_check/checks.rb

@@ -47,9 +47,10 @@ module ThemeCheck
       raise
     rescue => e
       node = args.first
-      template = node.respond_to?(:template) ? node.template.relative_path : "?"
+      theme_file = node.respond_to?(:theme_file) ? node.theme_file.relative_path : "?"
       markup = node.respond_to?(:markup) ? node.markup : ""
       node_class = node.respond_to?(:value) ? node.value.class : "?"
+      line_number = node.respond_to?(:line_number) ? node.line_number : "?"
 
       ThemeCheck.bug(<<~EOS)
         Exception while running `#{check.code_name}##{method}`:
@@ -58,12 +59,13 @@ module ThemeCheck
           #{e.backtrace.join("\n  ")}
         ```
 
-        Template: `#{template}`
+        Theme File: `#{theme_file}`
         Node: `#{node_class}`
         Markup:
         ```
         #{markup}
         ```
+        Line number: #{line_number}
         Check options: `#{check.options.pretty_inspect}`
       EOS
     end

data/lib/theme_check/cli.rb

@@ -49,7 +49,7 @@ module ThemeCheck
         "Automatically fix offenses"
       ) { @auto_correct = true }
       @option_parser.on(
-        "--fail-level SEVERITY", Check::SEVERITIES,
+        "--fail-level SEVERITY", [:crash] + Check::SEVERITIES,
         "Minimum severity (error|suggestion|style) for exit with error code"
       ) do |severity|
         @fail_level = severity.to_sym
@@ -186,12 +186,15 @@ module ThemeCheck
       storage = ThemeCheck::FileSystemStorage.new(@config.root, ignored_patterns: @config.ignored_patterns)
       theme = ThemeCheck::Theme.new(storage)
       if theme.all.empty?
-        raise Abort, "No templates found."
+        raise Abort, "No theme files found."
       end
       analyzer = ThemeCheck::Analyzer.new(theme, @config.enabled_checks, @config.auto_correct)
       analyzer.analyze_theme
       analyzer.correct_offenses
-      output_with_format(theme, analyzer, out_stream)
+      print_with_format(theme, analyzer, out_stream)
+      # corrections are committed after printing so that the
+      # source_excerpts are still pointing to the uncorrected source.
+      analyzer.write_corrections
       raise Abort, "" if analyzer.uncorrectable_offenses.any? do |offense|
         offense.check.severity_value <= Check.severity_value(@fail_level)
       end
@@ -211,7 +214,7 @@ module ThemeCheck
       STDERR.puts "Profiling is only available in development"
     end
 
-    def output_with_format(theme, analyzer, out_stream)
+    def print_with_format(theme, analyzer, out_stream)
       case @format
       when :text
         ThemeCheck::Printer.new(out_stream).print(theme, analyzer.offenses, @config.auto_correct)

data/lib/theme_check/corrector.rb

@@ -2,30 +2,25 @@
 
 module ThemeCheck
   class Corrector
-    def initialize(template:)
-      @template = template
+    def initialize(theme_file:)
+      @theme_file = theme_file
     end
 
     def insert_after(node, content)
-      line = @template.full_line(node.line_number)
-      line.insert(node.range[1] + 1, content)
+      @theme_file.rewriter.insert_after(node, content)
     end
 
     def insert_before(node, content)
-      line = @template.full_line(node.line_number)
-      line.insert(node.range[0], content)
+      @theme_file.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
+      @theme_file.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)
+      @theme_file.rewriter.wrap(node, insert_before, insert_after)
     end
 
     def create(theme, relative_path, content)
@@ -34,11 +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/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,19 @@ 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)

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,10 @@ 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

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, []