[Feature] Implement file cache

lib/erb_lint/all.rb

@@ -3,6 +3,8 @@
 require "rubocop"
 
 require "erb_lint"
+require "erb_lint/cache"
+require "erb_lint/cached_offense"
 require "erb_lint/corrector"
 require "erb_lint/file_loader"
 require "erb_lint/linter_config"

lib/erb_lint/cache.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class Cache
+    CACHE_DIRECTORY = ".erb-lint-cache"
+
+    def initialize(config, file_loader = nil, prune = false)
+      @config = config
+      @file_loader = file_loader
+      @hits = []
+      @new_results = []
+      @prune = prune
+      puts "Cache mode is on"
+    end
+
+    def get(filename, file_content)
+      file_checksum = checksum(filename, file_content)
+      begin
+        cache_file_contents_as_offenses = JSON.parse(
+          File.read(File.join(CACHE_DIRECTORY, file_checksum))
+        ).map do |offense|
+          ERBLint::CachedOffense.from_json(offense)
+        end
+      rescue Errno::ENOENT
+        return false
+      end
+      @hits.push(file_checksum) if prune?
+      cache_file_contents_as_offenses
+    end
+
+    def set(filename, file_content, offenses_as_json)
+      file_checksum = checksum(filename, file_content)
+      @new_results.push(file_checksum) if prune?
+
+      FileUtils.mkdir_p(CACHE_DIRECTORY)
+
+      File.open(File.join(CACHE_DIRECTORY, file_checksum), "wb") do |f|
+        f.write(offenses_as_json)
+      end
+    end
+
+    def close
+      prune_cache if prune?
+    end
+
+    def prune_cache
+      puts "Prune cache mode is on - pruned file names will be logged"
+      if hits.empty?
+        puts "Cache being created for the first time, skipping prune"
+        return
+      end
+
+      cache_files = Dir.new(CACHE_DIRECTORY).children
+      cache_files.each do |cache_file|
+        next if hits.include?(cache_file)
+
+        if new_results.include?(cache_file)
+          puts "Skipping deletion of new cache result #{cache_file}"
+          next
+        end
+
+        puts "Cleaning deleted cached file with checksum #{cache_file}"
+        File.delete(File.join(CACHE_DIRECTORY, cache_file))
+      end
+
+      @hits = []
+    end
+
+    def cache_dir_exists?
+      File.directory?(CACHE_DIRECTORY)
+    end
+
+    def clear
+      return unless cache_dir_exists?
+
+      puts "Clearing cache by deleting cache directory"
+      FileUtils.rm_r(CACHE_DIRECTORY)
+    end
+
+    private
+
+    attr_reader :config, :hits, :new_results
+
+    def checksum(filename, file_content)
+      digester = Digest::SHA1.new
+      mode = File.stat(filename).mode
+
+      digester.update(
+        "#{mode}#{config.to_hash}#{ERBLint::VERSION}#{file_content}"
+      )
+      digester.hexdigest
+    rescue Errno::ENOENT
+      # Spurious files that come and go should not cause a crash, at least not
+      # here.
+      "_"
+    end
+
+    def prune?
+      @prune
+    end
+  end
+end

lib/erb_lint/cached_offense.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ERBLint
+  # A Cached version of an Offense with only essential information represented as strings
+  class CachedOffense
+    attr_reader :line_number, :message, :severity
+
+    def initialize(message, line_number, severity)
+      @message = message
+      @line_number = line_number
+      @severity = severity
+    end
+
+    def self.new_from_offense(offense)
+      new(
+        offense.message,
+        offense.line_number.to_s,
+        offense.severity
+      )
+    end
+
+    def to_json_format
+      {
+        message: message,
+        line_number: line_number,
+        severity: severity,
+      }
+    end
+
+    def self.from_json(parsed_json)
+      parsed_json.transform_keys!(&:to_sym)
+      new(
+        parsed_json[:message],
+        parsed_json[:line_number],
+        parsed_json[:severity].to_sym
+      )
+    end
+  end
+end

lib/erb_lint/cli.rb

@@ -30,10 +30,26 @@ def initialize
     def run(args = ARGV)
       dupped_args = args.dup
       load_options(dupped_args)
+
+      if with_cache? && autocorrect?
+        failure!("cannot run autocorrect mode with cache")
+      end
+
       @files = @options[:stdin] || dupped_args
 
       load_config
 
