simplecov 1.1.1 → 1.3.0

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,43 +16,49 @@ 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
 
       def directive_chunks
-        @directive_chunks ||= Directive.disabled_ranges(@src)
+        @directive_chunks ||= Directive.disabled_ranges(ruby_lines)
       end
 
-    private
+      private
 
+      # The Ruby the file holds, which for a template means the Ruby inside its
+      # tags or script lines with its own comments turned into Ruby comments.
+      # Both kinds of marker are found there, so a toggle in a template's
+      # comment syntax gets the same treatment, and the same deprecation
+      # warning, as one in a Ruby file.
+      def ruby_lines
+        @ruby_lines ||= Directive::Template.ruby_lines(@filename, @src)
+      end
+
+      # 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 = ruby_lines.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)

data/lib/simplecov/source_file/source_loader.rb

@@ -2,36 +2,35 @@
 
 module SimpleCov
   class SourceFile
-    # Reads a source file into an array of lines, honoring the source's
-    # shebang and `coding:` magic comment when present. Always
-    # transcodes to UTF-8 with invalid/undef bytes replaced — both for
-    # JRuby compatibility and to keep encoding shenanigans in one place
-    # (see #866).
+    # Reads a source file into an array of lines, honoring the source's shebang
+    # and `coding:` magic comment when present. Always transcodes to UTF-8 with
+    # invalid and undefined bytes replaced, both for JRuby compatibility and to
+    # keep encoding shenanigans in one place (#866).
     module SourceLoader
       SHEBANG_REGEX = /\A#!/
       RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/
 
-    module_function
+      extend self
 
       def call(filename)
         lines = [] #: Array[String]
-        # The default encoding is UTF-8
-        File.open(filename, "rb:UTF-8") do |file|
-          current_line = scrub_invalid(file.gets)
-
-          if current_line && shebang?(current_line)
-            lines << current_line
-            current_line = scrub_invalid(file.gets)
-          end
-
-          read_lines(file, lines, current_line)
+        open_file(filename, "rb:UTF-8") do |file|
+          read_lines(file, lines, scrub_invalid(file.gets))
         end
       end
 
-      # A line read as UTF-8 can still carry invalid bytes (a Latin-1
-      # source file without a magic comment, say). Replace them before
-      # any regex sees the line: the shebang and magic-comment checks
-      # would otherwise raise ArgumentError and take the report down.
+      # mutant:disable — Ruby 4.0 removed Kernel#open's leading-pipe
+      # command mode, so no test can tell `File.open` from `open` here
+      # any more. The explicit receiver is kept: on older rubies it is
+      # what refuses to run a filename as a command.
+      def open_file(name, mode, &)
+        File.open(name, mode, &)
+      end
+
+      # A line read as UTF-8 can still carry invalid bytes, from a Latin-1 source
+      # file without a magic comment, say. They are replaced before any regex sees
+      # the line: the shebang and magic-comment checks would otherwise raise
+      # ArgumentError and take the report down.
       def scrub_invalid(line)
         return line if line.nil? || line.valid_encoding?
 
@@ -45,11 +44,17 @@ module SimpleCov
       def read_lines(file, lines, current_line)
         return lines unless current_line
 
+        if shebang?(current_line)
+          lines << current_line
+          current_line = scrub_invalid(file.gets)
+          return lines unless current_line
+        end
+
         set_encoding_based_on_magic_comment(file, current_line)
         lines.concat([current_line], ensure_remove_undefs(file.readlines))
       end
 
-      # Encoding magic comment must be placed at first line except for
+      # An encoding magic comment must be placed on the first line, except after a
       # shebang.
       def set_encoding_based_on_magic_comment(file, line)
         if (match = RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX.match(line))
@@ -57,21 +62,26 @@ module SimpleCov
         end
       end
 
-      # Guarantee every line leaves the loader as valid UTF-8, replacing
-      # what can't be represented: transcode non-UTF-8 lines (setting
-      # invalid/undef options on `file.set_encoding` doesn't work
-      # properly, and this also works around a JRuby incompatibility)
-      # and scrub UTF-8-tagged lines that carry invalid bytes, which
-      # would otherwise raise from every regex the classifier runs.
+      # Setting invalid/undef options on `file.set_encoding` doesn't work
+      # properly, and transcoding here also works around a JRuby incompatibility.
       def ensure_remove_undefs(file_lines)
