simplecov 1.1.0 → 1.2.0

data/lib/simplecov/source_file/branch_builder.rb

@@ -2,11 +2,10 @@
 
 module SimpleCov
   class SourceFile
-    # Builds the `SourceFile::Branch` objects for a source file from
-    # the raw branch data Ruby's Coverage library reports. Applies the
-    # `ignore_branches :eval_generated` / `:implicit_else` filters and
-    # marks branches inside `# simplecov:disable` / `# :nocov:` chunks
-    # as skipped.
+    # Builds the `SourceFile::Branch` objects for a source file from the raw
+    # branch data Ruby's Coverage library reports, applying the
+    # `ignore_branches` filters and marking branches inside disabled chunks as
+    # skipped.
     class BranchBuilder
       def initialize(source_file)
         @source_file = source_file
@@ -23,17 +22,13 @@ module SimpleCov
         process_skipped(branches)
       end
 
-    private
-
-      # Detect a Coverage-reported branch condition that originates from
-      # `eval`/`module_eval`/`class_eval`/`instance_eval` rather than from
-      # the file's literal source. Coverage attributes such branches to the
-      # caller's `__FILE__`/`__LINE__`, so a Rails `delegate :foo, to: :bar`
-      # call surfaces inside the source file as if there were branches at
-      # the `delegate` line. Prism never sees those branches in the static
-      # source, so a condition whose start_line isn't in the real-source
-      # branch set must be eval-generated. Only consulted when the user has
-      # opted in via `SimpleCov.ignore_branches :eval_generated`. See #1046.
+      private
+
+      # Coverage attributes an eval'd branch to the caller's `__FILE__` /
+      # `__LINE__`, so a Rails `delegate :foo, to: :bar` call surfaces inside the
+      # source file as if there were branches at the `delegate` line. Prism never
+      # sees those branches in the static source, so a condition whose start_line
+      # isn't in the real-source branch set must be eval-generated (#1046).
       def eval_generated_condition_to_ignore?(condition)
         return false unless SimpleCov.ignored_branch?(:eval_generated)
 
@@ -44,15 +39,10 @@ module SimpleCov
         # simplecov:enable branch
 
         _type, _id, start_line, * = RubyDataParser.call(condition)
-        !positions[:branches].include?(start_line)
+        !positions.fetch(:branches).include?(start_line)
       end
 
       def build_branches_from(condition, branches)
-        # the format handed in from the coverage data is like this:
-        #
-        #     [:then, 4, 6, 6, 6, 10]
-        #
-        # which is [type, id, start_line, start_col, end_line, end_col]
         _condition_type, _condition_id, *condition_range = RubyDataParser.call(condition)
 
         branches.filter_map do |branch_data, hit_count|
@@ -60,54 +50,45 @@ module SimpleCov
         end
       end
 
+      # The coverage data hands in `[:then, 4, 6, 6, 6, 10]`, which is
+      # [type, id, start_line, start_col, end_line, end_col].
       def build_branch(branch_data, hit_count, condition_range)
         type, _id, start_line, start_col, end_line, end_col = branch_data
         return nil if implicit_else_to_ignore?(type, [start_line, start_col, end_line, end_col], condition_range)
 
