erb_lint 0.1.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ee5b7d05405468648ea7ea174c2f8f57ec1e56490873e1e89e1e9f618df585
-  data.tar.gz: 3f7db38955673a6218517c8a031c97a9aed5a03fe8a1a9ed11c631cc8aa920f7
+  metadata.gz: 0eabdfa71b2841fc684663a79233451981e21fcffb175c3ae7a1e0bd8afdc8e4
+  data.tar.gz: c609b033d3354e27c938ef1972b1ac16c654b1900115bb4f6d6595c384d1cfb5
 SHA512:
-  metadata.gz: e466a9178358d9400fa7a38cda19d1263efecaa1729391b1eea5c9dae2cf928686f97c5d84a0df85ba6774465f415ef94ec628cda8cc38834f2983fe525f41e7
-  data.tar.gz: 1f7cc9b5a8994d9378f70085d69e0012baa78c0da7896b366dfd32f894f05b4c3978c831eab31f6b209c9c4a42bfe36dcf0bb413a872a91a2bb22bfc79effc16
+  metadata.gz: f3686f39426c32119e8a725b8320143b31c48f98969bb6f0135827c5ff7c260d5674cfad5190c2bc75111fd5a76d881e47d7aa18b6b48f3f903f698719601623
+  data.tar.gz: 727473a64473dad0adb3912bc7f7b7e5c84d51c60374f72e93f380d378635848a240e8f1f3f16ec8f88874290e5e16821e8445b882c09cec4c78081db9eb2bda

data/exe/erb_lint

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path("#{__dir__}/../lib")
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require "erb_lint/cli"
+
+cli = ERBLint::CLI.new
+exit(cli.run)

data/exe/erblint

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift("#{__dir__}/../lib")
+lib_path = File.expand_path("#{__dir__}/../lib")
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 
-require "erb_lint/cli"
+require "rainbow"
 
-cli = ERBLint::CLI.new
-exit(cli.run)
+warn(Rainbow("Calling `erblint` is deprecated, please call the renamed executable `erb_lint` instead.").yellow)
+exec(File.join(__dir__, "erb_lint"), *ARGV)

data/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"

data/lib/erb_lint/cache.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class Cache
+    CACHE_DIRECTORY = ".erb_lint_cache"
+
+    def initialize(config, cache_dir = nil)
+      @config = config
+      @cache_dir = cache_dir || CACHE_DIRECTORY
+      @hits = []
+      @new_results = []
+      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_dir, file_checksum)),
+        ).map do |offense_hash|
+          ERBLint::CachedOffense.new(offense_hash)
+        end
+      rescue Errno::ENOENT
+        return false
+      end
+      @hits.push(file_checksum)
+      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)
+
+      FileUtils.mkdir_p(@cache_dir)
+
+      File.open(File.join(@cache_dir, file_checksum), "wb") do |f|
+        f.write(offenses_as_json)
+      end
+    end
+
+    def close
+      prune_cache
+    end
+
+    def prune_cache
+      if hits.empty?
+        puts "Cache being created for the first time, skipping prune"
+        return
+      end
+
+      cache_files = Dir.new(@cache_dir).children
+      cache_files.each do |cache_file|
+        next if hits.include?(cache_file) || new_results.include?(cache_file)
+
+        File.delete(File.join(@cache_dir, cache_file))
+      end
+    end
+
+    def cache_dir_exists?
+      File.directory?(@cache_dir)
+    end
+
+    def clear
+      return unless cache_dir_exists?
+
+      puts "Clearing cache by deleting cache directory"
+      FileUtils.rm_r(@cache_dir)
+    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
+  end
+end