-        file_lines.each do |line|
-          # simplecov:disable — defensive: only fires for non-UTF-8 source files
-          if line.encoding == Encoding::UTF_8
-            line.scrub! unless line.valid_encoding?
-          else
-            line.encode!("UTF-8", invalid: :replace, undef: :replace)
-          end
-          # simplecov:enable
+        file_lines.each { |line| make_utf8(line) }
+      end
+
+      # mutant:disable — on CRuby the two arms answer alike, because
+      # converting to the encoding a string already carries scrubs it
+      # when `invalid: :replace` is given. The arms are kept apart for
+      # the engines where that conversion is the documented no-op it
+      # reads as, which is the same reason the transcode is here rather
+      # than on `file.set_encoding`.
+      # Encodings are singletons, so identity is the whole of the question. A line
+      # already tagged UTF-8 has nothing to transcode, only invalid bytes to
+      # replace, and scrubbing a line that has none of those leaves it alone.
+      def make_utf8(line)
+        if line.encoding.equal?(Encoding::UTF_8)
+          line.scrub!
+        else
+          line.encode!("UTF-8", invalid: :replace, undef: :replace)
         end
       end
     end

data/lib/simplecov/source_file/statistics.rb

@@ -2,10 +2,9 @@
 
 module SimpleCov
   class SourceFile
-    # Builds the `CoverageStatistics` triple (`:line`, `:branch`, `:method`)
-    # for a SourceFile, regardless of which criteria were actually enabled
-    # during the run — disabled or empty criteria collapse to 0/0/0 so
-    # downstream consumers don't have to special-case enable-state.
+    # Builds the `CoverageStatistics` triple for a SourceFile regardless of which
+    # criteria were enabled during the run: disabled or empty criteria collapse to
+    # 0/0/0 so downstream consumers don't have to special-case enable-state.
     class Statistics
       def initialize(source_file)
         @source_file = source_file
@@ -19,7 +18,7 @@ module SimpleCov
         }
       end
 
-    private
+      private
 
       def line_statistics
         {
@@ -31,13 +30,11 @@ module SimpleCov
         }
       end
 
-      # Files added via track_files but never loaded have no branch/method
-      # data. Report 0% instead of the empty-set default of 100% (see #902).
       def branch_statistics
         sf = @source_file
         covered = sf.covered_branches
         missed = sf.missed_branches
-        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
+        percent = 0.0 if covered.empty? && unaccounted?(sf, "branches")
 
         {branch: coverage_statistics(covered, missed, percent: percent)}
       end
@@ -46,11 +43,25 @@ module SimpleCov
         sf = @source_file
         covered = sf.covered_methods
         missed = sf.missed_methods
-        percent = 0.0 if sf.not_loaded? && covered.empty? && missed.empty?
+        percent = 0.0 if covered.empty? && unaccounted?(sf, "methods")
 
         {method: coverage_statistics(covered, missed, percent: percent)}
       end
 
