simplecov 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 774f2590be4fc8efd720e8c61b8e0678b50794dbc8c881c5872c51ac7b318c08
-  data.tar.gz: a67efdab2414345fa195aea9015d5cfc5128c452be20888edc1814c05fff98e0
+  metadata.gz: c96bd7c97b97593cd5f90f20315a755ddbb9e25bd2b43ca54cc19fdf6c0540ac
+  data.tar.gz: 23b1b6392bfcf9119b2a5c575adf54568c47ef2c5838e11cbb77bffd72d61666
 SHA512:
-  metadata.gz: 32062ccc9c83227f868788d5f2a0fa43eda93e8f714ed4ffe068fea3ac05ee7dd21f26d4234903da7679a6c72325955282000055892deaabf4a0703f924f06ca
-  data.tar.gz: c4a9a68bfbed7bc9c38de07afd89bedfefd3ea1ff1ee2b5294701c588c6cca7a10ae571313e0d836478045c07fcee81e4a1dc20c258d92e13a46f1e044c4d6d5
+  metadata.gz: 3fb49f89386b147aa212d3b8814fb4afef021f394a2231c1e0649b5c35ea4e4ed14ba96cb9b8deacf1d6825629f56c55f900e3decaea287bff81f8a05d12b83f
+  data.tar.gz: a57ae0348b43869e6084866da885132c118acf88d83d967992d78aec222f8b6fab1ff6ab6572d3cc1ecdb2e701650aac9837ba45e963e64312ca8d3cdaaad1bd

data/README.md

@@ -212,7 +212,7 @@ Both commands are documented in [the CLI docs](docs/CLI.md).
 
 View templates execute real logic, and now they can be part of the report.
 `cover_views` brings ERB, Haml, and Slim templates in, measured through eval