-        SourceFile::Branch.new(
+        Branch.new(
           start_line: start_line,
           end_line: end_line,
           coverage: hit_count,
-          inline: start_line == condition_range.first,
+          inline: start_line.eql?(condition_range.first),
           type: type
         )
       end
 
-      # Detect synthetic `:else` branches that Ruby's Coverage library reports
-      # for constructs with no literal `else` keyword in source (`case/in` /
-      # `case/when` without else, `||=`, `&&=`, `if`/`unless` without else,
-      # and the postfix `return if cond` shape). The signal is structural:
-      # a synthetic else reuses its parent condition's *full source range*
-      # (start_line, start_col, end_line, end_col all identical), while an
-      # explicit `else` arm carries a narrower range — its own keyword/body
-      # position rather than the whole conditional. Comparing the full range
-      # (not just `start_line`) is what distinguishes a ternary's explicit
-      # else on the same line as the condition — `arg == 42 ? :yes : :no`,
-      # where the else's columns differ from the parent's — from a postfix
-      # `return if cond` where the synthetic else inherits the full range.
-      # Only consulted when the user has opted in via
-      # `SimpleCov.ignore_branches :implicit_else`. See #1033.
+      # Ruby's Coverage reports a synthetic `:else` for constructs with no literal
+      # `else` keyword. The signal is structural: a synthetic else reuses its
+      # parent condition's full source range, while an explicit `else` arm carries
+      # a narrower one. Comparing the full range rather than just `start_line` is
+      # what distinguishes a ternary's explicit else on the condition's own line
+      # from a postfix `return if cond` (#1033).
       def implicit_else_to_ignore?(type, branch_range, condition_range)
-        return false unless type == :else
+        return false unless type.equal?(:else)
         return false unless SimpleCov.ignored_branch?(:implicit_else)
 
-        branch_range == condition_range
+        branch_range.eql?(condition_range)
       end
 
+      # A non-inline branch's source range starts on its arm body, but
+      # `report_line` is the condition line above it, which is where the user sees
+      # the branch and would naturally place an inline disable directive. Honour
+      # both.
       def process_skipped(branches)
         chunks = @source_file.skip_chunks_for(:branch)
-        return branches if chunks.empty?
 
-        # A non-inline branch's source range starts on its arm body (e.g. the
-        # `:yes` line of `if cond / :yes / else / :no / end`), but `report_line`
-        # is the condition line above it — that's where the user sees the
-        # branch in the report and where they would naturally place an inline
         # `# simplecov:disable branch` directive. Honour both.
         branches.each do |branch|
           branch.skipped! if chunks.any? { |chunk| branch.overlaps_with?(chunk) || chunk.include?(branch.report_line) }
         end
-
-        branches
       end
     end
   end

data/lib/simplecov/source_file/builder_context.rb

@@ -2,24 +2,17 @@
 
 module SimpleCov
   class SourceFile
-    # Helpers shared by the per-criterion builders (LineBuilder /
-    # BranchBuilder / MethodBuilder). Mixed into SourceFile so each
-    # builder can ask the file for its skip-chunk ranges and Prism-derived
-    # real source positions without duplicating the memoization.
     module BuilderContext
-      # Skip-chunk lookup for the named criterion (`:line`, `:branch`,
-      # `:method`).
       def skip_chunks_for(criterion)
-        (@skip_chunks ||= SkipChunks.new(filename, src)).for(criterion)
+        (@skip_chunks ||= SkipChunks.new(filename, src)).chunks_for(criterion)
       end
 
-      # Memoized set of real source positions (branch start lines, method
-      # name+line pairs) extracted via Prism. Returns nil when Prism is
-      # unavailable or parsing fails, signaling callers to keep every
-      # Coverage entry (no false drops). The `defined?` guard preserves a
-      # nil memoization across calls.
+      # Memoized set of real source positions extracted via Prism. Nil when Prism is
+      # unavailable or parsing fails, signaling callers to keep every Coverage entry
+      # rather than risk false drops. The `defined?` guard preserves a nil
+      # memoization across calls.
       def real_source_positions
-        return @real_source_positions if defined?(@real_source_positions)
+        return @real_source_positions if instance_variable_defined?(:@real_source_positions)
 
         @real_source_positions = StaticCoverageExtractor.real_source_positions(src.join)
       end

data/lib/simplecov/source_file/line.rb

@@ -2,25 +2,12 @@
 
 module SimpleCov
   class SourceFile
-    # Representation of a single line in a source file including
-    # this specific line's source code, line_number and code coverage,
-    # with the coverage being either nil (coverage not applicable, e.g. comment
-    # line), 0 (line not covered) or >1 (the amount of times the line was
-    # executed)
     class Line
-      # The source code for this line. Aliased as :source
-      attr_reader :src
-      # The line number in the source file. Aliased as :line, :number
-      attr_reader :line_number
-      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
-      attr_reader :coverage
-      # Whether this line was skipped
-      attr_reader :skipped
+      attr_reader :src, :line_number, :coverage, :skipped
 
-      # Lets grab some fancy aliases, shall we?
-      alias source src
-      alias line line_number
-      alias number line_number
+      alias_method :source, :src
+      alias_method :line, :line_number
+      alias_method :number, :line_number
 
       def initialize(src, line_number, coverage)
         raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
@@ -29,48 +16,41 @@ module SimpleCov
           raise ArgumentError, "Only Integer and nil accepted for coverage"
         end
 
-        @src         = src
+        @src = src
         @line_number = line_number
-        @coverage    = coverage
-        @skipped     = false
+        @coverage = coverage
+        @skipped = false
       end
 
-      # Returns true if this is a line that should have been covered, but was not
+      # Asking `covered?` rather than reading the count a second time keeps the two
+      # answers from ever disagreeing, and `never?` ahead of it is what keeps a
+      # line with no coverage at all out of the missed column.
       def missed?
-        !never? && !skipped? && coverage.to_i.zero?
+        !never? && !skipped? && !covered?
       end
 
-      # Returns true if this is a line that has been covered
       def covered?
-        !never? && !skipped? && coverage.to_i.positive?
+        !skipped? && coverage.to_i.positive?
       end
 
-      # Returns true if this line is not relevant for coverage
       def never?
         !skipped? && coverage.nil?
       end
 
-      # Flags this line as skipped
       def skipped!
         @skipped = true
       end
 
-      # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
-      # # :nocov: comment lines.
       def skipped?
         skipped
       end
 
-      # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
-      # as a css class in report generation
       def status
         return "skipped" if skipped?
         return "never" if never?
         return "missed" if missed?
 
-        # simplecov:disable — defensive: covered? is the only state left after the three above
-        "covered" if covered?
-        # simplecov:enable
+        "covered"
       end
     end
   end

data/lib/simplecov/source_file/line_builder.rb

@@ -2,11 +2,8 @@
 
 module SimpleCov
   class SourceFile
-    # Builds the `SourceFile::Line` objects for a source file from the
-    # raw line-coverage array. Each line carries its source text, its
-    # 1-based line number, and the Coverage hit count (or nil for
-    # never-counted lines). Applies `# simplecov:disable` /
-    # `# :nocov:` block ranges via `skipped!`.
+    # Builds the `SourceFile::Line` objects for a source file from the raw
+    # line-coverage array, applying the disabled block ranges via `skipped!`.
     class LineBuilder
       def initialize(source_file)
         @source_file = source_file
@@ -18,23 +15,20 @@ module SimpleCov
         lines
       end
 
-    private
+      private
 
-      # When `:line` coverage is disabled, the Ruby Coverage module
-      # doesn't emit "lines" data, so look up `nil` (never-counted) for
-      # every position. The source rows are still useful — e.g. for the
-      # HTML report's source view — even without per-line hits.
+      # When `:line` coverage is disabled the Coverage module emits no "lines" data,
+      # so every position looks up nil. The source rows are still useful for the
+      # HTML report's source view even without per-line hits.
       def build_lines
         line_coverage = @source_file.coverage_data["lines"] || []
         @source_file.src.map.with_index(1) do |src, i|
-          SourceFile::Line.new(src, i, line_coverage[i - 1])
+          Line.new(src, i, line_coverage.at(i - 1))
         end
       end
 
-      # The array the lines are kept in is 0-based whereas the line
-      # numbers in the chunks are 1-based (more understandable elsewhere),
-      # so each range needs to be shifted down by one to slice into the
-      # `lines` array.
+      # The lines array is 0-based while the chunks' line numbers are 1-based, so
+      # each range is shifted down by one to slice into it.
       def mark_skipped(lines, chunks)
         chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
       end

data/lib/simplecov/source_file/method.rb

@@ -2,11 +2,9 @@
 
 module SimpleCov
   class SourceFile
-    # Represents a single method detected in coverage data.
-    # Provides helpers similar to Branch for coverage status.
     class Method
       attr_reader :source_file, :coverage, :class_name, :method_name,
-                  :start_line, :start_col, :end_line, :end_col
+        :start_line, :start_col, :end_line, :end_col
 
       def initialize(source_file, info, coverage)
         @source_file = source_file
@@ -25,12 +23,11 @@ module SimpleCov
       # method from method totals. Without line info there is nothing to
       # report against, so such a method stays skipped.
       def skipped?
-        return @skipped if defined?(@skipped)
+        return @skipped if instance_variable_defined?(:@skipped)
 
         @skipped = lines.empty?
       end
 
-      # Flag the method as skipped directly, without going through its lines.
       def skipped!
         @skipped = true
       end
@@ -40,10 +37,9 @@ module SimpleCov
       end
 
       def lines
-        @lines ||= start_line && end_line ? source_file.lines[(start_line - 1)..(end_line - 1)] || [] : []
+        @lines ||= (start_line && end_line) ? source_file.lines[(start_line - 1)..(end_line - 1)] || [] : []
       end
 
-      # Whether this method's source range intersects the given inclusive line range.
       def overlaps_with?(line_range)
         return false unless start_line && end_line
 

data/lib/simplecov/source_file/method_builder.rb

@@ -2,9 +2,6 @@
 
 module SimpleCov
   class SourceFile
-    # Builds the `SourceFile::Method` objects for a source file from
-    # the raw method-coverage data. Applies the
-    # `ignore_methods :eval_generated` filter and marks methods inside
     # `# simplecov:disable` / `# :nocov:` chunks as skipped.
     class MethodBuilder
       def initialize(source_file)
@@ -18,20 +15,17 @@ module SimpleCov
           info = RubyDataParser.call(info)
           next if eval_generated_to_ignore?(info)
 
-          SourceFile::Method.new(@source_file, info, hit_count)
+          Method.new(@source_file, info, hit_count)
         end
 
         process_skipped(methods)
       end
 
-    private
+      private
 
-      # See `BranchBuilder#eval_generated_condition_to_ignore?` for the
-      # rationale. Coverage reports an eval'd `def` at the eval caller's
-      # line and name, so a method whose `(name, start_line)` is absent
-      # from the real-source `def` set is eval-generated. Only consulted
-      # when the user has opted in via
-      # `SimpleCov.ignore_methods :eval_generated`. See #1046.
+      # Coverage reports an eval'd `def` at the eval caller's line and name, so a
+      # method whose `(name, start_line)` is absent from the real-source `def` set
+      # is eval-generated (#1046).
       def eval_generated_to_ignore?(info)
         return false unless SimpleCov.ignored_method?(:eval_generated)
 
@@ -42,18 +36,15 @@ module SimpleCov
         # simplecov:enable branch
 
         _class_name, name, start_line, * = info
-        !positions[:methods].include?([name, start_line])
+        !positions.fetch(:methods).include?([name, start_line])
       end
 
       def process_skipped(methods)
         chunks = @source_file.skip_chunks_for(:method)
-        return methods if chunks.empty?
 
         methods.each do |method|
           method.skipped! if chunks.any? { |chunk| method.overlaps_with?(chunk) }
         end
-
-        methods
       end
     end
   end

data/lib/simplecov/source_file/ruby_data_parser.rb

@@ -4,106 +4,99 @@ require "ripper"
 
 module SimpleCov
   class SourceFile
-    # `Coverage.result` reports condition and method keys as Ruby
-    # arrays. When the resultset is round-tripped through JSON those
-    # array keys become their stringified inspect form, so this parser
-    # walks the literal back into a real Array without using `eval` (see
-    # #801). The grammar covers symbols, strings, integers, unary minus,
-    # and constant paths — every shape Coverage ever emits.
+    # `Coverage.result` reports condition and method keys as Ruby arrays. When
+    # the resultset is round-tripped through JSON those array keys become their
+    # stringified inspect form, so this parser walks the literal back into a
+    # real Array without using `eval` (#801). The grammar covers symbols,
+    # strings, integers, unary minus, and constant paths: every shape Coverage
+    # ever emits.
     module RubyDataParser
-    module_function
+      extend self
 
-      # Tests use the real data structures (except for integration tests)
-      # so no need to put them through here.
-      #
       # String parses are memoized: `Combine::BranchesCombiner` and
       # `Combine::MethodsCombiner` derive a merge identity from every key of
       # both sides on every pairwise merge, so collating N resultsets parses
-      # each key string N-1 times — and Ripper dominates the wall time of a
-      # large collate.
-      # Key strings repeat across folds and within report building, while the
-      # set of unique keys is bounded by the project's branch and method
-      # count, so a permanent cache stays small. Cached arrays are frozen
-      # element-wise (String class names included, not just the tuple):
+      # each key string N-1 times, and Ripper dominates the wall time of a
+      # large collate. The set of unique keys is bounded by the project's
+      # branch and method count, so a permanent cache stays small.
+      #
+      # Cached arrays are frozen element-wise, String class names included:
       # every caller destructures without mutating, and sharing one array
-      # across callers must stay that way. The cache key needs no such
-      # care — `Hash#[]=` dups and freezes String keys on its own.
+      # across callers must stay that way. The cache key needs no such care,
+      # since `Hash#[]=` dups and freezes String keys on its own.
       def call(structure)
         return structure if structure.is_a?(Array)
 
-        string = structure.to_s
-        parse_cache[string] ||= parse_array_string(string).each(&:freeze).freeze
+        parse_cache[structure] ||= parse_array_string(structure).each(&:freeze).freeze
       end
 
       def parse_cache
         @parse_cache ||= {} #: Hash[String, untyped]
       end
 
-      # Parse a string like '[:if, 0, 3, 4, 3, 21]' or
+      # Parses a string like '[:if, 0, 3, 4, 3, 21]' or
       # '["ClassName", :method1, 2, 2, 5, 5]' back into a Ruby array.
       def parse_array_string(str)
-        # Try plain Ripper first; only pre-quote `#<...>` inspect segments
-        # if the input isn't already valid Ruby (otherwise we corrupt
-        # `"#<Class:Foo>"` strings that *are* valid Ruby literals — exactly
-        # the shape simplecov-on-simplecov method-coverage keys take).
+        # Plain Ripper first: pre-quoting `#<...>` inspect segments would corrupt
+        # `"#<Class:Foo>"` strings that are valid Ruby literals, exactly the
+        # shape simplecov-on-simplecov method-coverage keys take.
         sexp = Ripper.sexp(str) || Ripper.sexp(quote_inspected_class_segments(str))
-        # simplecov:disable — defensive: Ripper.sexp returning nil from both passes requires malformed input
-        array_node = sexp&.dig(1, 0)
-        # simplecov:enable
-        raise ArgumentError, "expected array literal: #{str.inspect}" unless array_node && array_node[0] == :array
+        # Ripper wraps what it parsed in a `:program` node holding the
+        # statements, and this input is supposed to be one array literal and
+        # nothing else. Both passes answer nil for input Ruby can't parse at
+        # all, so there may be no statement to unwrap.
+        _program, statements = sexp
+        first_statement, *extra = statements
+        array_node = Array(first_statement)
+        unless extra.empty? && array_node.first.equal?(:array)
+          raise ArgumentError, "expected array literal: #{str.inspect}"
+        end
 
-        Array(array_node[1]).map { |element| parse_element(element) }
+        Array(array_node.fetch(1)).map { |element| parse_element(element) }
       end
 
+      # Each `when` already knows the node's shape, so the elements read straight
+      # out of it rather than through a second dispatch. A symbol's text sits
+      # where a string's does, one node deeper.
       def parse_element(node)
-        case node[0]
-        when :@int, :unary                 then parse_integer_node(node)
-        when :symbol_literal, :dyna_symbol then parse_symbol_node(node)
-        when :string_literal               then unescape_ruby(string_literal_text(node[1]))
-        when :var_ref                      then node.dig(1, 1) # `Foo`
-        when :const_path_ref               then "#{parse_element(node[1])}::#{node[2][1]}" # `Foo::Bar`
+        case node.fetch(0)
+        when :@int then Integer(node.fetch(1))
+        when :unary then -Integer(node.fetch(2).fetch(1)) # `-2`
+        when :symbol_literal, :dyna_symbol then literal_text(node).to_sym
+        when :string_literal then literal_text(node)
+        when :var_ref then node.fetch(1).fetch(1) # `Foo`
+        when :const_path_ref then const_path(node) # `Foo::Bar`
         else
-          # simplecov:disable — defensive fallback for unexpected Ripper node shapes
-          raise ArgumentError, "unexpected element: #{node.inspect}"
-          # simplecov:enable
+          raise ArgumentError, "unexpected element: #{node}"
         end
       end
 
-      def parse_integer_node(node)
-        node[0] == :@int ? node[1].to_i : -node[2][1].to_i
-      end
-
-      def parse_symbol_node(node)
-        if node[0] == :symbol_literal
-          node.dig(1, 1, 1).to_sym
-        else
-          unescape_ruby(string_literal_text(node[1])).to_sym
-        end
+      # A constant path's namespace is an element in its own right, so
+      # `Foo::Bar::Baz` comes back together one segment at a time.
+      def const_path(node)
+        "#{parse_element(node.fetch(1))}::#{node.fetch(2).fetch(1)}"
       end
 
-      # Concatenate the text fragments of a `:string_content` node. Ripper
-      # may emit zero, one, or many `:@tstring_content` children depending
-      # on the literal.
-      def string_literal_text(string_content)
-        Array(string_content[1..]).map { |child| child[1] }.join
+      # Ripper may emit zero, one, or many fragments under a literal depending
+      # on its form, and the escapes it leaves in the source text come back out.
+      def literal_text(node)
+        unescape_ruby(node.fetch(1)[1..].map { |fragment| fragment.fetch(1) }.join)
       end
 
-      # Undo the same backslash-prefix escapes the previous hand-rolled
-      # parser undid: `\X` → `X` for any X.
+      # Undoes the same backslash-prefix escapes the previous hand-rolled parser
+      # undid: `\X` -> `X` for any X.
       def unescape_ruby(raw)
-        raw.gsub(/\\(.)/) { ::Regexp.last_match(1) }
+        raw.gsub(/\\(.)/) { Regexp.last_match(1) }
       end
 
-      # Method coverage keys can contain inspect-format class references
-      # like `#<Class:Foo>` or `#<Class:0x...>`, which aren't valid Ruby
-      # syntax. Wrap them in quotes so Ripper can parse the surrounding
-      # array literal; downstream we treat them as opaque strings. The
-      # pattern recurses because singleton methods on instances nest one
-      # inspect segment inside another (`#<Class:#<Object:0x...>>`), and
-      # stopping at the first `>` leaves a dangling `>` that fails both
-      # Ripper passes and crashes the merge.
+      # Method coverage keys can contain inspect-format class references like
+      # `#<Class:Foo>`, which aren't valid Ruby syntax. Wrapping them in quotes
+      # lets Ripper parse the surrounding array literal. The pattern recurses
+      # because singleton methods on instances nest one inspect segment inside
+      # another (`#<Class:#<Object:0x...>>`), and stopping at the first `>`
+      # leaves a dangling `>` that fails both Ripper passes.
       def quote_inspected_class_segments(str)
-        str.gsub(/#<(?:[^<>]|\g<0>)*>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
+        str.gsub(/#<(?:[^<>]|\g<0>)+>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
       end
     end
   end

data/lib/simplecov/source_file/skip_chunks.rb

@@ -2,15 +2,9 @@
 
 module SimpleCov
   class SourceFile
-    # Computes the set of line ranges that should be excluded from a
-    # SourceFile's coverage for each criterion. Two sources contribute:
-    #
-    # * The deprecated `# :nocov:` block toggle (lines wrapped between
-    #   even-numbered pairs of nocov markers are excluded from line and
-    #   branch coverage).
-    # * `# simplecov:disable` / `# simplecov:enable` block directives,
-    #   which can be scoped per-criterion (`# simplecov:disable branch`,
-    #   etc.) — see `SimpleCov::Directive`.
+    # The line ranges excluded from a SourceFile's coverage per criterion. Two
+    # sources contribute: the deprecated nocov block toggle, and the
+    # `SimpleCov::Directive` block directives, which can be scoped per criterion.
     class SkipChunks
       @nocov_warned = Set.new
       class << self
@@ -22,16 +16,15 @@ module SimpleCov
         @src = src
       end
 
-      # Every criterion honors the deprecated all-criteria `# :nocov:`
-      # chunks plus its own per-criterion directive ranges. Methods
-      # included: they carry a source range, and nocov has always meant
-      # "exclude everything here".
-      def for(criterion)
+      # Every criterion honors the deprecated all-criteria nocov chunks plus its
+      # own per-criterion directive ranges, methods included: they carry a
+      # source range, and nocov has always meant "exclude everything here". The
+      # ranges are 1-based line numbers, so consumers subtract 1 to index into
+      # the zero-based lines array.
+      def chunks_for(criterion)
         nocov_chunks + directive_chunks.fetch(criterion)
       end
 
-      # Ranges of 1-based line numbers (see `with_index(1)` below);
-      # consumers subtract 1 to index into the zero-based lines array.
       def nocov_chunks
         @nocov_chunks ||= build_nocov_chunks
       end
@@ -40,25 +33,23 @@ module SimpleCov
         @directive_chunks ||= Directive.disabled_ranges(@src)
       end
 
-    private
+      private
 
+      # An uneven number of nocovs is assumed to run to the end of the file. It
+      # cannot be handled inside the each_slice because JRuby behaves differently
+      # there (jruby/jruby#6048).
       def build_nocov_chunks
-        no_cov_lines = @src.map.with_index(1).select { |line_src, _index| LinesClassifier.no_cov_line?(line_src) }
+        no_cov_lines = @src.filter_map.with_index(1) do |line_src, index|
+          index if LinesClassifier.no_cov_line?(line_src)
+        end
 
-        warn_nocov_deprecation(no_cov_lines.first.last) if no_cov_lines.any?
+        warn_nocov_deprecation(no_cov_lines.first) if no_cov_lines.any?
 
-        # If we have an uneven number of nocovs we assume they go to the
-        # end of the file, the source doesn't really matter. Can't deal
-        # with this within the each_slice due to differing behavior in
-        # JRuby: jruby/jruby#6048
-        no_cov_lines << ["", @src.size] if no_cov_lines.size.odd?
+        no_cov_lines << @src.size if no_cov_lines.size.odd?
 
-        no_cov_lines.each_slice(2).map do |(_line_src_start, index_start), (_line_src_end, index_end)|
-          index_start..index_end
-        end
+        no_cov_lines.each_slice(2).map { |chunk_start, chunk_end| chunk_start..chunk_end }
       end
 
-      # Emit a one-time-per-file deprecation warning pointing the user
       # at the `# simplecov:disable` / `# simplecov:enable` replacement.
       def warn_nocov_deprecation(first_line_number)
         return unless self.class.nocov_warned.add?(@filename)