simplecov 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 774f2590be4fc8efd720e8c61b8e0678b50794dbc8c881c5872c51ac7b318c08
-  data.tar.gz: a67efdab2414345fa195aea9015d5cfc5128c452be20888edc1814c05fff98e0
+  metadata.gz: d476eb77902a3475da8b97f4af5d61fc3ff9fd0829221447b78b82581ce7ddff
+  data.tar.gz: 5ad815e1bdc6c010579d550fbea11aaa860c2c92f2f4f77cca3824a611f1b38e
 SHA512:
-  metadata.gz: 32062ccc9c83227f868788d5f2a0fa43eda93e8f714ed4ffe068fea3ac05ee7dd21f26d4234903da7679a6c72325955282000055892deaabf4a0703f924f06ca
-  data.tar.gz: c4a9a68bfbed7bc9c38de07afd89bedfefd3ea1ff1ee2b5294701c588c6cca7a10ae571313e0d836478045c07fcee81e4a1dc20c258d92e13a46f1e044c4d6d5
+  metadata.gz: 7c3de21fa0caf77d6bb4154094be10b9bca3c30155b27b8a4679791bea6221dd09c9cd88eeb0ca3dc0e4959646459cf10d21ec8db234a1ad0f06197bdaa1a0e3
+  data.tar.gz: 6264dd029949453bdaf3a94ad893b647f40424eccbae4d0e9485be26e28d6c5ff92bdcff0a4e0f7acbb95b9afa5710df4ef6bca1230c888cbe4f99122ce63cb0

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

data/lib/simplecov/directive/indented_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class Directive
+    # The driver the line-oriented template languages share. Each line is
+    # converted on its own unless the line above it opened a block, which the
+    # language decides by answering a continuation alongside the converted
+    # text: `COMMENT` for a comment marker, whose deeper-indented lines
+    # continue the comment, `RUBY` for an embedded Ruby block, whose lines are
+    # Ruby as written, and `TEXT` for any other embedded block, whose lines are
+    # blanked. A blank line neither ends a block nor belongs to it.
+    module IndentedTemplate
+      COMMENT = ->(line) { line.start_with?("\n") ? line : "##{line[1..]}" }
+      RUBY = ->(line) { line }
+      TEXT = ->(line) { Template.blank(line) }
+
+      def ruby_lines(lines)
+        open = nil #: untyped
+        lines.map do |line|
+          line = "#{line}\n" unless line.end_with?("\n")
+          indent = line[/\A[ \t]*/].length
+          rest = line[indent..]
+          if open && (rest.eql?("\n") || indent > open.last)
+            open.first.call(line)
+          else
+            converted = convert(line[0, indent], rest)
+            continuation = converted.at(1)
+            open = continuation && [continuation, indent]
+            converted.fetch(0)
+          end
+        end
+      rescue ArgumentError, EncodingError
+        lines
+      end
+    end
+  end
+end

data/lib/simplecov/directive/slim.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "indented_template"
+
+module SimpleCov
+  class Directive
+    # The Ruby a Slim template holds. Control and output lines (`-`, `=`, `==`,
+    # and their whitespace variants) and the output a bare tag carries keep
+    # their Ruby with the markers blanked, a `/` comment becomes a Ruby
+    # comment, a `ruby:` block's lines are Ruby as written, and everything else
+    # is blanked. A tag with attributes is blanked whole, since `=` inside them
+    # is not the output marker.
+    module Slim
+      include IndentedTemplate
+      extend self
+
+      CODE = /\A(?:-|={1,2}[<>']*)(?=\s)/
+      TAG_CODE = /\A[\w.#-]+\s*={1,2}[<>']*(?=\s)/
+
+      def convert(indent, rest)
+        if rest.start_with?("/")
+          ["#{indent}##{rest[1..]}", COMMENT]
+        elsif rest.match?(/\Aruby:[ \t]*\n\z/)
+          [Template.blank(indent + rest), RUBY]
+        elsif rest.match?(/\A\w+:[ \t]*\n\z/)
+          [Template.blank(indent + rest), TEXT]
+        elsif (marker = rest[CODE] || rest[TAG_CODE])
+          [indent + Template.blank(marker) + rest[marker.length..]]
+        else
+          [Template.blank(indent + rest)]
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/directive/template.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "erb"
+require_relative "haml"
+require_relative "slim"
+
+module SimpleCov
+  class Directive
+    # Hands a template's lines to the extractor for its language, so the
+    # directive scan sees only the Ruby a template holds, at the template's own
+    # line numbers. A file in no template language is Ruby already.
+    module Template
+      EXTRACTORS = {".erb" => Erb, ".haml" => Haml, ".slim" => Slim}.freeze
+
+      def self.template?(filename)
+        EXTRACTORS.key?(File.extname(filename))
+      end
+
+      def self.ruby_lines(filename, lines)
+        extractor = EXTRACTORS[File.extname(filename)]
+        extractor ? extractor.ruby_lines(lines) : lines
+      end
+
+      def self.blank(text)
+        text.gsub(/[^\n]/, " ")
+      end
+    end
+  end
+end

data/lib/simplecov/directive.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ripper"
+require_relative "directive/template"
 
 module SimpleCov
   # Parses `# simplecov:disable` / `# simplecov:enable` directive comments, in