-coverage (CRuby 3.2+):
+coverage:
 
 ```ruby
 SimpleCov.start 'rails' do

data/lib/simplecov/cli/affected/runner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "English"
+
+module SimpleCov
+  module CLI
+    module Affected
+      # Starts the runner at the repository root, since the selection's paths
+      # are relative to it, and answers the runner's exit status.
+      module SpawnedRunner
+        extend self
+
+        def call(command, root)
+          _, status = Process.wait2(spawn(*command, chdir: root))
+          status.exitstatus || 1
+        end
+      end
+
+      # JRuby on Windows answers Process.wait2 with a nil status and ignores
+      # the chdir option Kernel#system takes, so there the runner starts
+      # inside Dir.chdir, and Kernel#system reports its status.
+      module SystemRunner
+        extend self
+
+        def call(command, root)
+          ran = Dir.chdir(root) { system(*command) }
+          raise Errno::ENOENT, command.first if ran.nil?
+
+          $CHILD_STATUS.exitstatus || 1
+        end
+      end
+
+      # simplecov:disable branch — fixed by the running engine and OS
+      RUNNER = (RUBY_ENGINE.eql?("jruby") && Gem.win_platform?) ? SystemRunner : SpawnedRunner
+      # simplecov:enable branch
+    end
+  end
+end

data/lib/simplecov/cli/affected.rb

@@ -5,6 +5,7 @@ require "optparse"
 require_relative "command_helpers"
 require_relative "tests"
 require_relative "affected/changed_files"
+require_relative "affected/runner"
 require_relative "affected/selection"
 
 module SimpleCov
@@ -133,12 +134,10 @@ module SimpleCov
         run_command(opts.fetch(:run) + selection.fetch(:tests), opts.fetch(:root), stderr)
       end
 
-      # The selection's paths are relative to the repository root, so the runner
-      # starts there. The command is named explicitly in the failure because not
-      # every engine's exception message carries it.
+      # The command is named explicitly in the failure because not every
+      # engine's exception message carries it.
       def run_command(command, root, stderr)
-        _, status = Process.wait2(spawn(*command, chdir: root))
-        status.exitstatus || 1
+        RUNNER.call(command, root)
       rescue SystemCallError => e
         stderr.puts("simplecov affected: cannot run #{command.first.inspect} (#{e})")
         127

data/lib/simplecov/cli/annotations.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module SimpleCov
+  module CLI
+    # The `--annotate KIND` output shared by `uncovered` and `patch`: each command
+    # reduces its answer to diagnostics (a path, a contiguous missed line range,
+    # and the criterion that missed), and one emitter per CI host renders them in
+    # that host's native inline-annotation channel, so a gap surfaces on the diff
+    # with no upload step and no extra gem.
+    module Annotations
+      KINDS = %w[github gitlab rdjson azure teamcity buildkite].freeze
+
+      MESSAGES = {
+        line: "Not covered by tests",
+        branch: "Branch not covered by tests",
+        method: "Method not covered by tests"
+      }.freeze
+
+      DESCRIPTIONS = {
+        line: "Lines the tests never executed",
+        branch: "Branches the tests never took",
+        method: "Methods the tests never called"
+      }.freeze
+
+      SOURCE = {"name" => "simplecov", "url" => "https://github.com/simplecov-ruby/simplecov"}.freeze
+
+      # TeamCity's service message grammar and Azure's logging command grammar
+      # each reserve a few characters in attribute values.
+      TEAMCITY_ESCAPES = {"|" => "||", "'" => "|'", "[" => "|[", "]" => "|]", "\n" => "|n", "\r" => "|r"}.freeze
+      AZURE_ESCAPES = {"%" => "%AZP25", ";" => "%3B", "]" => "%5D", "\n" => "%0A", "\r" => "%0D"}.freeze
+
+      extend self
+
+      def issue(opts)
+        kind = opts.fetch(:annotate)
+        return nil unless kind
+        return "unknown --annotate #{kind.inspect} (expected #{expected_kinds})" unless KINDS.include?(kind)
+
+        "cannot combine --annotate with --json" if opts.fetch(:json)
+      end
+
+      def expected_kinds
+        *rest, last = KINDS
+        "#{rest.join(", ")}, or #{last}"
+      end
+
+      def diagnostics(path, missed, criterion)
+        missed.slice_when { |previous, current| current > previous + 1 }.map do |run|
+          {path: path, first: run.first, last: run.last, criterion: criterion, message: MESSAGES.fetch(criterion)}
+        end
+      end
+
+      def emit(stdout, kind, diagnostics)
+        case kind
+        when "github" then github(stdout, diagnostics)
+        when "gitlab" then stdout.puts(JSON.pretty_generate(gitlab(diagnostics)))
+        when "rdjson" then stdout.puts(JSON.pretty_generate(rdjson(diagnostics)))
+        when "azure" then azure(stdout, diagnostics)
+        when "teamcity" then teamcity(stdout, diagnostics)
+        else buildkite(stdout, diagnostics)
+        end
+      end
+
+      def github(stdout, diagnostics)
+        diagnostics.each do |diagnostic|
+          stdout.puts("::warning file=#{diagnostic.fetch(:path)},line=#{diagnostic.fetch(:first)}," \
+                      "endLine=#{diagnostic.fetch(:last)}::#{diagnostic.fetch(:message)}")
+        end
+      end
+
+      # GitLab's Code Quality report, a subset of the Code Climate spec, read from
+      # a `codequality` artifact for merge request annotations.
+      def gitlab(diagnostics)
+        diagnostics.map do |diagnostic|
+          {
+            "description" => diagnostic.fetch(:message),
+            "check_name" => "coverage",
+            "fingerprint" => fingerprint(diagnostic),
+            "severity" => "minor",
+            "location" => {
+              "path" => diagnostic.fetch(:path),
+              "lines" => {"begin" => diagnostic.fetch(:first), "end" => diagnostic.fetch(:last)}
+            }
+          }
+        end
+      end
+
+      def fingerprint(diagnostic)
+        Digest::SHA256.hexdigest("#{diagnostic.fetch(:path)}:#{diagnostic.fetch(:first)}-#{diagnostic.fetch(:last)}:" \
+                                 "#{diagnostic.fetch(:criterion)}")
+      end
+
+      # reviewdog's Diagnostic Format, which reviewdog posts to whichever host it
+      # runs under.
+      def rdjson(diagnostics)
+        {"source" => SOURCE, "severity" => "WARNING", "diagnostics" => diagnostics.map { |d| rdjson_diagnostic(d) }}
+      end
+
+      def rdjson_diagnostic(diagnostic)
+        {
+          "message" => diagnostic.fetch(:message),
+          "location" => {
+            "path" => diagnostic.fetch(:path),
+            "range" => {"start" => {"line" => diagnostic.fetch(:first)}, "end" => {"line" => diagnostic.fetch(:last)}}
+          },
+          "severity" => "WARNING",
+          "code" => {"value" => diagnostic.fetch(:criterion).to_s}
+        }
+      end
+
+      # Azure Pipelines logging commands carry one line number, so a range is
+      # spelled out in the message.
+      def azure(stdout, diagnostics)
+        diagnostics.each do |diagnostic|
+          stdout.puts("##vso[task.logissue type=warning;sourcepath=#{escape(diagnostic.fetch(:path), AZURE_ESCAPES)};" \
+                      "linenumber=#{diagnostic.fetch(:first)}]#{described(diagnostic)}")
+        end
+      end
+
+      # TeamCity's code inspection service messages: each criterion is one
+      # inspection type, declared once before its first inspection.
+      def teamcity(stdout, diagnostics)
+        diagnostics.group_by { |diagnostic| diagnostic.fetch(:criterion) }.each do |criterion, group|
+          id = "simplecov.#{criterion}"
+          stdout.puts(service_message("inspectionType", id: id, name: MESSAGES.fetch(criterion),
+            description: DESCRIPTIONS.fetch(criterion), category: "Code coverage"))
+          group.each do |diagnostic|
+            stdout.puts(service_message("inspection", typeId: id, message: described(diagnostic),
+              file: diagnostic.fetch(:path), line: diagnostic.fetch(:first), SEVERITY: "WARNING"))
+          end
+        end
+      end
+
+      def service_message(name, attributes)
+        body = attributes.map { |key, value| "#{key}='#{escape(value.to_s, TEAMCITY_ESCAPES)}'" }.join(" ")
+        "##teamcity[#{name} #{body}]"
+      end
+
+      # Buildkite has no per-line channel; its annotations are Markdown, so this
+      # is the body for `buildkite-agent annotate`.
+      def buildkite(stdout, diagnostics)
+        sections = diagnostics.group_by { |diagnostic| diagnostic.fetch(:message) }.map do |message, group|
+          (["#### #{message}"] + group.map { |diagnostic| "- `#{diagnostic.fetch(:path)}:#{range(diagnostic)}`" }).join("\n")
+        end
+        stdout.puts(sections.join("\n\n")) unless sections.empty?
+      end
+
+      def described(diagnostic)
+        return diagnostic.fetch(:message) if diagnostic.fetch(:first).equal?(diagnostic.fetch(:last))
+
+        "#{diagnostic.fetch(:message)} (lines #{range(diagnostic)})"
+      end
+
+      def range(diagnostic)
+        [diagnostic.fetch(:first), diagnostic.fetch(:last)].uniq.join("-")
+      end
+
+      def escape(text, escapes)
+        text.gsub(Regexp.union(escapes.keys), escapes)
+      end
+    end
+  end
+end

