theme-check 0.2.0 → 0.3.3

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/offense.rb

@@ -55,7 +55,9 @@ module ThemeCheck
     end
 
     def end_line
-      if markup
+      if markup&.ends_with?("\n")
+        start_line + markup.count("\n") - 1
+      elsif markup
         start_line + markup.count("\n")
       else
         start_line

data/lib/theme_check/shopify_liquid/object.rb

@@ -11,6 +11,12 @@ module ThemeCheck
           YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/objects.yml"))
         end
       end
+
+      def plus_labels
+        @plus_labels ||= begin
+          YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/plus_objects.yml"))
+        end
+      end
     end
   end
 end

data/lib/theme_check/storage.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class Storage
+    def read(relative_path)
+      raise NotImplementedError
+    end
+
+    def write(relative_path, content)
+      raise NotImplementedError
+    end
+
+    def path(relative_path)
+      raise NotImplementedError
+    end
+
+    def files
+      raise NotImplementedError
+    end
+
+    def directories
+      raise NotImplementedError
+    end
+  end
+end

data/lib/theme_check/template.rb

@@ -3,16 +3,29 @@ require "pathname"
 
 module ThemeCheck
   class Template
-    attr_reader :path
+    def initialize(relative_path, storage)
+      @storage = storage
+      @relative_path = relative_path
+    end
 
-    def initialize(path, root)
-      @path = Pathname(path)
-      @root = Pathname(root)
-      @updated = false
+    def path
+      @storage.path(@relative_path)
     end
 
     def relative_path
-      @path.relative_path_from(@root)
+      @relative_pathname ||= Pathname.new(@relative_path)
+    end
+
+    def source
+      @source ||= @storage.read(@relative_path)
+    end
+
+    def write
+      content = updated_content
+      if source != content
+        @storage.write(@relative_path, content)
+        @source = content
+      end
     end
 
     def name
@@ -31,15 +44,17 @@ module ThemeCheck
       name.start_with?('snippets')
     end
 
-    def source
-      @source ||= @path.read
-    end
-
     def lines
       # Retain trailing newline character
       @lines ||= source.split("\n", -1)
     end
 
+    # Not entirely obvious but lines is mutable, corrections are to be
+    # applied on @lines.
+    def updated_content
+      lines.join("\n")
+    end
+
     def excerpt(line)
       lines[line - 1].strip
     end
@@ -65,18 +80,8 @@ module ThemeCheck
       parse.root
     end
 
-    def update!
-      @updated = true
-    end
-
-    def write
-      if @updated
-        @path.write(lines.join("\n"))
-      end
-    end
-
     def ==(other)
-      other.is_a?(Template) && @path == other.path
+      other.is_a?(Template) && relative_path == other.relative_path
     end
 
     def self.parse(source)

data/lib/theme_check/theme.rb

@@ -4,18 +4,27 @@ require "pathname"
 module ThemeCheck
   class Theme
     DEFAULT_LOCALE_REGEXP = %r{^locales/(.*)\.default$}
-    attr_reader :root
+    LIQUID_REGEX = /\.liquid$/i
+    JSON_REGEX = /\.json$/i
 
-    def initialize(root)
-      @root = Pathname.new(root)
+    def initialize(storage)
+      @storage = storage
     end
 
     def liquid
-      @liquid ||= @root.glob("**/*.liquid").map { |path| Template.new(path, @root) }
+      @liquid ||= @storage.files
+        .select { |path| LIQUID_REGEX.match?(path) }
+        .map { |path| Template.new(path, @storage) }
     end
 
     def json
-      @json ||= @root.glob("**/*.json").map { |path| JsonFile.new(path, @root) }
+      @json ||= @storage.files
+        .select { |path| JSON_REGEX.match?(path) }
+        .map { |path| JsonFile.new(path, @storage) }
+    end
+
+    def directories
+      @storage.directories
     end
 
     def default_locale_json
@@ -52,9 +61,5 @@ module ThemeCheck
     def snippets
       liquid.select(&:snippet?)
     end
-
-    def directories
-      @directories ||= @root.glob('*').select { |f| File.directory?(f) }.map { |f| f.relative_path_from(@root) }
-    end
   end
 end

data/lib/theme_check/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ThemeCheck
-  VERSION = "0.2.0"
+  VERSION = "0.3.3"
 end

data/lib/theme_check/visitor.rb

@@ -6,12 +6,15 @@ module ThemeCheck
     end
 
     def visit_template(template)
+      @disabled_checks = DisabledChecks.new
       visit(Node.new(template.root, nil, template))
     rescue Liquid::Error => exception
       exception.template_name = template.name
       call_checks(:on_error, exception)
     end
 
+    private
+
     def visit(node)
       call_checks(:on_node, node)
       call_checks(:on_tag, node) if node.tag?
@@ -22,16 +25,24 @@ module ThemeCheck
         call_checks(:after_tag, node) if node.tag?
         call_checks(:after_node, node)
       end
-    end
 
-    private
+      @disabled_checks.update(node) if node.comment?
+    end
 
     def visit_children(node)
       node.children.each { |child| visit(child) }
     end
 
     def call_checks(method, *args)
-      @checks.call(method, *args)
+      checks.call(method, *args)
+    end
+
+    def checks
+      return @checks unless @disabled_checks.any?
+
+      return @checks.always_enabled if @disabled_checks.all_disabled?
+
+      @checks.except_for(@disabled_checks)
     end
   end
 end