+      # A file tracked but never loaded once carried no branch or method tuples
+      # at all, so an empty set meant "nobody knows", and answering the
+      # empty-set default of 100% overstated it (#902). Simulation now
+      # synthesizes those tuples statically, so a file carrying a table at all,
+      # empty or not, has been accounted for: it has no branches, or a
+      # directive skipped the ones it has, and it is as covered as a loaded
+      # file with none. Only a file carrying no table for the criterion is
+      # still unaccounted for. A file with missed entries and none covered
+      # already computes to 0% either way, so only one that really has covered
+      # entries keeps its computed percentage.
+      def unaccounted?(source_file, table)
+        source_file.not_loaded? && source_file.coverage_data[table].nil?
+      end
+
       def coverage_statistics(covered, missed, omitted: 0, percent: nil)
         CoverageStatistics.new(
           total_strength: covered.sum { |item| item.coverage.to_i },

data/lib/simplecov/source_file.rb

@@ -12,17 +12,10 @@ require_relative "source_file/method_builder"
 require_relative "source_file/statistics"
 
 module SimpleCov
-  #
-  # Representation of a source file including it's coverage data, source code,
-  # source lines and featuring helpers to interpret that data.
-  #
   class SourceFile
     include BuilderContext
 
-    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
-    attr_reader :filename
-    # The array of coverage data received from the Coverage.result
-    attr_reader :coverage_data
+    attr_reader :filename, :coverage_data
 
     def initialize(filename, coverage_data, loaded: true)
       @filename = filename
@@ -30,72 +23,57 @@ module SimpleCov
       @loaded = loaded
     end
 
-    # The path to this source file relative to the projects directory
     def project_filename
       @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
     end
 
-    # The source code for this file. Aliased as :source.
-    # Intentionally read lazily to suppress reading unused source code.
+    # Read lazily to suppress reading unused source code.
     def src
       @src ||= SourceLoader.call(filename)
     end
-    alias source src
+    alias_method :source, :src
 
-    # Returns a hash keyed by every supported coverage criterion. Each
-    # value is a CoverageStatistics, even for criteria that weren't
-    # enabled during the run — those collapse to 0/0/0. Consumers
-    # (FileList, formatters) decide which keys to surface based on
-    # `SimpleCov.coverage_criterion_enabled?`.
     # The per-criterion coverage statistics for this file. With no argument
-    # returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
-    # (`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
+    # answers the `{line:, branch:, method:}` Hash, and with a criterion symbol
+    # that one CoverageStatistics. Every criterion is present even when it
+    # wasn't enabled during the run, collapsed to 0/0/0; `FileList` is the
+    # layer that filters to the enabled set.
     def coverage_statistics(criterion = nil)
       stats = (@coverage_statistics ||= Statistics.new(self).call)
       criterion ? stats[criterion] : stats
     end
 
-    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
-    # and thus including coverage data. Aliased as :source_lines
     def lines
       @lines ||= LineBuilder.new(self).call
     end
-    alias source_lines lines
+    alias_method :source_lines, :lines
 
-    # Returns all covered lines as SimpleCov::SourceFile::Line
     def covered_lines
       @covered_lines ||= lines.select(&:covered?)
     end
 
-    # Returns all lines that should have been, but were not covered
-    # as instances of SimpleCov::SourceFile::Line
     def missed_lines
       @missed_lines ||= lines.select(&:missed?)
     end
 
-    # Returns all lines that are not relevant for coverage as
-    # SimpleCov::SourceFile::Line instances
     def never_lines
       @never_lines ||= lines.select(&:never?)
     end
 
-    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
     def skipped_lines
       @skipped_lines ||= lines.select(&:skipped?)
     end
 
-    # Returns the number of relevant lines (covered + missed)
     def lines_of_code
       coverage_statistics[:line]&.total || 0
     end
 
-    # Access SimpleCov::SourceFile::Line source lines by line number
+    # Answers nil for a number this file has no line for.
     def line(number)
-      lines[number - 1]
+      lines.at(number - 1)
     end
 
-    # The coverage for this file in percent, for the given criterion (line by
-    # default). Returns nil if the criterion was not measured.
+    # Nil if the criterion was not measured.
     def covered_percent(criterion = :line)
       coverage_statistics(criterion)&.percent
     end
@@ -104,15 +82,16 @@ module SimpleCov
       coverage_statistics(criterion)&.strength
     end
 
+    # Every line the file has is irrelevant, a file with no lines at all
+    # included.
     def no_lines?
-      lines.empty? || (lines.length == never_lines.size)
+      lines.all?(&:never?)
     end
 
     def relevant_lines
       lines.size - never_lines.size - skipped_lines.size
     end
 
-    # Return all the branches inside current source file
     def branches
       @branches ||= BranchBuilder.new(self).call
     end
@@ -121,33 +100,28 @@ module SimpleCov
       total_branches.empty?
     end
 
-    # DEPRECATED: use `covered_percent(:branch)`.
     def branches_coverage_percent
-      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
-                                  "Use `covered_percent(:branch)`.")
+      Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
+                       "Use `covered_percent(:branch)`.")
       covered_percent(:branch)
     end
 
-    # Return the relevant branches to source file
     def total_branches
       @total_branches ||= covered_branches + missed_branches
     end
 
-    # Return hash with key of line number and branch coverage count as value
     def branches_report
       @branches_report ||=
         branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
     end
 
-    # Select the covered branches. We use a tree schema here because
-    # some conditions like `case` may have an additional `else` that
-    # isn't declared in code but is given by default by the coverage
-    # report.
+    # A tree schema, because some conditions like `case` may have an additional
+    # `else` that isn't declared in code but is given by default by the
+    # coverage report.
     def covered_branches
       @covered_branches ||= branches.select(&:covered?)
     end
 
-    # Select the missed branches with coverage equal to zero
     def missed_branches
       @missed_branches ||= branches.select(&:missed?)
     end
@@ -156,12 +130,10 @@ module SimpleCov
       branches_report.fetch(line_number, [])
     end
 
-    # Check if any branches missing on given line number
     def line_with_missed_branch?(line_number)
       branches_for_line(line_number).any? { |_type, count| count.zero? }
     end
 
-    # Return all methods detected in this source file
     def methods
       @methods ||= MethodBuilder.new(self).call
     end
@@ -174,14 +146,12 @@ module SimpleCov
       @missed_methods ||= methods.select(&:missed?)
     end
 
-    # DEPRECATED: use `covered_percent(:method)`.
     def methods_coverage_percent
-      SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
-                                  "Use `covered_percent(:method)`.")
+      Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                       "Use `covered_percent(:method)`.")
       covered_percent(:method)
     end
 
-    # Whether this file was added via track_files but never loaded/required.
     def not_loaded?
       !@loaded
     end