haml_lint 0.73.0 → 0.75.0

data/lib/haml_lint/linter.rb

@@ -56,13 +56,14 @@ module HamlLint
     end
 
     # Runs the linter against the given Haml document, raises if the file cannot be processed due to
-    # Syntax or HAML-Lint internal errors. (For testing purposes)
+    # Syntax or Haml-Lint internal errors. (For testing purposes)
     #
     # @param document [HamlLint::Document]
     def run_or_raise(document, autocorrect: nil)
       @document = document
       @lints = []
       @autocorrect = autocorrect
+      reset_autocorrect_state
       visit(document.tree)
       @lints
     end
@@ -85,6 +86,30 @@ module HamlLint
       self.class.supports_autocorrect?
     end
 
+    # Returns whether this linter's autocorrect is safe. Defaults to true (safe)
+    # unless the linter declares otherwise via `autocorrect_safe(false)`.
+    #
+    # @return [Boolean]
+    def self.autocorrect_safe?
+      @autocorrect_safe != false
+    end
+
+    # The autocorrect ordering priority for this linter. During autocorrect,
+    # linters with a lower priority run first and higher priority run later,
+    # against the same (already mutated) document. Linters with the same priority
+    # keep their default (alphabetical) order.
+    #
+    # Called with an argument (e.g. `autocorrect_priority(1)`) in a linter's
+    # top-level scope, it sets the priority; called with no argument it reads it.
+    # The default, when never set, is 0.
+    #
+    # @param value [Integer, nil] the new priority, or nil to read the current one
+    # @return [Integer]
+    def self.autocorrect_priority(value = nil)
+      @autocorrect_priority = value unless value.nil?
+      @autocorrect_priority || 0
+    end
+
     private
 
     attr_reader :config, :document
@@ -97,6 +122,92 @@ module HamlLint
       @supports_autocorrect = value
     end
 
+    # Linters can call autocorrect_safe(false) in their top-level scope to declare that their
+    # autocorrect is unsafe, meaning it only runs under `--auto-correct-all` (`:all`).
+    # The default, when not called, is safe.
+    #
+    # @params value [Boolean] The new value for autocorrect_safe
+    private_class_method def self.autocorrect_safe(value)
+      @autocorrect_safe = value
+    end
+
+    # Resets the per-run autocorrect bookkeeping. Linter instances are reused
+    # across files, so subclasses that accumulate extra autocorrect state during
+    # a traversal (e.g. a list of lines to merge or delete) must override this,
+    # calling `super`, to clear that state between files. Otherwise corrections
+    # from one file leak into the next.
+    def reset_autocorrect_state
+      @autocorrected_lines = nil
+      @autocorrect_changed = false
+    end
+
+    # Whether the linter is currently allowed to apply autocorrections, given the active
+    # autocorrect mode and this linter's declared safety:
+    #
+    #   * safe linters correct under both `:safe` and `:all`;
+    #   * unsafe linters correct only under `:all`;
+    #   * with no mode (`nil`) nothing is corrected (detection only).
+    #
+    # @return [Boolean]
+    def autocorrect?
+      case @autocorrect
+      when :all
+        true
+      when :safe
+        self.class.autocorrect_safe?
+      else
+        false
+      end
+    end
+
+    # Applies a corrected, full-document source to the document through the single
+    # mutation path (`Document#change_source`), but only when the safety gate permits.
+    # No-ops otherwise; `change_source` itself also no-ops when the source is unchanged.
+    #
+    # @param new_source [String] the corrected Haml source
+    def apply_autocorrect(new_source)
+      return unless autocorrect?
+      document.change_source(new_source)
+    end
+
+    # Lazily-initialized working copy of the document's source lines, used to
+    # accumulate line-level corrections during a single tree traversal. Editing
+    # this copy (rather than calling `apply_autocorrect` per node) avoids
+    # reparsing the document mid-walk, which would invalidate the tree being
+    # visited.
+    #
+    # @return [Array<String>]
+    def autocorrected_lines
+      @autocorrected_lines ||= document.source_lines.dup
+    end
+
+    # Replaces a single source line (0-indexed) in the working copy, but only
+    # when autocorrect is permitted and the new text actually differs.
+    #
+    # @param index [Integer] the 0-indexed line to replace
+    # @param new_text [String] the corrected line
+    # @return [Boolean] true if a change was recorded, false otherwise
+    def correct_line(index, new_text)
+      return false unless autocorrect?
+      return false if autocorrected_lines[index] == new_text
+
+      autocorrected_lines[index] = new_text
+      @autocorrect_changed = true
+    end
+
+    # Flushes any corrections accumulated via `correct_line` through the single
+    # mutation path, once, after the whole tree has been visited. Defined on the
+    # base so per-node linters need no boilerplate; no-ops for linters that never
+    # accumulated a change (including those that apply within `visit_root`).
+    #
+    # NOTE: a linter that overrides `after_visit_root` must call `super`, or
+    # accumulated corrections will not be applied.
+    def after_visit_root(_node)
+      return unless @autocorrect_changed
+
+      apply_autocorrect(autocorrected_lines.join("\n"))
+    end
+
     # Record a lint for reporting back to the user.
     #
     # @param node_or_line [#line] line number or node to extract the line number from

