erb_lint 0.1.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ee5b7d05405468648ea7ea174c2f8f57ec1e56490873e1e89e1e9f618df585
-  data.tar.gz: 3f7db38955673a6218517c8a031c97a9aed5a03fe8a1a9ed11c631cc8aa920f7
+  metadata.gz: 98ba7a87f348e584502a9e4810f9311329c04aeddf34af0b05a37702648b495e
+  data.tar.gz: 8728892a4c09fcbdbddb60316b911bf73ce099cc04e9ac10534b76f8aa6708a5
 SHA512:
-  metadata.gz: e466a9178358d9400fa7a38cda19d1263efecaa1729391b1eea5c9dae2cf928686f97c5d84a0df85ba6774465f415ef94ec628cda8cc38834f2983fe525f41e7
-  data.tar.gz: 1f7cc9b5a8994d9378f70085d69e0012baa78c0da7896b366dfd32f894f05b4c3978c831eab31f6b209c9c4a42bfe36dcf0bb413a872a91a2bb22bfc79effc16
+  metadata.gz: 8d01f3c07ddebb9482ee744c69df6e799b4c0cb06bd24ffd7939f3d86e612a4f1bb2d5b4040c8505d7c8f8e9cceaecaabcca7dc03cab6ea5f23e73f10e098345
+  data.tar.gz: '080398f6522352b669bf21ea1fbdd8850b7b6b8dcef60493d8349fbfeb98eceeefc77c15442cad339612e83c5056d5498a286046c3a3749a73428661c962b695'

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

@@ -30,12 +30,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,6 +69,7 @@ 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?)
@@ -55,13 +77,13 @@ module ERBLint
       reporter = Reporter.create_reporter(@options[:format], @stats, autocorrect?)
       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)}"
@@ -73,6 +95,8 @@ module ERBLint
         end
       end
 
+      cache&.close
+
       reporter.show
 
       if stdin? && autocorrect?
@@ -95,13 +119,43 @@ 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)
@@ -123,6 +177,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 +193,6 @@ module ERBLint
 
       @stats.processed_files[offenses_filename] ||= []
       @stats.processed_files[offenses_filename] |= offenses
-
-      file_content
     end
 
     def read_content(filename)
@@ -165,7 +222,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
@@ -262,7 +319,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,6 +336,18 @@ module ERBLint
           @options[:enabled_linters] = known_linter_names
         end
 
+        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|
@@ -302,6 +371,14 @@ module ERBLint
           @options[:autocorrect] = config
         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",
@@ -333,5 +410,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

@@ -12,7 +12,7 @@ module ERBLint
 
     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
 

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,7 +32,7 @@ module ERBLint
       end
     end
 
-    attr_reader :offenses
+    attr_reader :offenses, :config
 
     # Must be implemented by the concrete inheriting class.
     def initialize(file_loader, config)
@@ -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/linters/comment_syntax.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Detects comment syntax that isn't valid ERB.
+    class CommentSyntax < Linter
+      include LinterRegistry
+
+      def initialize(file_loader, config)
+        super
+      end
+
+      def run(processed_source)
+        file_content = processed_source.file_content
+        return if file_content.empty?
+
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          indicator_node, _, code_node, _ = *erb_node
+          next if code_node.nil?
+
+          indicator_node_str = indicator_node&.deconstruct&.last
+          next if indicator_node_str == "#"
+
+          code_node_str = code_node.deconstruct.last
+          next unless code_node_str.start_with?(" #")
+
+          range = find_range(erb_node, code_node_str)
+          source_range = processed_source.to_source_range(range)
+
+          correct_erb_tag = indicator_node_str == "=" ? "<%#=" : "<%#"
+
+          add_offense(
+            source_range,
+            <<~EOF.chomp
+              Bad ERB comment syntax. Should be #{correct_erb_tag} without a space between.
+              Leaving a space between ERB tags and the Ruby comment character can cause parser errors.
+            EOF
+          )
+        end
+      end
+
+      def find_range(node, str)
+        match = node.loc.source.match(Regexp.new(Regexp.quote(str.strip)))
+        return unless match
+
+        range_begin = match.begin(0) + node.loc.begin_pos
+        range_end   = match.end(0) + node.loc.begin_pos
+        (range_begin...range_end)
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/hard_coded_string.rb