+      @cache = Cache.new(@config, file_loader, prune_cache?) if with_cache? || clear_cache?
+
+      if clear_cache?
+        if cache.cache_dir_exists?
+          cache.clear
+          success!("cache directory cleared")
+        else
+          failure!("cache directory doesn't exist, skipping deletion.")
+        end
+      end
+
       if !@files.empty? && lint_files.empty?
         if allow_no_files?
           success!("no files found...\n")
@@ -65,7 +81,7 @@ def run(args = ARGV)
       lint_files.each do |filename|
         runner.clear_offenses
         begin
-          file_content = run_with_corrections(runner, filename)
+          file_content = run_on_file(runner, filename)
         rescue => e
           @stats.exceptions += 1
           puts "Exception occurred when processing: #{relative_filename(filename)}"
@@ -77,6 +93,8 @@ def run(args = ARGV)
         end
       end
 
+      cache.close if with_cache? || clear_cache?
+
       reporter.show
 
       if stdin? && autocorrect?
@@ -99,13 +117,47 @@ def run(args = ARGV)
 
     private
 
+    attr_reader :cache, :config
+
+    def run_on_file(runner, filename)
+      file_content = read_content(filename)
+
+      if with_cache? && !autocorrect?
+        run_using_cache(runner, filename, file_content)
+      else
+        file_content = run_with_corrections(runner, filename, file_content)
+      end
+
+      log_offense_stats(runner, filename)
+      file_content
+    end
+
+    def run_using_cache(runner, filename, file_content)
+      if (cache_result_offenses = cache.get(filename, file_content))
+        runner.restore_offenses(cache_result_offenses)
+      else
+        run_with_corrections(runner, filename, file_content)
+        cache.set(filename, file_content, runner.offenses.map(&:to_cached_offense_json_format).to_json)
+      end
+    end
+
     def autocorrect?
       @options[:autocorrect]
     end
 
-    def run_with_corrections(runner, filename)
-      file_content = read_content(filename)
+    def with_cache?
+      @options[:with_cache]
+    end
+
+    def prune_cache?
+      @options[:prune_cache]
+    end
+
+    def clear_cache?
+      @options[:clear_cache]
+    end
 
+    def run_with_corrections(runner, filename, file_content)
       7.times do
         processed_source = ERBLint::ProcessedSource.new(filename, file_content)
         runner.run(processed_source)
@@ -127,6 +179,11 @@ def run_with_corrections(runner, filename)
         file_content = corrector.corrected_content
         runner.clear_offenses
       end
+
+      file_content
+    end
+
+    def log_offense_stats(runner, filename)
       offenses_filename = relative_filename(filename)
       offenses = runner.offenses || []
 
@@ -138,8 +195,6 @@ def run_with_corrections(runner, filename)
 
       @stats.processed_files[offenses_filename] ||= []
       @stats.processed_files[offenses_filename] |= offenses
-
-      file_content
     end
 
     def read_content(filename)
@@ -283,6 +338,18 @@ def option_parser
           @options[:enabled_linters] = known_linter_names
         end
 
+        opts.on("--with-cache", "Enable caching") do |config|
+          @options[:with_cache] = config
+        end
+
+        opts.on("--prune-cache", "Prune cache") do |config|
+          @options[:prune_cache] = config
+        end
+
+        opts.on("--clear-cache", "Clear cache") do |config|
+          @options[:clear_cache] = config
+        end
+
         opts.on("--enable-linters LINTER[,LINTER,...]", Array,
           "Only use specified linter", "Known linters are: #{known_linter_names.join(", ")}") do |linters|
           linters.each do |linter|

lib/erb_lint/linter.rb

@@ -30,7 +30,7 @@ def support_autocorrect?
       end
     end
 
-    attr_reader :offenses
+    attr_reader :offenses, :config
 
     # Must be implemented by the concrete inheriting class.
     def initialize(file_loader, config)

lib/erb_lint/offense.rb

@@ -17,6 +17,10 @@ def initialize(linter, source_range, message, context = nil, severity = nil)
       @severity = severity
     end
 
+    def to_cached_offense_json_format
+      ERBLint::CachedOffense.new_from_offense(self).to_json_format
+    end
+
     def inspect
       "#<#{self.class.name} linter=#{linter.class.name} "\
         "source_range=#{source_range.begin_pos}...#{source_range.end_pos} "\

lib/erb_lint/runner.rb

@@ -30,5 +30,9 @@ def clear_offenses
       @offenses = []
       @linters.each(&:clear_offenses)
     end
+
+    def restore_offenses(offenses)
+      @offenses.concat(offenses)
+    end
   end
 end