theme-check 0.1.0 → 0.3.0

data/lib/theme_check/corrector.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class Corrector
+    def initialize(template:)
+      @template = template
+    end
+
+    def insert_after(node, content)
+      line = @template.full_line(node.line_number)
+      line.insert(node.range[1] + 1, content)
+    end
+
+    def insert_before(node, content)
+      line = @template.full_line(node.line_number)
+      line.insert(node.range[0], content)
+    end
+
+    def replace(node, content)
+      line = @template.full_line(node.line_number)
+      line[node.range[0]..node.range[1]] = 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)
+    end
+  end
+end

data/lib/theme_check/disabled_checks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class DisabledChecks
+    DISABLE_START = 'theme-check-disable'
+    DISABLE_END = 'theme-check-enable'
+    DISABLE_PREFIX_PATTERN = /#{DISABLE_START}|#{DISABLE_END}/
+
+    ACTION_DISABLE_CHECKS = :disable
+    ACTION_ENABLE_CHECKS = :enable
+    ACTION_UNRELATED_COMMENT = :unrelated
+
+    def initialize
+      @disabled = []
+      @all_disabled = false
+      @full_document_disabled = false
+    end
+
+    def update(node)
+      text = comment_text(node)
+
+      if start_disabling?(text)
+        @disabled = checks_from_text(text)
+        @all_disabled = @disabled.empty?
+
+        if node&.line_number == 1
+          @full_document_disabled = true
+        end
+      elsif stop_disabling?(text)
+        checks = checks_from_text(text)
+        @disabled = checks.empty? ? [] : @disabled - checks
+
+        @all_disabled = false
+      end
+    end
+
+    # Whether any checks are currently disabled
+    def any?
+      !@disabled.empty? || @all_disabled
+    end
+
+    # Whether all checks should be disabled
+    def all_disabled?
+      @all_disabled
+    end
+
+    # Get a list of all the individual disabled checks
+    def all
+      @disabled
+    end
+
+    # If the first line of the document is a theme-check-disable comment
+    def full_document_disabled?
+      @full_document_disabled
+    end
+
+    private
+
+    def comment_text(node)
+      node.value.nodelist.join
+    end
+
+    def start_disabling?(text)
+      text.strip.starts_with?(DISABLE_START)
+    end
+
+    def stop_disabling?(text)
+      text.strip.starts_with?(DISABLE_END)
+    end
+
+    # Return a list of checks from a theme-check-disable comment
+    # Returns [] if all checks are meant to be disabled
+    def checks_from_text(text)
+      text.gsub(DISABLE_PREFIX_PATTERN, '').strip.split(',').map(&:strip)
+    end
+  end
+end

data/lib/theme_check/file_system_storage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "pathname"
+
+module ThemeCheck
+  class FileSystemStorage < Storage
+    attr_reader :root
+
+    def initialize(root, ignored_patterns: [])
+      @root = Pathname.new(root)
+      @ignored_patterns = ignored_patterns
+      @files = {}
+    end
+
+    def path(relative_path)
+      @root.join(relative_path)
+    end
+
+    def read(relative_path)
+      file(relative_path).read
+    end
+
+    def write(relative_path, content)
+      file(relative_path).write(content)
+    end
+
+    def files
+      @file_array ||= glob("**/*")
+        .map { |path| path.relative_path_from(@root).to_s }
+    end
+
+    def directories
+      @directories ||= glob('*')
+        .select { |f| File.directory?(f) }
+        .map { |f| f.relative_path_from(@root).to_s }
+    end
+
+    private
+
+    def glob(pattern)
+      @root.glob(pattern).reject do |path|
+        relative_path = path.relative_path_from(@root)
+        @ignored_patterns.any? { |ignored| relative_path.fnmatch?(ignored) }
+      end
+    end
+
+    def file(name)
+      return @files[name] if @files[name]
+      @files[name] = root.join(name)
+    end
+  end
+end

data/lib/theme_check/in_memory_storage.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# 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
+# as a big hash already, leave it like that and save yourself some IO.
+module ThemeCheck
+  class InMemoryStorage < Storage
+    def initialize(files)
+      @files = files
+    end
+
+    def path(name)
+      name
+    end
+
+    def read(name)
+      @files[name]
+    end
+
+    def write(name, content)
+      @files[name] = content
+    end
+
+    def files
+      @values ||= @files.keys
+    end
+
+    def directories
+      @directories ||= @files
+        .keys
+        .flat_map { |relative_path| Pathname.new(relative_path).ascend.to_a }
+        .map(&:to_s)
+        .uniq
+    end
+  end
+end

data/lib/theme_check/json_file.rb

@@ -4,22 +4,20 @@ require "pathname"
 
 module ThemeCheck
   class JsonFile
-    attr_reader :path
-
-    def initialize(path, root)
-      @path = Pathname(path)
-      @root = Pathname(root)
+    def initialize(relative_path, storage)
+      @relative_path = relative_path
+      @storage = storage
       @loaded = false
       @content = nil
       @parser_error = nil
     end
 
-    def relative_path
-      @path.relative_path_from(@root)
+    def path
+      @storage.path(@relative_path)
     end
 
-    def name
-      relative_path.sub_ext('').to_s
+    def relative_path
+      @relative_pathname ||= Pathname.new(@relative_path)
     end
 
     def content
@@ -32,12 +30,16 @@ module ThemeCheck
       @parser_error
     end
 
