theme-check 0.8.2 → 0.10.1

data/lib/theme_check/checks/template_length.rb

@@ -8,6 +8,9 @@ module ThemeCheck
     def initialize(max_length: 200, exclude_schema: true)
       @max_length = max_length
       @exclude_schema = exclude_schema
+    end
+
+    def on_document(_node)
       @excluded_lines = 0
     end
 

data/lib/theme_check/checks/valid_html_translation.rb

@@ -5,6 +5,7 @@ require 'nokogumbo'
 module ThemeCheck
   class ValidHTMLTranslation < JsonCheck
     severity :suggestion
+    category :translation
     doc docs_url(__FILE__)
 
     def on_file(file)

data/lib/theme_check/config.rb

@@ -91,11 +91,13 @@ module ThemeCheck
 
         options_for_check = options.transform_keys(&:to_sym)
         options_for_check.delete(:enabled)
+        ignored_patterns = options_for_check.delete(:ignore) || []
         check = if options_for_check.empty?
           check_class.new
         else
           check_class.new(**options_for_check)
         end
+        check.ignored_patterns = ignored_patterns
         check.options = options_for_check
         check
       end.compact

data/lib/theme_check/disabled_check.rb

@@ -4,10 +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, :ranges
+    attr_reader :name, :template, :ranges
     attr_accessor :first_line
 
-    def initialize(name)
+    def initialize(template, name)
+      @template = template
       @name = name
       @ranges = []
       @first_line = false
@@ -24,7 +25,8 @@ module ThemeCheck
     end
 
     def disabled?(index)
-      ranges.any? { |range| range.cover?(index) }
+      index == 0 && first_line ||
+        ranges.any? { |range| range.cover?(index) }
     end
 
     def last
@@ -33,7 +35,7 @@ module ThemeCheck
 
     def missing_end_index?
       return false if first_line && ranges.size == 1
-      last.end.nil?
+      last&.end.nil?
     end
   end
 end

data/lib/theme_check/disabled_checks.rb

@@ -10,28 +10,36 @@ module ThemeCheck
     ACTION_ENABLE_CHECKS = :enable
 
     def initialize
-      @disabled_checks = {}
+      @disabled_checks = Hash.new do |hash, key|
+        template, check_name = key
+        hash[key] = DisabledCheck.new(template, check_name)
+      end
     end
 
     def update(node)
       text = comment_text(node)
       if start_disabling?(text)
         checks_from_text(text).each do |check_name|