data/lib/erb_lint/cached_offense.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ERBLint
+  # A Cached version of an Offense with only essential information represented as strings
+  class CachedOffense
+    attr_reader(
+      :message,
+      :line_number,
+      :severity,
+      :column,
+      :simple_name,
+      :last_line,
+      :last_column,
+      :length,
+    )
+
+    def initialize(params)
+      params = params.transform_keys(&:to_sym)
+
+      @message = params[:message]
+      @line_number = params[:line_number]
+      @severity = params[:severity]&.to_sym
+      @column = params[:column]
+      @simple_name = params[:simple_name]
+      @last_line = params[:last_line]
+      @last_column = params[:last_column]
+      @length = params[:length]
+    end
+
+    def self.new_from_offense(offense)
+      new(
+        {
+          message: offense.message,
+          line_number: offense.line_number,
+          severity: offense.severity,
+          column: offense.column,
+          simple_name: offense.simple_name,
+          last_line: offense.last_line,
+          last_column: offense.last_column,
+          length: offense.length,
+        },
+      )
+    end
+
+    def to_h
+      {
+        message: message,
+        line_number: line_number,
+        severity: severity,
+        column: column,
+        simple_name: simple_name,
+        last_line: last_line,
+        last_column: last_column,
+        length: length,
+      }
+    end
+  end
+end

data/lib/erb_lint/cli.rb

@@ -13,7 +13,8 @@ module ERBLint
   class CLI
     include Utils::SeverityLevels
 
-    DEFAULT_CONFIG_FILENAME = ".erb-lint.yml"
+    DEPRECATED_CONFIG_FILENAME = ".erb-lint.yml"
+    DEFAULT_CONFIG_FILENAME = ".erb_lint.yml"
     DEFAULT_LINT_ALL_GLOB = "**/*.html{+*,}.erb"
 
     class ExitWithFailure < RuntimeError; end
@@ -30,12 +31,33 @@ module ERBLint
     def run(args = ARGV)
       dupped_args = args.dup
       load_options(dupped_args)
+
+      if cache? && autocorrect?
+        failure!("cannot run autocorrect mode with cache")
+      end
+
       @files = @options[:stdin] || dupped_args
 
       load_config
 
+      cache_dir = @options[:cache_dir]
+      @cache = Cache.new(@config, cache_dir) if 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?
-        failure!("no files found...\n")
+        if allow_no_files?
+          success!("no files found...\n")
+        else
+          failure!("no files found...\n")
+        end
       elsif lint_files.empty?
         failure!("no files found or given, specify files or config...\n#{option_parser}")
       end
@@ -48,24 +70,25 @@ module ERBLint
 
       @options[:format] ||= :multiline
       @options[:fail_level] ||= severity_level_for_name(:refactor)
+      @options[:disable_inline_configs] ||= false
       @stats.files = lint_files.size
       @stats.linters = enabled_linter_classes.size
       @stats.autocorrectable_linters = enabled_linter_classes.count(&:support_autocorrect?)
 
-      reporter = Reporter.create_reporter(@options[:format], @stats, autocorrect?)
+      reporter = Reporter.create_reporter(@options[:format], @stats, autocorrect?, @options[:show_linter_names])
       reporter.preview
 
-      runner = ERBLint::Runner.new(file_loader, @config)
+      runner = ERBLint::Runner.new(file_loader, @config, @options[:disable_inline_configs])
       file_content = nil
 
       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)}"
-          puts "If this file cannot be processed by erb-lint, "\
+          puts "If this file cannot be processed by erb_lint, " \
             "you can exclude it in your configuration file."
           puts e.message
           puts Rainbow(e.backtrace.join("\n")).red
@@ -73,6 +96,8 @@ module ERBLint
         end
       end
 
+      cache&.close
+
       reporter.show
 
       if stdin? && autocorrect?
@@ -95,19 +120,49 @@ module ERBLint
 
     private
 
+    attr_reader :cache, :config
+
+    def run_on_file(runner, filename)
+      file_content = read_content(filename)
+
+      if 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_hash).to_json)
+      end
+    end
+
     def autocorrect?
       @options[:autocorrect]
     end
 
-    def run_with_corrections(runner, filename)
-      file_content = read_content(filename)
+    def cache?
+      @options[: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)
         break unless autocorrect? && runner.offenses.any?
 
-        corrector = correct(processed_source, runner.offenses)
+        corrector = corrector(processed_source, runner.offenses)
         break if corrector.corrections.empty?
         break if processed_source.file_content == corrector.corrected_content
 
@@ -123,6 +178,11 @@ module ERBLint
         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 || []
 