data/lib/haml_lint/node_transformer.rb

@@ -4,7 +4,7 @@ module HamlLint
   # Responsible for transforming {Haml::Parser::ParseNode} objects into
   # corresponding {HamlLint::Tree::Node} objects.
   #
-  # The parse tree generated by HAML has a number of strange cases where certain
+  # The parse tree generated by Haml has a number of strange cases where certain
   # types of nodes are created that don't necessarily correspond to what one
   # would expect. This class is intended to isolate and handle these cases so
   # that linters don't have to deal with them.
@@ -16,7 +16,7 @@ module HamlLint
       @document = document
     end
 
-    # Converts the given HAML parse node into its corresponding HAML-Lint parse
+    # Converts the given Haml parse node into its corresponding Haml-Lint parse
     # node.
     #
     # @param haml_node [Haml::Parser::ParseNode]

data/lib/haml_lint/reporter/disabled_config_reporter.rb

@@ -5,10 +5,12 @@ require_relative 'progress_reporter'
 module HamlLint
   # Outputs a YAML configuration file based on existing violations.
   class Reporter::DisabledConfigReporter < Reporter::ProgressReporter
-    HEADING =
+    DEFAULT_EXCLUDE_LIMIT = 15
+
+    HEADING_TEMPLATE =
       ['# This configuration was generated by',
-       '# `haml-lint --auto-gen-config`',
-       "# on #{Time.now} using Haml-Lint version #{HamlLint::VERSION}.",
+       '# `%<command>s`',
+       '# on %<timestamp>s using Haml-Lint version %<version>s.',
        '# The point is for the user to remove these configuration records',
        '# one by one as the lints are removed from the code base.',
        '# Note that changes in the inspected code, or installation of new',
@@ -25,11 +27,12 @@ module HamlLint
     # Create the reporter that will display the report and write the config.
     #
     # @param _log [HamlLint::Logger]
-    def initialize(log, limit: 15)
+    def initialize(log, limit: DEFAULT_EXCLUDE_LIMIT, options: {})
       super(log)
       @linters_with_lints = Hash.new { |hash, key| hash[key] = [] }
       @linters_lint_count = Hash.new(0)
       @exclude_limit = limit
+      @options = options
     end
 
     # A hash of linters with the files that have that type of lint.
@@ -81,12 +84,30 @@ module HamlLint
 
     private
 
+    # Reconstructs the CLI command used to generate this config.
+    #
+    # @return [String] the command string
+    def command
+      cmd = "#{HamlLint::APP_NAME} --auto-gen-config"
+      if @options[:auto_gen_exclude_limit]
+        cmd += " --auto-gen-exclude-limit #{@options[:auto_gen_exclude_limit]}"
+      end
+      cmd
+    end
+
+    # The heading comment for the generated config file.
+    #
+    # @return [String]
+    def heading
+      format(HEADING_TEMPLATE, command: command, timestamp: Time.now, version: HamlLint::VERSION)
+    end
+
     # The contents of the generated configuration file based on captured lint.
     #
     # @return [String] a Yaml-formatted configuration file's contents
     def config_file_contents
       output = []
-      output << HEADING
+      output << heading
       output << 'linters:' if linters_with_lints.any?
       linters_with_lints.sort.each do |linter, files|
         output << generate_config_for_linter(linter, files)

data/lib/haml_lint/reporter/github_reporter.rb

@@ -3,16 +3,16 @@
 module HamlLint
   # Outputs GitHub workflow commands for GitHub check annotations when run within GitHub actions.
   class Reporter::GithubReporter < Reporter
+    # Characters to escape within a command message.
     ESCAPE_MAP = { '%' => '%25', "\n" => '%0A', "\r" => '%0D' }.freeze
+    # Property values also escape the `:` and `,` that delimit the command.
+    PROPERTY_ESCAPE_MAP = ESCAPE_MAP.merge(':' => '%3A', ',' => '%2C').freeze
 
     include Reporter::Utils
 
     def added_lint(lint, report)
-      if lint.severity >= report.fail_level
-        print_workflow_command(lint: lint)
-      else
-        print_workflow_command(severity: 'warning', lint: lint)
-      end
+      severity = lint.severity >= report.fail_level ? 'error' : 'warning'
+      print_workflow_command(lint, severity)
     end
 
     def display_report(report)
@@ -21,12 +21,30 @@ module HamlLint
 
     private
 
-    def print_workflow_command(lint:, severity: 'error')
-      log.log "::#{severity} file=#{lint.filename},line=#{lint.line}::#{github_escape(lint.message)}"
+    def print_workflow_command(lint, severity)
+      log.log "::#{severity} file=#{github_escape_property(lint.filename)}," \
+              "line=#{lint.line},title=#{github_escape_property(annotation_title(lint))}" \
+              "::#{github_escape(annotation_message(lint))}"
+    end
+
+    # Annotation title, naming the linter that produced the lint when known.
+    def annotation_title(lint)
+      lint.linter ? "haml-lint #{lint.linter.name}" : 'haml-lint'
+    end
+
+    # Message body, prefixed with the location and linter so it stays useful in the plain log.
+    def annotation_message(lint)
+      location = "#{lint.filename}:#{lint.line}"
+      location += " #{lint.linter.name}:" if lint.linter
+      "#{location} #{lint.message}"
     end
 
     def github_escape(string)
-      string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+      string.to_s.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+    end
+
+    def github_escape_property(string)
+      string.to_s.gsub(Regexp.union(PROPERTY_ESCAPE_MAP.keys), PROPERTY_ESCAPE_MAP)
     end
   end
 end

data/lib/haml_lint/ruby_extraction/base_chunk.rb

@@ -2,13 +2,13 @@
 
 module HamlLint::RubyExtraction
   # This is the base class for all of the Chunks of HamlLint::RubyExtraction.
-  # A Chunk represents a part of the HAML file that HamlLint::Linter::RuboCop
+  # A Chunk represents a part of the Haml file that HamlLint::Linter::RuboCop
   # is processing and will insert some Ruby code in a file passed to RuboCop.
   #
-  # There are chunks for most HAML concepts, even if they don't represent Ruby
+  # There are chunks for most Haml concepts, even if they don't represent Ruby
   # code. For example, there is a chunk that represents a `%div` tag, which
   # uses a `begin` in the generated Ruby to add indentation for the children
-  # of the %div in the Ruby file just like there is in the HAML file.
+  # of the %div in the Ruby file just like there is in the Haml file.
   class BaseChunk
     COMMA_CHANGES_LINES = true
 

data/lib/haml_lint/ruby_extraction/chunk_extractor.rb

@@ -4,7 +4,7 @@
 module HamlLint::RubyExtraction
   # Extracts "chunks" of the haml file into instances of subclasses of HamlLint::RubyExtraction::BaseChunk.
   #
-  # This is the first step of generating Ruby code from a HAML file to then be processed by RuboCop.
+  # This is the first step of generating Ruby code from a Haml file to then be processed by RuboCop.
   # See HamlLint::RubyExtraction::BaseChunk for more details.
   class ChunkExtractor
     include HamlLint::HamlVisitor
@@ -17,7 +17,7 @@ module HamlLint::RubyExtraction
                              ::Haml::Parser.new('', {})
                            end
 
-    # HAML strips newlines when handling multi-line statements (using pipes or trailing comma)
+    # Haml strips newlines when handling multi-line statements (using pipes or trailing comma)
     # We don't. So the regex must be fixed to correctly detect the start of the string.
     BLOCK_KEYWORD_REGEX = Regexp.new(Haml::Parser::BLOCK_KEYWORD_REGEX.source.sub('^', '\A'))
 
@@ -124,7 +124,7 @@ module HamlLint::RubyExtraction
     def visit_script(node, &block)
       raw_first_line = @original_haml_lines[node.line - 1]
 
-      # ==, !, !==, &, &== means interpolation (was needed before HAML 2.2... it's still supported)
+      # ==, !, !==, &, &== means interpolation (was needed before Haml 2.2... it's still supported)
       # =, !=, &= mean actual ruby code is coming
       # Anything else is interpolation
       # The regex lists the case for Ruby Code. The 3 cases and making sure they are not followed by another = sign
@@ -169,20 +169,20 @@ module HamlLint::RubyExtraction
           prev_chunk.node == node.parent
         # When an outputting script is nested under another outputting script,
         # we want to block them from being merged together by rubocop, because
-        # this doesn't make sense in HAML.
+        # this doesn't make sense in Haml.
         # Example:
         #   = if this_is_short
         #     = this_is_short_too
         # Could become (after RuboCop):
         #   HL.out = (HL.out = this_is_short_too if this_is_short)
-        # Or in (broken) HAML style:
+        # Or in (broken) Haml style:
         #   = this_is_short_too = if this_is_short
         # By forcing this to start a chunk, there will be extra placeholders which
         # blocks rubocop from merging the lines.
         must_start_chunk = true
       elsif script_prefix != '='
         # In the few cases where &= and != are used to start the script,
-        # We need to remember and put it back in the final HAML. Fusing scripts together
+        # We need to remember and put it back in the final Haml. Fusing scripts together
         # would make that basically impossible. Instead, a script has a "first_output_prefix"
         # field for this specific case
         must_start_chunk = true
@@ -300,7 +300,13 @@ module HamlLint::RubyExtraction
       end
 
       if attributes_code&.start_with?('{')
-        # Looks like the .foo(bar = 123) case. Ignoring.
+        # HTML-style (parens) attributes, e.g. %div(foo=foo), arrive as a synthesized hash string
+        # like '{"foo" => foo,}'. That text isn't present verbatim in the Haml, so we can't map
+        # RuboCop corrections back and intentionally don't autocorrect it. We still extract the
+        # attribute *values* as a non-correctable chunk so RuboCop sees variables used here;
+        # otherwise they look unused (false Lint/UselessAssignment, plus unsafe autocorrect that
+        # removes the assignment). See issue #648.
+        add_html_attributes_value_usage(node, attributes_code, indent: indent)
         attributes_code = nil
       end
 
@@ -345,6 +351,22 @@ module HamlLint::RubyExtraction
       final_line_index
     end
 
+    # For HTML-style (parens) attributes, adds the attribute value expressions as a
+    # non-autocorrectable chunk purely so RuboCop counts the variables/methods used there.
+    def add_html_attributes_value_usage(node, attributes_code, indent:)
+      ast = parse_ruby(attributes_code)
+      return unless ast&.type == :hash
+
+      value_sources = ast.children.filter_map do |pair|
+        next unless pair.type == :pair
+        pair.children[1]&.source
+      end
+      return if value_sources.empty?
+
+      lines = value_sources.map { |value| "#{' ' * indent}#{script_output_prefix}#{value}" }
+      @ruby_chunks << AdHocChunk.new(node, lines)
+    end
+
     # Visiting the script besides tag. The part to the right of the equal sign of
     # lines looking like `  %div= foo(bar)`
     def visit_tag_script(node, line_index:, indent:)
@@ -384,7 +406,7 @@ module HamlLint::RubyExtraction
       end
     end
 
-    # Visiting a HAML filter. Lines looking like `  :javascript` and the following lines
+    # Visiting a Haml filter. Lines looking like `  :javascript` and the following lines
     # that are nested.
     def visit_filter(node)
       # For unknown reasons, haml doesn't escape interpolations in filters.
@@ -392,8 +414,10 @@ module HamlLint::RubyExtraction
       filter_name_indent = @original_haml_lines[node.line - 1].index(/\S/)
       if node.filter_type == 'ruby'
         # The indentation in node.text is normalized, so that at least one line
-        # is indented by 0.
-        lines = node.text.split("\n")
+        # is indented by 0. Split("\n", -1) + pop keeps trailing blank lines (plain split drops them),
+        # which the end marker needs so it doesn't land right after the last code line.
+        lines = node.text.split("\n", -1)
+        lines.pop
         lines.map! do |line|
           if !/\S/.match?(line)
             # whitespace or empty
@@ -497,14 +521,14 @@ module HamlLint::RubyExtraction
     # The first and last lines may not be the complete lines from the Haml, only the Ruby parts
     # and the indentation between the first and last list.
 
-    # HAML transforms the ruby code in many ways as it parses a document. Often removing lines and/or
+    # Haml transforms the ruby code in many ways as it parses a document. Often removing lines and/or
     # indentation. This is quite annoying for us since we want the exact layout of the code to analyze it.
     #
     # This function receives the code as haml provides it and the line where it starts. It returns
     # the actual code as it is in the haml file, keeping breaks and indentation for the following lines.
     # In addition, the start position of the code in the first line.
     #
-    # The rules for handling multiline code in HAML are as follow:
+    # The rules for handling multiline code in Haml are as follow:
     # * if the line being processed ends with a space and a pipe, then append to the line (without
     #   newlines) every following lines that also end with a space and a pipe. This means the last line of
     #   the "block" also needs a pipe at the end.
@@ -703,7 +727,7 @@ module HamlLint::RubyExtraction
 
     LOOP_KEYWORDS = %w[for until while].freeze
     def self.block_keyword(code)
-      # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
+      # Need to handle 'for'/'while' since regex stolen from Haml parser doesn't
       if (keyword = code[/\A\s*([^\s]+)\s+/, 1]) && LOOP_KEYWORDS.include?(keyword)
         return keyword
       end

data/lib/haml_lint/ruby_extraction/coordinator.rb

@@ -9,7 +9,7 @@ module HamlLint::RubyExtraction
   # * Preprocess the chunks to cleanup/fuse some of them.
   # * Generates the extracted ruby code from the Chunks.
   # * Handles the markers (see below)
-  # * Use the chunks to transfer corrections from corrected Ruby code back to HAML
+  # * Use the chunks to transfer corrections from corrected Ruby code back to Haml
   #
   # The generated Ruby code uses markers to wrap around the Ruby code from the chunks.
   # Those markers look like function calls, like: `haml_lint_marker_1`, so are valid ruby.
@@ -22,7 +22,7 @@ module HamlLint::RubyExtraction
     # @return [String] The prefix used for markers in the Ruby code
     attr_reader :marker_prefix
 
-    # @return [Array<String>] The ruby lines after extraction from HAML (before RuboCop)
+    # @return [Array<String>] The ruby lines after extraction from Haml (before RuboCop)
     attr_reader :assembled_ruby_lines
 
     # @return [Array<String>] The ruby lines after correction by RuboCop

data/lib/haml_lint/ruby_extraction/implicit_end_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # HAML adds a `end` when code gets outdented. We need to add that to the Ruby too, this
+  # Haml adds a `end` when code gets outdented. We need to add that to the Ruby too, this
   # is the chunk for it.
   # However:
   # * we can't apply fixes to it, so there are no markers

data/lib/haml_lint/ruby_extraction/non_ruby_filter_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # Chunk for dealing with every HAML filter other than `:ruby`
+  # Chunk for dealing with every Haml filter other than `:ruby`
   # The generated Ruby for these is just a HEREDOC, so interpolation is corrected at
   # the same time by RuboCop.
   class NonRubyFilterChunk < BaseChunk

data/lib/haml_lint/ruby_extraction/placeholder_marker_chunk.rb

@@ -5,7 +5,7 @@ module HamlLint::RubyExtraction
   # transfer the corrections it receives to the indentation of the associated lines.
   #
   # Also used so that Rubocop doesn't think that there is nothing in `if` and other such structures,
-  # so that it does corrections that make sense for the HAML.
+  # so that it does corrections that make sense for the Haml.
   class PlaceholderMarkerChunk < BaseChunk
     def initialize(node, marker_name, indent:, nb_lines: 1, **kwargs)
       @marker_name = marker_name

data/lib/haml_lint/ruby_extraction/script_chunk.rb

@@ -18,7 +18,7 @@ module HamlLint::RubyExtraction
     attr_reader :must_start_chunk
 
     # @return [Array<Integer>] Line indexes to ignore when building the source_map. For examples,
-    #   implicit `end` are on their own line in the Ruby file, but in the HAML, they are absent.
+    #   implicit `end` are on their own line in the Ruby file, but in the Haml, they are absent.
     attr_reader :skip_line_indexes_in_source_map
 
     # @return [HamlLint::RubyExtraction::BaseChunk] The previous chunk can affect how

data/lib/haml_lint/runner.rb

@@ -23,7 +23,8 @@ module HamlLint
     def run(options = {})
       @config = load_applicable_config(options)
       @sources = extract_applicable_sources(config, options)
-      @linter_selector = HamlLint::LinterSelector.new(config, options)
+      @options = options
+      @linter_selector = build_linter_selector
       @fail_fast = options.fetch(:fail_fast, false)
       @cache = {}
       @autocorrect = options[:autocorrect]
@@ -61,6 +62,31 @@ module HamlLint
     # @return [HamlLint::LinterSelector]
     attr_reader :linter_selector
 
+    PARALLEL_LINTER_SELECTOR_THREAD_KEY = :haml_lint_runner_parallel_linter_selectors
+
+    # Returns a fresh selector for this run.
+    #
+    # LinterSelector memoizes linter instances, and linters mutate instance
+    # state while processing a document. JRuby runs Parallel.map in threads, so
+    # parallel jobs must not share a selector.
+    #
+    # @return [HamlLint::LinterSelector]
+    def build_linter_selector
+      HamlLint::LinterSelector.new(config, @options)
+    end
+
+    # Returns a selector scoped to the current parallel worker.
+    #
+    # MRI runs Parallel.map in forked processes, so each worker can safely reuse
+    # its own linter instances. JRuby runs Parallel.map in threads, so this must
+    # be isolated per thread to avoid sharing mutable linter state.
+    #
+    # @return [HamlLint::LinterSelector]
+    def parallel_linter_selector
+      selectors = Thread.current[PARALLEL_LINTER_SELECTOR_THREAD_KEY] ||= {}.compare_by_identity
+      selectors[self] ||= build_linter_selector
+    end
+
     # Returns the {HamlLint::Configuration} that should be used given the
     # specified options.
     #
@@ -89,7 +115,6 @@ module HamlLint
       begin
         document = HamlLint::Document.new source.contents, file: source.path,
                                                            config: config,
-                                                           file_on_disk: !source.stdin?,
                                                            write_to_stdout: @autocorrect_stdout
       rescue HamlLint::Exceptions::ParseError => e
         return [HamlLint::Lint.new(HamlLint::Linter::Syntax.new(config), source.path,
@@ -122,6 +147,9 @@ module HamlLint
       lint_arrays = []
 
       autocorrecting_linters = linters.select(&:supports_autocorrect?)
+                                      .each_with_index
+                                      .sort_by { |linter, index| [linter.class.autocorrect_priority, index] }
+                                      .map(&:first)
       lint_arrays << autocorrecting_linters.map do |linter|
         linter.run(document, autocorrect: @autocorrect)
       end
@@ -191,7 +219,7 @@ module HamlLint
     # @return [void]
     def warm_cache
       results = Parallel.map(sources) do |source|
-        lints = collect_lints(source, linter_selector, config)
+        lints = collect_lints(source, parallel_linter_selector, config)
         [source.path, lints]
       end
       @cache = results.to_h

data/lib/haml_lint/source.rb

@@ -13,17 +13,13 @@ module HamlLint
     # @param [IO] io
     def initialize(path: nil, io: nil)
       @path = path
+      @file_path = File.expand_path(path) if path
       @io = io
     end
 
     # @return [String] Contents of the given IO object.
     def contents
-      @contents ||= @io&.read || File.read(path)
-    end
-
-    # @return [boolean] true if we're reading from stdin rather than a file path
-    def stdin?
-      !@io.nil?
+      @contents ||= @io&.read || File.read(@file_path)
     end
   end
 end

data/lib/haml_lint/spec/matchers/report_lint.rb

@@ -65,7 +65,7 @@ module HamlLint
             (expected_severity ? " with severity '#{expected_severity}'" : '')
         end
 
-        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists
+        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists,Naming
                        expected_corrected)
           if expected_line
             has_expected_line_lints?(linter,
@@ -83,7 +83,7 @@ module HamlLint
           end
         end
 
-        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists
+        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists,Naming
                                      expected_line,
                                      count,
                                      expected_message,

data/lib/haml_lint/tree/comment_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a visible XHTML comment in a HAML document.
+  # Represents a visible XHTML comment in a Haml document.
   class CommentNode < Node
   end
 end

data/lib/haml_lint/tree/doctype_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a doctype definition for a HAML document.
+  # Represents a doctype definition for a Haml document.
   class DoctypeNode < Node
   end
 end

data/lib/haml_lint/tree/filter_node.rb

@@ -9,7 +9,7 @@ module HamlLint::Tree
     end
 
     def text
-      # Seems HAML strips the starting blank lines... without them, line numbers become offset,
+      # Seems Haml strips the starting blank lines... without them, line numbers become offset,
       # breaking the source_map and auto-correct
 
       nb_blank_lines = 0
@@ -17,5 +17,18 @@ module HamlLint::Tree
 
       "#{"\n" * nb_blank_lines}#{super}"
     end
+
+    # The line numbers that are contained within the node.
+    #
+    # Unlike most nodes, a filter's content begins on the line *after* the
+    # `:filtername` declaration, so the span runs from the declaration line
+    # through all of the indented content lines.
+    #
+    # @return [Range]
+    def line_numbers
+      return super if lines.empty?
+
+      (line..(line + lines.count))
+    end
   end
 end

data/lib/haml_lint/tree/haml_comment_node.rb

@@ -3,7 +3,7 @@
 require_relative '../directive'
 
 module HamlLint::Tree
-  # Represents a HAML comment node.
+  # Represents a Haml comment node.
   class HamlCommentNode < Node
     def directives
       directives = super
@@ -28,7 +28,7 @@ module HamlLint::Tree
     # Returns whether this comment contains a `locals` directive.
     #
     # @return [Boolean]
-    def is_strict_locals?
+    def is_strict_locals? # rubocop:disable Naming
       text.lstrip.start_with?('locals:')
     end