data/lib/simplecov/cli/clean.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require "optparse"
 require_relative "command_helpers"
+require_relative "real_path"
 
 module SimpleCov
   module CLI
@@ -68,7 +69,7 @@ module SimpleCov
       end
 
       def canonical_path(path)
-        File.realpath(path)
+        REAL_PATHS.realpath(path)
       rescue SystemCallError
         File.expand_path(path)
       end

data/lib/simplecov/cli/coverage_file.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../coverage_json"
+require_relative "real_path"
 
 module SimpleCov
   module CLI
@@ -55,7 +56,7 @@ module SimpleCov
 
       # A key whose file no longer exists keeps its literal spelling.
       def normalize(key)
-        File.realdirpath(key)
+        REAL_PATHS.realdirpath(key)
       rescue SystemCallError
         key
       end

data/lib/simplecov/cli/patch/output.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../annotations"
 
 module SimpleCov
   module CLI
@@ -8,8 +9,23 @@ module SimpleCov
       module Output
         OPTIONAL_CRITERIA = %i[branch method].freeze
 
+        CRITERIA = %i[line branch method].freeze
+
         extend self
 
+        # One diagnostic per contiguous missed range per measured criterion, in the
+        # CI host's own annotation form. Totals and the empty-change notice stay
+        # off stdout: the exit status under --minimum is the verdict.
+        def annotate(stdout, rows, kind)
+          diagnostics = rows.flat_map do |row|
+            CRITERIA.flat_map do |criterion|
+              stats = row.fetch(criterion)
+              stats ? Annotations.diagnostics(row.fetch(:file), stats.fetch(:missing), criterion) : []
+            end
+          end
+          Annotations.emit(stdout, kind, diagnostics)
+        end
+
         def emit(stdout, rows, opts)
           if opts.fetch(:json)
             stdout.puts(JSON.pretty_generate(json_rows(rows)))