+    def name
+      relative_path.sub_ext('').to_s
+    end
+
     private
 
     def load!
       return if @loaded
 
-      @content = JSON.parse(File.read(@path))
+      @content = JSON.parse(@storage.read(@relative_path))
     rescue JSON::ParserError => e
       @parser_error = e
     ensure

data/lib/theme_check/language_server/handler.rb

@@ -14,6 +14,7 @@ module ThemeCheck
 
       def initialize(server)
         @server = server
+        @previously_reported_files = Set.new
       end
 
       def on_initialize(id, params)
@@ -41,27 +42,51 @@ module ThemeCheck
       def analyze_and_send_offenses(file_path)
         root = ThemeCheck::Config.find(file_path) || @root_path
         config = ThemeCheck::Config.from_path(root)
-        theme = ThemeCheck::Theme.new(config.root)
-        analyzer = ThemeCheck::Analyzer.new(theme, config.enabled_checks)
+        storage = ThemeCheck::FileSystemStorage.new(
+          config.root,
+          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
-        log("Found #{theme.all.size} templates, and #{analyzer.offenses.size} offenses")
-        send_offenses(analyzer.offenses)
+        analyzer.offenses
       end
 
-      def send_offenses(offenses)
+      def send_diagnostics(offenses)
+        reported_files = Set.new
+
         offenses.group_by(&:template).each do |template, template_offenses|
           next unless template
-          # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
-          send_response(
-            method: 'textDocument/publishDiagnostics',
-            params: {
-              uri: "file:#{template.path}",
-              diagnostics: template_offenses.map { |offense| offense_to_diagnostic(offense) },
-            },
-          )
+          send_diagnostic(template.path, template_offenses)
+          reported_files << template.path
+        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)
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage
+        send_response(
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: "file:#{path}",
+            diagnostics: offenses.map { |offense| offense_to_diagnostic(offense) },
+          },
+        )
       end
 
       def offense_to_diagnostic(offense)

data/lib/theme_check/language_server/server.rb

@@ -9,6 +9,8 @@ module ThemeCheck
     class IncompatibleStream < StandardError; end
 
     class Server
+      attr_reader :handler
+
       def initialize(
         in_stream: STDIN,
         out_stream: STDOUT,
@@ -87,8 +89,6 @@ module ThemeCheck
 
         if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
-        else
-          log("Handler does not respond to #{method_name}")
         end
       end
 

data/lib/theme_check/liquid_check.rb

@@ -6,8 +6,8 @@ module ThemeCheck
     extend ChecksTracking
     include ParsingHelpers
 
-    def add_offense(message, node: nil, template: node&.template, markup: nil, line_number: nil)
-      offenses << Offense.new(check: self, message: message, template: template, node: node, markup: markup, line_number: line_number)
+    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

data/lib/theme_check/node.rb

@@ -22,6 +22,14 @@ module ThemeCheck
       end
     end
 
+    def markup=(markup)
+      if tag?
+        @value.raw = markup
+      elsif @value.instance_variable_defined?(:@markup)
+        @value.instance_variable_set(:@markup, markup)
+      end
+    end
+
     # Array of children nodes.
     def children
       @children ||= begin
@@ -113,5 +121,10 @@ module ThemeCheck
         false
       end
     end
+
+    def range
+      start = template.full_line(line_number).index(markup)
+      [start, start + markup.length - 1]
+    end
   end
 end

data/lib/theme_check/offense.rb

@@ -3,10 +3,11 @@ module ThemeCheck
   class Offense
     MAX_SOURCE_EXCERPT_SIZE = 120
 
-    attr_reader :check, :message, :template, :node, :markup, :line_number
+    attr_reader :check, :message, :template, :node, :markup, :line_number, :correction
 
-    def initialize(check:, message: nil, template: nil, node: nil, markup: nil, line_number: nil)
+    def initialize(check:, message: nil, template: nil, node: nil, markup: nil, line_number: nil, correction: nil)
       @check = check
+      @correction = correction
 
       if message
         @message = message
@@ -39,7 +40,7 @@ module ThemeCheck
     def source_excerpt
       return unless line_number
       @source_excerpt ||= begin
-        excerpt = template.excerpt(line_number)
+        excerpt = template.source_excerpt(line_number)
         if excerpt.size > MAX_SOURCE_EXCERPT_SIZE
           excerpt[0, MAX_SOURCE_EXCERPT_SIZE - 3] + '...'
         else
@@ -54,18 +55,22 @@ module ThemeCheck
     end
 
     def end_line
-      return 0 unless line_number
-      line_number - 1
+      if markup
+        start_line + markup.count("\n")
+      else
+        start_line
+      end
     end
 
     def start_column
-      return 0 unless line_number
-      template.full_line(line_number).index(markup)
+      return 0 unless line_number && markup
+      template.full_line(start_line + 1).index(markup.split("\n", 2).first)
     end
 
     def end_column
-      return 0 unless line_number
-      template.full_line(line_number).index(markup) + markup.size
+      return 0 unless line_number && markup
+      markup_end = markup.split("\n").last
+      template.full_line(end_line + 1).index(markup_end) + markup_end.size
     end
 
     def code_name
@@ -93,6 +98,17 @@ module ThemeCheck
       tokens.join(":") if tokens.any?
     end
 
+    def correctable?
+      line_number && correction
+    end
+
+    def correct
+      if correctable?
+        corrector = Corrector.new(template: template)
+        correction.call(corrector)
+      end
+    end
+
     def to_s
       if template
         "#{message} at #{location}"