@@ -134,8 +194,6 @@ module ERBLint
 
       @stats.processed_files[offenses_filename] ||= []
       @stats.processed_files[offenses_filename] |= offenses
-
-      file_content
     end
 
     def read_content(filename)
@@ -144,10 +202,8 @@ module ERBLint
       $stdin.binmode.read.force_encoding(Encoding::UTF_8)
     end
 
-    def correct(processed_source, offenses)
-      corrector = ERBLint::Corrector.new(processed_source, offenses)
-      failure!(corrector.diagnostics.join(", ")) if corrector.diagnostics.any?
-      corrector
+    def corrector(processed_source, offenses)
+      ERBLint::Corrector.new(processed_source, offenses)
     end
 
     def config_filename
@@ -158,6 +214,13 @@ module ERBLint
       if File.exist?(config_filename)
         config = RunnerConfig.new(file_loader.yaml(config_filename), file_loader)
         @config = RunnerConfig.default_for(config)
+      elsif File.exist?(DEPRECATED_CONFIG_FILENAME)
+        deprecation_message = "The config file has been renamed to `#{DEFAULT_CONFIG_FILENAME}` and " \
+          "`#{DEPRECATED_CONFIG_FILENAME}` is deprecated. " \
+          "Please rename your config file to `#{DEFAULT_CONFIG_FILENAME}`."
+        warn(Rainbow(deprecation_message).yellow)
+        config = RunnerConfig.new(file_loader.yaml(DEPRECATED_CONFIG_FILENAME), file_loader)
+        @config = RunnerConfig.default_for(config)
       else
         warn(Rainbow("#{config_filename} not found: using default config").yellow)
         @config = RunnerConfig.default
@@ -165,7 +228,7 @@ module ERBLint
     rescue Psych::SyntaxError => e
       failure!("error parsing config: #{e.message}")
     ensure
-      @config.merge!(runner_config_override)
+      @config&.merge!(runner_config_override)
     end
 
     def file_loader
@@ -246,7 +309,7 @@ module ERBLint
           ERBLint::LinterRegistry.linters.map do |klass|
             linters[klass.simple_name] = { "enabled" => enabled_linter_classes.include?(klass) }
           end
-        end
+        end,
       )
     end
 
@@ -262,7 +325,7 @@ module ERBLint
           end
         end
 
-        opts.on("--format FORMAT", format_options_help) do |format|
+        opts.on("-f", "--format FORMAT", format_options_help) do |format|
           unless Reporter.available_format?(format)
             error_message = invalid_format_error_message(format)
             failure!(error_message)
@@ -279,8 +342,24 @@ module ERBLint
           @options[:enabled_linters] = known_linter_names
         end
 
-        opts.on("--enable-linters LINTER[,LINTER,...]", Array,
-          "Only use specified linter", "Known linters are: #{known_linter_names.join(", ")}") do |linters|
+        opts.on("--cache", "Enable caching") do |config|
+          @options[:cache] = config
+        end
+
+        opts.on("--cache-dir DIR", "Set the cache directory") do |dir|
+          @options[:cache_dir] = dir
+        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|
             unless known_linter_names.include?(linter)
               failure!("#{linter}: not a valid linter name (#{known_linter_names.join(", ")})")
@@ -302,10 +381,22 @@ module ERBLint
           @options[:autocorrect] = config
         end
 
+        opts.on("--show-linter-names", "Show linter names") do
+          @options[:show_linter_names] = true
+        end
+
+        opts.on("--allow-no-files", "When no matching files found, exit successfully (default: false)") do |config|
+          @options[:allow_no_files] = config
+        end
+
+        opts.on("--disable-inline-configs", "Report all offenses while ignoring inline disable comments") do
+          @options[:disable_inline_configs] = true
+        end
+
         opts.on(
           "-sFILE",
           "--stdin FILE",
-          "Pipe source from STDIN. Takes the path to be used to check which rules to apply."
+          "Pipe source from STDIN. Takes the path to be used to check which rules to apply.",
         ) do |file|
           @options[:stdin] = [file]
         end
@@ -321,7 +412,7 @@ module ERBLint
     end
 
     def format_options_help