data/lib/simplecov/cli/patch.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "annotations"
 require_relative "command_helpers"
 require_relative "patch/changed_lines"
 require_relative "patch/output"
@@ -35,20 +36,25 @@ module SimpleCov
         return 1 unless diffed
 
         rows = compute_rows(opts.fetch(:coverage), diffed, stderr)
-        Output.emit(stdout, rows, opts)
+        kind = opts.fetch(:annotate)
+        kind ? Output.annotate(stdout, rows, kind) : Output.emit(stdout, rows, opts)
         Output.gate(rows, opts.fetch(:minimum))
       end
 
       def parse(args, stderr)
         # No `base:` default: the run fills it in from the repository when the
         # option is left out.
-        opts, rest = parse_common(args, find_renames: false, minimum: nil) do |parser, options|
+        opts, rest = parse_common(args, find_renames: false, minimum: nil, annotate: nil) do |parser, options|
           parser.on("--base REF") { |v| options[:base] = v }
           parser.on("--minimum N", Float) { |v| options[:minimum] = v }
           parser.on("--find-renames") { options[:find_renames] = true }
+          parser.on("--annotate KIND") { |v| options[:annotate] = v }
         end
         return unless positional_ok?(rest, stderr)
 
+        issue = Annotations.issue(opts)
+        return error_nil(stderr, issue) if issue
+
         opts[:coverage] = CoverageFile.load_coverage(opts.fetch(:input), command: "patch", stderr: stderr) or return nil
         opts
       end