@@ -17,7 +17,7 @@ module ERBLint
       ALLOWED_CORRECTORS = ["I18nCorrector", "RuboCop::Corrector::I18n::HardCodedString"]
 
       NON_TEXT_TAGS = Set.new(["script", "style", "xmp", "iframe", "noembed", "noframes", "listing"])
-      TEXT_NOT_ALLOWED = Set.new([
+      NO_TRANSLATION_NEEDED = Set.new([
         " ",
         "&",
         "<",
@@ -40,6 +40,7 @@ module ERBLint
         " ",
         " ",
         " ",
+        "×",
       ])
 
       class ConfigSchema < LinterConfig
@@ -96,7 +97,7 @@ module ERBLint
 
       def check_string?(str)
         string = str.gsub(/\s*/, "")
-        string.length > 1 && !TEXT_NOT_ALLOWED.include?(string)
+        string.length > 1 && !NO_TRANSLATION_NEEDED.include?(string)
       end
 
       def load_corrector

data/lib/erb_lint/linters/no_unused_disable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "erb_lint/utils/inline_configs"
+
+module ERBLint
+  module Linters
+    # Checks for unused disable comments.
+    class NoUnusedDisable < Linter
+      include LinterRegistry
+
+      def run(processed_source, offenses)
+        disabled_rules_and_line_number = {}
+
+        processed_source.source_buffer.source_lines.each_with_index do |line, index|
+          rule_disables = Utils::InlineConfigs.disabled_rules(line)
+          next unless rule_disables
+
+          rule_disables.split(",").each do |rule|
+            disabled_rules_and_line_number[rule.strip] =
+              (disabled_rules_and_line_number[rule.strip] ||= []).push(index + 1)
+          end
+        end
+
+        offenses.each do |offense|
+          rule_name = offense.linter.class.simple_name
+          line_numbers = disabled_rules_and_line_number[rule_name]
+          next unless line_numbers
+
+          line_numbers.reject do |line_number|
+            if (offense.source_range.line_span.first..offense.source_range.line_span.last).include?(line_number)
+              disabled_rules_and_line_number[rule_name].delete(line_number)
+            end
+          end
+        end
+
+        disabled_rules_and_line_number.each do |rule, line_numbers|
+          line_numbers.each do |line_number|
+            add_offense(processed_source.source_buffer.line_range(line_number),
+              "Unused erblint:disable comment for #{rule}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/rubocop.rb

@@ -13,6 +13,7 @@ module ERBLint
       class ConfigSchema < LinterConfig
         property :only, accepts: array_of?(String)
         property :rubocop_config, accepts: Hash, default: -> { {} }
+        property :config_file_path, accepts: String
       end
 
       self.config_schema = ConfigSchema
@@ -24,7 +25,8 @@ module ERBLint
       def initialize(file_loader, config)
         super
         @only_cops = @config.only
-        custom_config = config_from_hash(@config.rubocop_config)
+        custom_config = config_from_path(@config.config_file_path) if @config.config_file_path
+        custom_config ||= config_from_hash(@config.rubocop_config)
         @rubocop_config = ::RuboCop::ConfigLoader.merge_with_default(custom_config, "")
       end
 
@@ -129,11 +131,17 @@ module ERBLint
       end
 
       def rubocop_processed_source(content, filename)
-        ::RuboCop::ProcessedSource.new(
+        source = ::RuboCop::ProcessedSource.new(
           content,
           @rubocop_config.target_ruby_version,
           filename
         )
+        if ::RuboCop::Version::STRING.to_f >= 1.38
+          registry = RuboCop::Cop::Registry.global
+          source.registry = registry
+          source.config = @rubocop_config
+        end
+        source
       end
 
       def cop_classes
@@ -158,34 +166,13 @@ module ERBLint
       end
 
       def config_from_hash(hash)
-        inherit_from = hash&.delete("inherit_from")
-        resolve_inheritance(hash, inherit_from)
-
         tempfile_from(".erblint-rubocop", hash.to_yaml) do |tempfile|
-          ::RuboCop::ConfigLoader.load_file(tempfile.path)
+          config_from_path(tempfile.path)
         end
       end
 
-      def resolve_inheritance(hash, inherit_from)
-        base_configs(inherit_from)
-          .reverse_each do |base_config|
-          base_config.each do |k, v|
-            hash[k] = hash.key?(k) ? ::RuboCop::ConfigLoader.merge(v, hash[k]) : v if v.is_a?(Hash)
-          end
-        end
-      end
-
-      def base_configs(inherit_from)
-        regex = URI::DEFAULT_PARSER.make_regexp(["http", "https"])
-        configs = Array(inherit_from).compact.map do |base_name|
-          if base_name =~ /\A#{regex}\z/
-            ::RuboCop::ConfigLoader.load_file(::RuboCop::RemoteConfig.new(base_name, Dir.pwd))
-          else
-            config_from_hash(@file_loader.yaml(base_name))
-          end
-        end
-
-        configs.compact
+      def config_from_path(path)
+        ::RuboCop::ConfigLoader.load_file(path)
       end
 
       def add_offense(rubocop_offense, offense_range, correction, offset, bound_range)

data/lib/erb_lint/linters/rubocop_text.rb

@@ -10,6 +10,7 @@ module ERBLint
       class ConfigSchema < LinterConfig
         property :only, accepts: array_of?(String)
         property :rubocop_config, accepts: Hash
+        property :config_file_path, accepts: String
       end
 
       self.config_schema = ConfigSchema

data/lib/erb_lint/offense.rb

@@ -15,6 +15,11 @@ module ERBLint
       @message = message
       @context = context
       @severity = severity
+      @disabled = false
+    end
+
+    def to_cached_offense_hash
+      ERBLint::CachedOffense.new_from_offense(self).to_h
     end
 
     def inspect
@@ -40,8 +45,30 @@ module ERBLint
       line_range.begin
     end
 
+    attr_writer :disabled
+
+    def disabled?
+      @disabled
+    end
+
     def column
       source_range.column
     end
+
+    def simple_name
+      linter.class.simple_name
+    end
+
+    def last_line
+      source_range.last_line
+    end
+
+    def last_column
+      source_range.last_column
+    end
+
+    def length
+      source_range.length
+    end
   end
 end

data/lib/erb_lint/reporters/json_reporter.rb

@@ -56,14 +56,14 @@ module ERBLint
 
       def format_offense(offense)
         {
-          linter: offense.linter.class.simple_name,
+          linter: offense.simple_name,
           message: offense.message.to_s,
           location: {
             start_line: offense.line_number,
             start_column: offense.column,
-            last_line: offense.source_range.last_line,
-            last_column: offense.source_range.last_column,
-            length: offense.source_range.length,
+            last_line: offense.last_line,
+            last_column: offense.last_column,
+            length: offense.length,
           },
         }
       end

data/lib/erb_lint/reporters/junit_reporter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require "rexml/formatters/pretty"
+
+module ERBLint
+  module Reporters
+    class JunitReporter < Reporter
+      def preview; end
+
+      def show
+        xml = create_junit_xml
+        formatted_xml_string = StringIO.new
+        REXML::Formatters::Pretty.new.write(xml, formatted_xml_string)
+        puts formatted_xml_string.string
+      end
+
+      private
+
+      CONTEXT = {
+        prologue_quote: :quote,
+        attribute_quote: :quote,
+      }
+
+      def create_junit_xml
+        # create prologue
+        xml = REXML::Document.new(nil, CONTEXT)
+        xml << REXML::XMLDecl.new("1.0", "UTF-8")
+
+        xml.add_element(create_testsuite_element)
+
+        xml
+      end
+
+      def create_testsuite_element
+        tests = stats.processed_files.size
+        failures = stats.found
+        testsuite_element = REXML::Element.new("testsuite", nil, CONTEXT)
+        testsuite_element.add_attribute("name", "erblint")
+        testsuite_element.add_attribute("tests", tests.to_s)
+        testsuite_element.add_attribute("failures", failures.to_s)
+
+        testsuite_element.add_element(create_properties)
+
+        processed_files.each do |filename, offenses|
+          if offenses.empty?
+            testcase_element = REXML::Element.new("testcase", nil, CONTEXT)
+            testcase_element.add_attribute("name", filename.to_s)
+            testcase_element.add_attribute("file", filename.to_s)
+
+            testsuite_element.add_element(testcase_element)
+          end
+
+          offenses.each do |offense|
+            testsuite_element.add_element(create_testcase(filename, offense))
+          end
+        end
+
+        testsuite_element
+      end
+
+      def create_properties
+        properties_element = REXML::Element.new("properties", nil, CONTEXT)
+
+        [
+          ["erb_lint_version", ERBLint::VERSION],
+          ["ruby_engine", RUBY_ENGINE],
+          ["ruby_version", RUBY_VERSION],
+          ["ruby_patchlevel", RUBY_PATCHLEVEL.to_s],
+          ["ruby_platform", RUBY_PLATFORM],
+        ].each do |property_attribute|
+          properties_element.add_element(create_property(*property_attribute))
+        end
+
+        properties_element
+      end
+
+      def create_property(name, value)
+        property_element = REXML::Element.new("property")
+        property_element.add_attribute("name", name)
+        property_element.add_attribute("value", value)
+
+        property_element
+      end
+
+      def create_testcase(filename, offense)
+        testcase_element = REXML::Element.new("testcase", nil, CONTEXT)
+        testcase_element.add_attribute("name", filename.to_s)
+        testcase_element.add_attribute("file", filename.to_s)
+        testcase_element.add_attribute("lineno", offense.line_number.to_s)
+
+        testcase_element.add_element(create_failure(filename, offense))
+
+        testcase_element
+      end
+
+      def create_failure(filename, offense)
+        message = offense.message
+        type = offense.simple_name
+
+        failure_element = REXML::Element.new("failure", nil, CONTEXT)
+        failure_element.add_attribute("message", "#{type}: #{message}")
+        failure_element.add_attribute("type", type.to_s)
+
+        cdata_element = REXML::CData.new("#{type}: #{message} at #{filename}:#{offense.line_number}:#{offense.column}")
+        failure_element.add_text(cdata_element)
+
+        failure_element
+      end
+    end
+  end
+end

data/lib/erb_lint/runner.rb

@@ -5,15 +5,19 @@ module ERBLint
   class Runner
     attr_reader :offenses
 
-    def initialize(file_loader, config)
+    def initialize(file_loader, config, disable_inline_configs = false)
       @file_loader = file_loader
       @config = config || RunnerConfig.default
       raise ArgumentError, "expect `config` to be a RunnerConfig instance" unless @config.is_a?(RunnerConfig)
 
-      linter_classes = LinterRegistry.linters.select { |klass| @config.for_linter(klass).enabled? }
+      linter_classes = LinterRegistry.linters.select do |klass|
+        @config.for_linter(klass).enabled? && klass != ERBLint::Linters::NoUnusedDisable
+      end
       @linters = linter_classes.map do |linter_class|
         linter_class.new(@file_loader, @config.for_linter(linter_class))
       end
+      @no_unused_disable = nil
+      @disable_inline_configs = disable_inline_configs
       @offenses = []
     end
 
@@ -21,14 +25,43 @@ module ERBLint
       @linters
         .reject { |linter| linter.excludes_file?(processed_source.filename) }
         .each do |linter|
-        linter.run(processed_source)
+        linter.run_and_update_offense_status(processed_source, enable_inline_configs?)
         @offenses.concat(linter.offenses)
       end
+      report_unused_disable(processed_source)
+      @offenses = @offenses.reject(&:disabled?)
     end
 
     def clear_offenses
       @offenses = []
       @linters.each(&:clear_offenses)
+      @no_unused_disable&.clear_offenses
+    end
+
+    def restore_offenses(offenses)
+      @offenses.concat(offenses)
+    end
+
+    private
+
+    def enable_inline_configs?
+      !@disable_inline_configs
+    end
+
+    def no_unused_disable_enabled?
+      LinterRegistry.linters.include?(ERBLint::Linters::NoUnusedDisable) &&
+        @config.for_linter(ERBLint::Linters::NoUnusedDisable).enabled?
+    end
+
+    def report_unused_disable(processed_source)
+      if no_unused_disable_enabled? && enable_inline_configs?
+        @no_unused_disable = ERBLint::Linters::NoUnusedDisable.new(
+          @file_loader,
+          @config.for_linter(ERBLint::Linters::NoUnusedDisable)
+        )
+        @no_unused_disable.run(processed_source, @offenses)
+        @offenses.concat(@no_unused_disable.offenses)
+      end
     end
   end
 end

data/lib/erb_lint/runner_config.rb

@@ -63,6 +63,7 @@ module ERBLint
             SpaceInHtmlTag: { enabled: default_enabled },
             TrailingWhitespace: { enabled: default_enabled },
             RequireInputAutocomplete: { enabled: default_enabled },
+            CommentSyntax: { enabled: default_enabled },
           },
         )
       end
@@ -82,7 +83,7 @@ module ERBLint
     def config_hash_for_linter(klass_name)
       config_hash = linters_config[klass_name] || {}
       config_hash["exclude"] ||= []
-      config_hash["exclude"].concat(global_exclude) if config_hash["exclude"].is_a?(Array)
+      config_hash["exclude"].concat(global_exclude).uniq! if config_hash["exclude"].is_a?(Array)
       config_hash
     end
 

data/lib/erb_lint/utils/inline_configs.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Utils
+    class InlineConfigs
+      def self.rule_disable_comment_for_lines?(rule, lines)
+        lines.match?(/# erblint:disable (?<rules>.*#{rule}).*/)
+      end
+
+      def self.disabled_rules(line)
+        line.match(/# erblint:disable (?<rules>.*) %>/)&.named_captures&.fetch("rules")
+      end
+    end
+  end
+end

data/lib/erb_lint/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ERBLint
-  VERSION = "0.1.3"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Justin Chan
+- Shopify Developers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-16 00:00:00.000000000 Z
+date: 2023-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -26,32 +27,18 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: better_html
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-- !ruby/object:Gem::Dependency
-  name: html_tokenizer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +139,7 @@ dependencies:
         version: '0'
 description: ERB Linter tool.
 email:
-- justin.the.c@gmail.com
+- ruby@shopify.com
 executables:
 - erblint
 extensions: []
@@ -161,6 +148,8 @@ files:
 - exe/erblint
 - lib/erb_lint.rb
 - lib/erb_lint/all.rb
+- lib/erb_lint/cache.rb
+- lib/erb_lint/cached_offense.rb
 - lib/erb_lint/cli.rb
 - lib/erb_lint/corrector.rb
 - lib/erb_lint/file_loader.rb
@@ -169,12 +158,14 @@ files:
 - lib/erb_lint/linter_registry.rb
 - lib/erb_lint/linters/allowed_script_type.rb
 - lib/erb_lint/linters/closing_erb_tag_indent.rb
+- lib/erb_lint/linters/comment_syntax.rb
 - lib/erb_lint/linters/deprecated_classes.rb
 - lib/erb_lint/linters/erb_safety.rb
 - lib/erb_lint/linters/extra_newline.rb
 - lib/erb_lint/linters/final_newline.rb
 - lib/erb_lint/linters/hard_coded_string.rb
 - lib/erb_lint/linters/no_javascript_tag_helper.rb
+- lib/erb_lint/linters/no_unused_disable.rb
 - lib/erb_lint/linters/parser_errors.rb
 - lib/erb_lint/linters/partial_instance_variable.rb
 - lib/erb_lint/linters/require_input_autocomplete.rb
@@ -192,12 +183,14 @@ files:
 - lib/erb_lint/reporter.rb
 - lib/erb_lint/reporters/compact_reporter.rb
 - lib/erb_lint/reporters/json_reporter.rb
+- lib/erb_lint/reporters/junit_reporter.rb
 - lib/erb_lint/reporters/multiline_reporter.rb
 - lib/erb_lint/runner.rb
 - lib/erb_lint/runner_config.rb
 - lib/erb_lint/runner_config_resolver.rb
 - lib/erb_lint/stats.rb
 - lib/erb_lint/utils/block_map.rb
+- lib/erb_lint/utils/inline_configs.rb
 - lib/erb_lint/utils/offset_corrector.rb
 - lib/erb_lint/utils/ruby_to_erb.rb
 - lib/erb_lint/utils/severity_levels.rb
@@ -215,14 +208,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.18
 signing_key: 
 specification_version: 4
 summary: ERB lint tool