-      "Report offenses in the given format: "\
+      "Report offenses in the given format: " \
         "(#{Reporter.available_formats.join(", ")}) (default: multiline)"
     end
 
@@ -333,5 +424,9 @@ module ERBLint
     def stdin?
       @options[:stdin].present?
     end
+
+    def allow_no_files?
+      @options[:allow_no_files]
+    end
   end
 end

data/lib/erb_lint/corrector.rb

@@ -7,31 +7,20 @@ module ERBLint
     def initialize(processed_source, offenses)
       @processed_source = processed_source
       @offenses = offenses
+      corrector = RuboCop::Cop::Corrector.new(@processed_source.source_buffer)
+      correct!(corrector)
       @corrected_content = corrector.rewrite
     end
 
     def corrections
       @corrections ||= @offenses.map do |offense|
-        offense.linter.autocorrect(@processed_source, offense)
+        offense.linter.autocorrect(@processed_source, offense) if offense.linter.class.support_autocorrect?
       end.compact
     end
 
-    def corrector
-      BASE.new(@processed_source.source_buffer, corrections)
-    end
-
-    if ::RuboCop::Version::STRING.to_f >= 0.87
-      require "rubocop/cop/legacy/corrector"
-      BASE = ::RuboCop::Cop::Legacy::Corrector
-
-      def diagnostics
-        []
-      end
-    else
-      BASE = ::RuboCop::Cop::Corrector
-
-      def diagnostics
-        corrector.diagnostics
+    def correct!(corrector)
+      corrections.each do |correction|
+        correction.call(corrector)
       end
     end
   end

data/lib/erb_lint/file_loader.rb

@@ -9,14 +9,8 @@ module ERBLint
       @base_path = base_path
     end
 
-    if RUBY_VERSION >= "2.6"
-      def yaml(filename)
-        YAML.safe_load(read_content(filename), permitted_classes: [Regexp, Symbol], filename: filename) || {}
-      end
-    else
-      def yaml(filename)
-        YAML.safe_load(read_content(filename), [Regexp, Symbol], [], false, filename) || {}
-      end
+    def yaml(filename)
+      YAML.safe_load(read_content(filename), permitted_classes: [Regexp, Symbol], filename: filename) || {}
     end
 
     private

data/lib/erb_lint/linter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "erb_lint/utils/inline_configs"
+
 module ERBLint
   # Defines common functionality available to all linters.
   class Linter
@@ -30,13 +32,13 @@ module ERBLint
       end
     end
 
-    attr_reader :offenses
+    attr_reader :offenses, :config
 
     # Must be implemented by the concrete inheriting class.
     def initialize(file_loader, config)
       @file_loader = file_loader
       @config = config
-      raise ArgumentError, "expect `config` to be #{self.class.config_schema} instance, "\
+      raise ArgumentError, "expect `config` to be #{self.class.config_schema} instance, " \
         "not #{config.class}" unless config.is_a?(self.class.config_schema)
       @offenses = []
     end
@@ -53,6 +55,13 @@ module ERBLint
       raise NotImplementedError, "must implement ##{__method__}"
     end
 
+    def run_and_update_offense_status(processed_source, enable_inline_configs = true)
+      run(processed_source)
+      if @offenses.any? && enable_inline_configs
+        update_offense_status(processed_source)
+      end
+    end
+
     def add_offense(source_range, message, context = nil, severity = nil)
       @offenses << Offense.new(self, source_range, message, context, severity)
     end
@@ -60,5 +69,22 @@ module ERBLint
     def clear_offenses
       @offenses = []
     end
+
+    private
+
+    def update_offense_status(processed_source)
+      @offenses.each do |offense|
+        offense_line_range = offense.source_range.line_range
+        offense_lines = source_for_line_range(processed_source, offense_line_range)
+
+        if Utils::InlineConfigs.rule_disable_comment_for_lines?(self.class.simple_name, offense_lines)
+          offense.disabled = true
+        end
+      end
+    end
+
+    def source_for_line_range(processed_source, line_range)
+      processed_source.source_buffer.source_lines[line_range.first - 1..line_range.last - 1].join
+    end
   end
 end