data/lib/simplecov/cli/real_path.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module CLI
+    # The JDK's answer to File.realpath and File.realdirpath, for JRuby. On
+    # Windows JRuby's own versions follow no symlinks, and realdirpath accepts
+    # a directory that does not exist, so the CLI's containment and identity
+    # checks would compare paths that were never resolved. Path#toRealPath has
+    # neither problem on any OS. The path is expanded first because the JDK
+    # resolves a relative path against the JVM's working directory, which
+    # Dir.chdir does not move.
+    #
+    # simplecov:disable — JRuby-only; this suite's coverage is measured on CRuby
+    module JDKRealPath
+      extend self
+
+      # mutant:disable — JRuby-only, unreachable from the engine mutant runs on
+      def realpath(path)
+        expanded = File.expand_path(path)
+        java.nio.file.Paths.get(expanded).toRealPath.toString.tr("\\", "/") # steep:ignore NoMethod
+      rescue java.nio.file.NoSuchFileException, java.nio.file.NotDirectoryException # steep:ignore NoMethod
+        raise Errno::ENOENT, expanded
+      rescue java.nio.file.AccessDeniedException # steep:ignore NoMethod
+        raise Errno::EACCES, expanded
+      rescue java.nio.file.InvalidPathException # steep:ignore NoMethod
+        raise Errno::EINVAL, expanded
+      end
+
+      # mutant:disable — JRuby-only, unreachable from the engine mutant runs on
+      def realdirpath(path)
+        expanded = File.expand_path(path)
+        return realpath(expanded) if File.exist?(expanded)
+
+        File.join(realpath(File.dirname(expanded)), File.basename(expanded))
+      end
+    end
+    # simplecov:enable
+
+    REAL_PATHS = RUBY_ENGINE.eql?("jruby") ? JDKRealPath : File # simplecov:disable branch — fixed by the running engine
+  end
+end

data/lib/simplecov/cli/serve/static_file_handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../real_path"
+
 module SimpleCov
   module CLI
     module Serve
@@ -93,7 +95,7 @@ module SimpleCov
         # added, it must happen BEFORE the `inside?` check.
         def resolve(request_path, root)
           path = request_path.split("?").first.to_s.delete_prefix("/")
-          absolute_root = File.realpath(root)
+          absolute_root = REAL_PATHS.realpath(root)
           candidate = File.expand_path(path, absolute_root)
           # Rejected before touching disk, so traversal and absolute-path attempts
           # are 403, not 404.
@@ -104,10 +106,10 @@ module SimpleCov
 
           # Symlinks are resolved last and re-checked: a file inside root could be
           # a symlink pointing outside.
-          real = File.realpath(candidate)
+          real = REAL_PATHS.realpath(candidate)
           inside?(real, absolute_root) ? real : :forbidden
         rescue Errno::ENOENT
-          # TOCTOU: candidate vanished between File.file? and File.realpath.
+          # TOCTOU: candidate vanished between File.file? and resolving it.
           nil
         end
 

data/lib/simplecov/cli/uncovered/misses.rb

@@ -20,16 +20,12 @@ module SimpleCov
           missed.uniq.sort
         end
 
-        # GitHub workflow commands, one ::warning per contiguous missed range, so a
-        # plain workflow gets inline diff annotations with no upload step and no
-        # code-scanning permissions.
-        def annotate(stdout, files)
-          files.each do |fname, _pct, _covered, _total, missed|
-            path = fname.delete_prefix("#{File.expand_path(SimpleCov.root)}/")
-            missed.slice_when { |previous, current| current > previous + 1 }.each do |run|
-              stdout.puts("::warning file=#{path},line=#{run.first},endLine=#{run.last}::Not covered by tests")
-            end
+        def annotate(stdout, files, criterion, kind)
+          root = "#{File.expand_path(SimpleCov.root)}/"
+          diagnostics = files.flat_map do |fname, _pct, _covered, _total, missed|
+            Annotations.diagnostics(fname.delete_prefix(root), missed, criterion)
           end
+          Annotations.emit(stdout, kind, diagnostics)
         end
       end
     end

data/lib/simplecov/cli/uncovered.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "optparse"
+require_relative "annotations"
 require_relative "command_helpers"
 require_relative "patch/output"
 require_relative "show/annotator"
@@ -21,7 +22,7 @@ module SimpleCov
 
       def run(args, stdout:, stderr:, **)
         opts = parse(args)
-        issue = precheck(opts)
+        issue = Annotations.issue(opts)
         return error(stderr, issue) if issue
 
         keys = CoverageFile::CRITERIA[opts.fetch(:criterion)]
@@ -31,28 +32,11 @@ module SimpleCov
         report(opts, keys, stdout, stderr)
       end
 