-          @disabled_checks[check_name] ||= DisabledCheck.new(check_name)
-          @disabled_checks[check_name].start_index = node.start_index
-          @disabled_checks[check_name].first_line = true if node.line_number == 1
+          disabled = @disabled_checks[[node.template, 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|
-          next unless @disabled_checks.key?(check_name)
-          @disabled_checks[check_name].end_index = node.end_index
+          disabled = @disabled_checks[[node.template, check_name]]
+          next unless disabled
+          disabled.end_index = node.end_index
         end
       end
     end
 
-    def disabled?(key, index)
-      @disabled_checks[:all]&.disabled?(index) ||
-        @disabled_checks[key]&.disabled?(index)
+    def disabled?(check, template, check_name, index)
+      return true if check.ignored_patterns&.any? do |pattern|
+        template.relative_path.fnmatch?(pattern)
+      end
+
+      @disabled_checks[[template, :all]]&.disabled?(index) ||
+        @disabled_checks[[template, check_name]]&.disabled?(index)
     end
 
     def checks_missing_end_index
@@ -40,6 +48,14 @@ module ThemeCheck
         .map(&:name)
     end
 
+    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)
+        end
+      end
+    end
+
     private
 
     def comment_text(node)

data/lib/theme_check/html_check.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class HtmlCheck < Check
+    extend ChecksTracking
+  end
+end

data/lib/theme_check/html_node.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require "forwardable"
+
+module ThemeCheck
+  class HtmlNode
+    extend Forwardable
+    attr_reader :template
+
+    def_delegators :@value, :content, :attributes
+
+    def initialize(value, template)
+      @value = value
+      @template = template
+    end
+
+    def literal?
+      @value.name == "text"
+    end
+
+    def element?
+      @value.element?
+    end
+
+    def children
+      @value.children.map { |child| HtmlNode.new(child, template) }
+    end
+
+    def parent
+      HtmlNode.new(@value.parent, template)
+    end
+
+    def name
+      if @value.name == "#document-fragment"
+        "document"
+      else
+        @value.name
+      end
+    end
+
+    def value
+      if literal?
+        @value.content
+      else
+        @value
+      end
+    end
+
+    def markup
+      @value.to_html
+    end
+
+    def line_number
+      @value.line
+    end
+  end
+end

data/lib/theme_check/html_visitor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "nokogumbo"
+require "forwardable"
+
+module ThemeCheck
+  class HtmlVisitor
+    attr_reader :checks
+
+    def initialize(checks)
+      @checks = checks
+    end
+
+    def visit_template(template)
+      doc = parse(template)
+      visit(HtmlNode.new(doc, template))
+    end
+
+    private
+
+    def parse(template)
+      Nokogiri::HTML5.fragment(template.source)
+    end
+
+    def visit(node)
+      call_checks(:on_element, node) if node.element?
+      call_checks(:"on_#{node.name}", node)
+      node.children.each { |child| visit(child) }
+      unless node.literal?
+        call_checks(:"after_#{node.name}", node)
+        call_checks(:after_element, node) if node.element?
+      end
+    end
+
+    def call_checks(method, *args)
+      checks.call(method, *args)
+    end
+  end
+end

data/lib/theme_check/json_file.rb

@@ -38,6 +38,19 @@ module ThemeCheck
       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/language_server.rb

@@ -9,6 +9,7 @@ require_relative "language_server/completion_helper"
 require_relative "language_server/completion_provider"
 require_relative "language_server/completion_engine"
 require_relative "language_server/document_link_engine"
+require_relative "language_server/diagnostics_tracker"
 
 Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
   require file

data/lib/theme_check/language_server/completion_providers/filter_completion_provider.rb

@@ -37,6 +37,7 @@ module ThemeCheck
         partial_match = matches(content, NAMED_FILTER).find do |match|
           match.begin(1) <= cursor && cursor < match.end(1) + 1 # including next character
         end
+        return '' if partial_match.nil?
         partial_match[1]
       end
 

data/lib/theme_check/language_server/diagnostics_tracker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require "logger"
+
+module ThemeCheck
+  module LanguageServer
+    class DiagnosticsTracker
+      def initialize
+        @previously_reported_files = Set.new
+        @single_files_offenses = {}
+        @first_run = true
+      end
+
+      def first_run?
+        @first_run
+      end
+
+      def build_diagnostics(offenses, analyzed_files: nil)
+        reported_files = Set.new
+        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
+          reported_offenses = template_offenses
+          previous_offenses = @single_files_offenses[template.path]
+          if analyzed_files.nil? || analyzed_files.include?(template.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
+            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
+        end
+
+        @single_files_offenses.each do |path, _|
+          # Already reported above, skip
+          next if reported_files.include?(path)
+
+          if analyzed_files.nil? || analyzed_files.include?(path)
+            # We re-analyzed this file, if it was not reported, all offenses in it got fixed
+            yield path, []
+            new_single_file_offenses[path] = nil
+          end
+          # NOTE: No need to re-report previous offenses as LSP should keep them around until
+          # we clear them.
+          reported_files << path
+        end
+
+        # Publish diagnostics with empty array if all issues on a previously reported template
+        # have been fixed.
+        (@previously_reported_files - reported_files).each do |path|
+          yield path, []
+        end
+
+        @previously_reported_files = reported_files
+        @single_files_offenses.merge!(new_single_file_offenses)
+        @first_run = false
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/handler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "benchmark"
 
 module ThemeCheck
   module LanguageServer
@@ -19,7 +20,7 @@ module ThemeCheck
 
       def initialize(server)
         @server = server
-        @previously_reported_files = Set.new
+        @diagnostics_tracker = DiagnosticsTracker.new
       end
 
       def on_initialize(id, params)
@@ -52,6 +53,7 @@ module ThemeCheck
       end
 
       def on_text_document_did_open(_id, params)
+        return unless @diagnostics_tracker.first_run?
         relative_path = relative_path_from_text_document_uri(params)
         @storage.write(relative_path, text_document_text(params))
         analyze_and_send_offenses(text_document_uri(params))
@@ -124,17 +126,32 @@ module ThemeCheck
           ignored_patterns: config.ignored_patterns
         )
         theme = ThemeCheck::Theme.new(storage)
-
-        offenses = analyze(theme, config)
-        log("Found #{theme.all.size} templates, and #{offenses.size} offenses")
-        send_diagnostics(offenses)
-      end
-
-      def analyze(theme, config)
         analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
-        log("Checking #{config.root}")
-        analyzer.analyze_theme
-        analyzer.offenses
+
+        if @diagnostics_tracker.first_run?
+          # Analyze the full theme on first run
+          log("Checking #{config.root}")
+          offenses = nil
+          time = Benchmark.measure do
+            offenses = analyzer.analyze_theme
+          end
+          log("Found #{offenses.size} offenses in #{format("%0.2f", time.real)}s")
+          send_diagnostics(offenses)
+        else
+          # Analyze selected files
+          relative_path = Pathname.new(@storage.relative_path(absolute_path))
+          file = theme[relative_path]
+          # Skip if not a theme file
+          if file
+            log("Checking #{relative_path}")
+            offenses = nil
+            time = Benchmark.measure do
+              offenses = analyzer.analyze_files([file])
+            end
+            log("Found #{offenses.size} new offenses in #{format("%0.2f", time.real)}s")
+            send_diagnostics(offenses, [absolute_path])
+          end
+        end
       end
 
       def completions(relative_path, line, col)
@@ -145,22 +162,10 @@ module ThemeCheck
         @document_link_engine.document_links(relative_path)
       end
 
-      def send_diagnostics(offenses)
-        reported_files = Set.new
-
-        offenses.group_by(&:template).each do |template, template_offenses|
-          next unless template
-          send_diagnostic(template.path, template_offenses)
-          reported_files << template.path
+      def send_diagnostics(offenses, analyzed_files = nil)
+        @diagnostics_tracker.build_diagnostics(offenses, analyzed_files: analyzed_files) do |path, diagnostic_offenses|
+          send_diagnostic(path, diagnostic_offenses)
         end
-
-        # Publish diagnostics with empty array if all issues on a previously reported template
-        # have been solved.
-        (@previously_reported_files - reported_files).each do |path|
-          send_diagnostic(path, [])
-        end
-
-        @previously_reported_files = reported_files
       end
 
       def send_diagnostic(path, offenses)

data/lib/theme_check/language_server/server.rb

@@ -52,7 +52,7 @@ module ThemeCheck
         response_body = JSON.dump(response)
         log(JSON.pretty_generate(response)) if $DEBUG
 
-        @out.write("Content-Length: #{response_body.size}\r\n")
+        @out.write("Content-Length: #{response_body.bytesize}\r\n")
         @out.write("\r\n")
         @out.write(response_body)
         @out.flush

data/lib/theme_check/liquid_check.rb

@@ -6,6 +6,7 @@ module ThemeCheck
     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 = /(^['"])|(['"]$)/
@@ -16,9 +17,5 @@ module ThemeCheck
     ATTR = /[a-z0-9-]+/i
     HTML_ATTRIBUTE = /#{ATTR}(?:=#{QUOTED_LIQUID_ATTRIBUTE})?/omix
     HTML_ATTRIBUTES = /(?:#{HTML_ATTRIBUTE}|\s)*/omix
-
-    def add_offense(message, node: nil, template: node&.template, markup: nil, line_number: nil, &block)
-      offenses << Offense.new(check: self, message: message, template: template, node: node, markup: markup, line_number: line_number, correction: block)
-    end
   end
 end