data/lib/erb_lint/linter_registry.rb

@@ -3,7 +3,8 @@
 module ERBLint
   # Stores all linters available to the application.
   module LinterRegistry
-    CUSTOM_LINTERS_DIR = ".erb-linters"
+    DEPRECATED_CUSTOM_LINTERS_DIR = ".erb-linters"
+    CUSTOM_LINTERS_DIR = ".erb_linters"
     @loaded_linters = []
 
     class << self
@@ -28,6 +29,15 @@ module ERBLint
 
       def load_custom_linters(directory = CUSTOM_LINTERS_DIR)
         ruby_files = Dir.glob(File.expand_path(File.join(directory, "**", "*.rb")))
+
+        deprecated_ruby_files = Dir.glob(File.expand_path(File.join(DEPRECATED_CUSTOM_LINTERS_DIR, "**", "*.rb")))
+        if deprecated_ruby_files.any?
+          deprecation_message = "The '#{DEPRECATED_CUSTOM_LINTERS_DIR}' directory for custom linters is deprecated. " \
+            "Please rename it to '#{CUSTOM_LINTERS_DIR}'"
+          warn(Rainbow(deprecation_message).yellow)
+          ruby_files.concat(deprecated_ruby_files)
+        end
+
         ruby_files.each { |file| require file }
       end
     end

data/lib/erb_lint/linters/allowed_script_type.rb

@@ -12,7 +12,8 @@ module ERBLint
       include LinterRegistry
 
       class ConfigSchema < LinterConfig
-        property :allowed_types, accepts: array_of?(String),
+        property :allowed_types,
+          accepts: array_of?(String),
           default: -> { ["text/javascript"] }
         property :allow_blank, accepts: [true, false], default: true, reader: :allow_blank?
         property :disallow_inline_scripts, accepts: [true, false], default: false, reader: :disallow_inline_scripts?
@@ -30,8 +31,8 @@ module ERBLint
             name_node = tag_node.to_a[1]
             add_offense(
               name_node.loc,
-              "Avoid using inline `<script>` tags altogether. "\
-                "Instead, move javascript code into a static file."
+              "Avoid using inline `<script>` tags altogether. " \
+                "Instead, move javascript code into a static file.",
             )
             next
           end
@@ -44,14 +45,14 @@ module ERBLint
             add_offense(
               name_node.loc,
               "Missing a `type=\"text/javascript\"` attribute to `<script>` tag.",
-              [type_attribute]
+              [type_attribute],
             )
           elsif type_present && !@config.allowed_types.include?(type_attribute.value)
             add_offense(
               type_attribute.loc,
-              "Avoid using #{type_attribute.value.inspect} as type for `<script>` tag. "\
-                "Must be one of: #{@config.allowed_types.join(", ")}"\
-                "#{" (or no type attribute)" if @config.allow_blank?}."
+              "Avoid using #{type_attribute.value.inspect} as type for `<script>` tag. " \
+                "Must be one of: #{@config.allowed_types.join(", ")}" \
+                "#{" (or no type attribute)" if @config.allow_blank?}.",
             )
           end
         end

data/lib/erb_lint/linters/closing_erb_tag_indent.rb

@@ -25,13 +25,13 @@ module ERBLint
             add_offense(
               code_node.loc.end.adjust(begin_pos: -end_spaces.size),
               "Remove newline before `%>` to match start of tag.",
-              " "
+              " ",
             )
           elsif start_with_newline && !end_with_newline
             add_offense(
               code_node.loc.end.adjust(begin_pos: -end_spaces.size),
               "Insert newline before `%>` to match start of tag.",
-              "\n"
+              "\n",
             )
           elsif start_with_newline && end_with_newline
             current_indent = end_spaces.split("\n", -1).last
@@ -39,7 +39,7 @@ module ERBLint
               add_offense(
                 code_node.loc.end.adjust(begin_pos: -current_indent.size),
                 "Indent `%>` on column #{erb_node.loc.column} to match start of tag.",
-                " " * erb_node.loc.column
+                " " * erb_node.loc.column,
               )
             end
           end