-      def precheck(opts)
-        return nil unless opts.fetch(:annotate)
-        unless opts.fetch(:annotate).eql?("github")
-          return "unknown --annotate #{opts.fetch(:annotate).inspect} (only github is supported)"
-        end
-
-        "cannot combine --annotate with --json" if opts.fetch(:json)
-      end
-
       def report(opts, keys, stdout, stderr)
         coverage = CoverageFile.load_coverage(opts.fetch(:input), command: "uncovered", stderr: stderr)
         return 1 unless coverage
 
-        files = rank(coverage, opts, keys).first(opts.fetch(:top))
-        return empty(opts, stdout) if files.empty?
-
-        emit(stdout, files, opts)
-        0
-      end
-
-      def empty(opts, stdout)
-        stdout.puts(empty_message(opts.fetch(:json))) unless opts.fetch(:annotate)
+        emit(stdout, rank(coverage, opts, keys).first(opts.fetch(:top)), opts)
         0
       end
 
@@ -62,7 +46,9 @@ module SimpleCov
       end
 
       def emit(stdout, files, opts)
-        return Misses.annotate(stdout, files) if opts.fetch(:annotate)
+        kind = opts.fetch(:annotate)
+        return Misses.annotate(stdout, files, opts.fetch(:criterion), kind) if kind
+        return stdout.puts(empty_message(opts.fetch(:json))) if files.empty?
 
         opts.fetch(:json) ? emit_json(stdout, files) : emit_text(stdout, files, CLI.color_enabled?(opts, stdout))
       end

data/lib/simplecov/cli/usage.rb

@@ -89,7 +89,7 @@ module SimpleCov
             --top N                   Show at most N files (default: 10)
             --criterion C             line, branch, or method (default: line)
             --missing                 Append the missed line ranges to each row
-            --annotate github         Emit ::warning workflow commands instead of rows
+            --annotate KIND           Emit CI annotations instead of rows: github, gitlab, rdjson, azure, teamcity, or buildkite
             --json                    Emit results as a JSON array (for CI)
 
           tests options:
@@ -116,6 +116,7 @@ module SimpleCov
             --base REF                Diff against the merge-base of REF for the touched lines (default: origin's HEAD, else main, or in CI the PR's target branch)
             --minimum N               Exit non-zero when patch coverage on any measured criterion is below N%
             --find-renames            Follow a renamed file instead of counting the moved file as all-new
+            --annotate KIND           Emit CI annotations instead of rows: github, gitlab, rdjson, azure, teamcity, or buildkite
             --json                    Emit results as a JSON array (for CI)
 
           dead-code options:

data/lib/simplecov/cli.rb

@@ -4,6 +4,7 @@ require "optparse"
 require_relative "version"
 require_relative "color"
 require_relative "cli/dotfile"
+require_relative "cli/real_path"
 require_relative "cli/badge"
 require_relative "cli/clean"
 require_relative "cli/completions"

data/lib/simplecov/configuration/eval_coverage.rb

@@ -25,7 +25,7 @@ module SimpleCov
       if coverage_for_eval_supported?
         @coverage_for_eval_enabled = true
       else
-        warn "Coverage for eval is not available; Use Ruby 3.2.0 or later"
+        warn "Coverage for eval is not available on this Ruby"
       end
     end
 

data/lib/simplecov/configuration/view_coverage.rb

@@ -11,9 +11,8 @@ module SimpleCov
     # them as empty.
     #
     # Templates the suite renders are measured through eval coverage, which this
-    # enables, so it needs Ruby 3.2 or later. Templates it never renders are
-    # compiled at the end of the run so they appear at 0% instead of going
-    # missing.
+    # enables. Templates it never renders are compiled at the end of the run so
+    # they appear at 0% instead of going missing.
     def cover_views(*globs)
       globs = globs.flatten.compact
       globs = DEFAULT_VIEW_GLOBS.dup if globs.empty?

data/lib/simplecov/coverage_violations.rb

@@ -159,10 +159,12 @@ module SimpleCov
       end
 
       # The misconfiguration notice is enforcement output, not a Ruby warning: it
-      # must survive `-W0` and `Warning.warn` hooks, and honor `print_errors`.
+      # must survive `-W0` and `Warning.warn` hooks, and honor `print_errors`. A
+      # configured group that matched no files is absent from `result.groups`
+      # too, but has nothing to gate rather than nothing to look up.
       def lookup_group(result, group_name)
         group = result.groups[group_name]
-        if group.nil? && SimpleCov.print_errors
+        if group.nil? && SimpleCov.print_errors && !result.configured_group?(group_name)
           ExitCodes.print_error "minimum_coverage_by_group: no group named '#{group_name}' exists. " \
                                 "Available groups: #{result.groups.keys.join(", ")}"
         end

data/lib/simplecov/directive/erb.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Directive
+    # The Ruby an ERB template holds, at the template's own line numbers, so
+    # directive comments in a template are found the way they are in a `.rb`
+    # file. Lexing the template itself as Ruby is not an option: `%>` opens a
+    # percent literal that swallows everything up to the next `>`, so comments
+    # after the first tag are never tokenized.
+    #
+    # Text outside the tags is blanked and the tag delimiters become spaces, so
+    # every token keeps its line and column. A comment tag becomes a Ruby
+    # comment, which makes `<%# simplecov:disable %>` the template's own form of
+    # the directive.
+    module Erb
+      SEGMENT = /
+        (?<escaped><%%)
+        | <%(?<kind>\#|==?|-)?(?<body>.*?)(?<close>-?%>)
+        | (?<text>[^<]+|<)
+      /mx
+
+      def self.ruby_lines(lines)
+        source = lines.map { |line| line.end_with?("\n") ? line : "#{line}\n" }.join
+        source.gsub(SEGMENT) { convert(Regexp.last_match) }.lines
+      rescue ArgumentError, EncodingError
+        lines
+      end
+
+      def self.convert(match)
+        body = match[:body]
+        return blank(match[0]) if body.nil?
+        return "  #" + body.gsub("\n", "\n#") + blank(match[:close]) if match[:kind].eql?("#")
+
+        blank("<%" + match[:kind].to_s) + body + blank(match[:close]).sub(" ", ";")
+      end
+
+      def self.blank(text)
+        Template.blank(text)
+      end
+
+      private_class_method :convert, :blank
+    end
+  end
+end

data/lib/simplecov/directive/haml.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "indented_template"
+
+module SimpleCov
+  class Directive
+    # The Ruby a Haml template holds. Script lines (`-`, `=`, and their `!`,
+    # `&`, and `~` variants) and the script a tag outputs keep their Ruby with
+    # the markers blanked, a `-#` comment becomes a Ruby comment, a `:ruby`
+    # filter's lines are Ruby as written, and everything else is blanked.
+    module Haml
+      include IndentedTemplate
+      extend self
+
+      SCRIPT = /\A[!&]?[-=~]/
+      TAG_SCRIPT = /\A[%.#][\w:.#-]*(?:\{[^{}]*\}|\([^()]*\)|\[[^\[\]]*\])*[<>]*[!&]?[=~]/
+
+      def convert(indent, rest)
+        if rest.start_with?("-#")
+          ["#{indent} ##{rest[2..]}", COMMENT]
+        elsif rest.match?(/\A:ruby[ \t]*\n\z/)
+          [Template.blank(indent + rest), RUBY]
+        elsif rest.start_with?(":")
+          [Template.blank(indent + rest), TEXT]
+        elsif (marker = rest[SCRIPT] || rest[TAG_SCRIPT])
+          [indent + Template.blank(marker) + rest[marker.length..]]
+        else
+          [Template.blank(indent + rest)]
+        end
+      end
+    end
+  end
+end