simplecov 0.22.0 → 1.3.0

data/lib/simplecov/source_file/source_loader.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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 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/
+
+      extend self
+
+      def call(filename)
+        lines = [] #: Array[String]
+        open_file(filename, "rb:UTF-8") do |file|
+          read_lines(file, lines, scrub_invalid(file.gets))
+        end
+      end
+
+      # 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?
+
+        line.scrub
+      end
+
+      def shebang?(line)
+        SHEBANG_REGEX.match?(line)
+      end
+
+      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
+
+      # 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))
+          file.set_encoding(match[1], "UTF-8")
+        end
+      end
+
+      # 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 { |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
+  end
+end

data/lib/simplecov/source_file/statistics.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  class SourceFile
+    # 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
+      end
+
+      def call
+        {
+          **line_statistics,
+          **branch_statistics,
+          **method_statistics
+        }
+      end
+
+      private
+
+      def line_statistics
+        {
+          line: coverage_statistics(
+            @source_file.covered_lines,
+            @source_file.missed_lines,
+            omitted: @source_file.never_lines.size
+          )
+        }
+      end
+
+      def branch_statistics
+        sf = @source_file
+        covered = sf.covered_branches
+        missed = sf.missed_branches
+        percent = 0.0 if covered.empty? && unaccounted?(sf, "branches")
+
+        {branch: coverage_statistics(covered, missed, percent: percent)}
+      end
+
+      def method_statistics
+        sf = @source_file
+        covered = sf.covered_methods
+        missed = sf.missed_methods
+        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 },
+          covered: covered.size,
+          missed: missed.size,
+          omitted: omitted,
+          percent: percent
+        )
+      end
+    end
+  end
+end

data/lib/simplecov/source_file.rb

@@ -1,102 +1,99 @@
 # frozen_string_literal: true
 
+require_relative "directive"
+require_relative "static_coverage_extractor"
+require_relative "source_file/ruby_data_parser"
+require_relative "source_file/source_loader"
+require_relative "source_file/skip_chunks"
+require_relative "source_file/builder_context"
+require_relative "source_file/line_builder"
+require_relative "source_file/branch_builder"
+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
-    # 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
+    include BuilderContext
+
+    attr_reader :filename, :coverage_data
 
-    def initialize(filename, coverage_data)
+    def initialize(filename, coverage_data, loaded: true)
       @filename = filename
       @coverage_data = coverage_data
+      @loaded = loaded
     end
 
-    # The path to this source file relative to the projects directory
     def project_filename
-      @filename.delete_prefix(SimpleCov.root)
+      @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
     end
 
-    # The source code for this file. Aliased as :source
+    # Read lazily to suppress reading unused source code.
     def src
-      # We intentionally read source code lazily to
-      # suppress reading unused source code.
-      @src ||= load_source
+      @src ||= SourceLoader.call(filename)
     end
-    alias source src
-
-    def coverage_statistics
-      @coverage_statistics ||=
-        {
-          **line_coverage_statistics,
-          **branch_coverage_statistics
-        }
+    alias_method :source, :src
+
+    # The per-criterion coverage statistics for this file. With no argument
+    # 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 ||= build_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
+      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. 0 if the file has no coverage lines
-    def covered_percent
-      coverage_statistics[:line]&.percent
+    # Nil if the criterion was not measured.
+    def covered_percent(criterion = :line)
+      coverage_statistics(criterion)&.percent
     end
 
-    def covered_strength
-      coverage_statistics[:line]&.strength
+    def covered_strength(criterion = :line)
+      coverage_statistics(criterion)&.strength
     end
 
+    # Every line the file has is irrelevant, a file with no lines at all
+    # included.
     def no_lines?
-      lines.length.zero? || (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 ||= build_branches
+      @branches ||= BranchBuilder.new(self).call
     end
 
     def no_branches?
@@ -104,37 +101,27 @@ module SimpleCov
     end
 
     def branches_coverage_percent
-      coverage_statistics[:branch]&.percent
+      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 ||= build_branches_report
+      @branches_report ||=
+        branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
     end
 
-    #
-    # Select the covered branches
-    # Here we user tree schema because some conditions like case may have additional
-    # else that is not in declared inside the code but given by default by coverage report
-    #
-    # @return [Array]
-    #
+    # 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
-    #
-    # @return [Array]
-    #
     def missed_branches
       @missed_branches ||= branches.select(&:missed?)
     end
@@ -143,213 +130,30 @@ module SimpleCov
       branches_report.fetch(line_number, [])
     end
 
-    #
-    # Check if any branches missing on given line number
-    #
-    # @param [Integer] line_number
-    #
-    # @return [Boolean]
-    #
     def line_with_missed_branch?(line_number)
-      branches_for_line(line_number).select { |_type, count| count.zero? }.any?
-    end
-
-  private
-
-    # no_cov_chunks is zero indexed to work directly with the array holding the lines
-    def no_cov_chunks
-      @no_cov_chunks ||= build_no_cov_chunks
-    end
-
-    def build_no_cov_chunks
-      no_cov_lines = src.map.with_index(1).select { |line_src, _index| LinesClassifier.no_cov_line?(line_src) }
-
-      # 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.each_slice(2).map do |(_line_src_start, index_start), (_line_src_end, index_end)|
-        index_start..index_end
-      end
-    end
-
-    def load_source
-      lines = []
-      # The default encoding is UTF-8
-      File.open(filename, "rb:UTF-8") do |file|
-        current_line = file.gets
-
-        if shebang?(current_line)
-          lines << current_line
-          current_line = file.gets
-        end
-
-        read_lines(file, lines, current_line)
-      end
-    end
-
-    SHEBANG_REGEX = /\A#!/.freeze
-    def shebang?(line)
-      SHEBANG_REGEX.match?(line)
-    end
-
-    def read_lines(file, lines, current_line)
-      return lines unless current_line
-
-      set_encoding_based_on_magic_comment(file, current_line)
-      lines.concat([current_line], ensure_remove_undefs(file.readlines))
-    end
-
-    RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/.freeze
-    def set_encoding_based_on_magic_comment(file, line)
-      # Check for encoding magic comment
-      # Encoding magic comment must be placed at first line except for shebang
-      if (match = RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX.match(line))
-        file.set_encoding(match[1], "UTF-8")
-      end
+      branches_for_line(line_number).any? { |_type, count| count.zero? }
     end
 
-    def ensure_remove_undefs(file_lines)
-      # invalid/undef replace are technically not really necessary but nice to
-      # have and work around a JRuby incompatibility. Also moved here from
-      # simplecov-html to have encoding shenaningans in one place. See #866
-      # also setting these option on `file.set_encoding` doesn't seem to work
-      # properly so it has to be done here.
-      file_lines.each do |line|
-        if line.encoding == Encoding::UTF_8
-          line
-        else
-          line.encode!("UTF-8", invalid: :replace, undef: :replace)
-        end
-      end
+    def methods
+      @methods ||= MethodBuilder.new(self).call
     end
 
-    def build_lines
-      coverage_exceeding_source_warn if coverage_data["lines"].size > src.size
-      lines = src.map.with_index(1) do |src, i|
-        SimpleCov::SourceFile::Line.new(src, i, coverage_data["lines"][i - 1])
-      end
-      process_skipped_lines(lines)
+    def covered_methods
+      @covered_methods ||= methods.select(&:covered?)
     end
 
-    def process_skipped_lines(lines)
-      # the array the lines are kept in is 0-based whereas the line numbers in the nocov
-      # chunks are 1-based and are expected to be like this in other parts (and it's also
-      # arguably more understandable)
-      no_cov_chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
-
-      lines
-    end
-
-    def lines_strength
-      lines.sum { |line| line.coverage.to_i }
-    end
-
-    # Warning to identify condition from Issue #56
-    def coverage_exceeding_source_warn
-      warn "Warning: coverage data provided by Coverage [#{coverage_data['lines'].size}] exceeds number of lines in #{filename} [#{src.size}]"
-    end
-
-    #
-    # Build full branches report
-    # Root branches represent the wrapper of all condition state that
-    # have inside the branches
-    #
-    # @return [Hash]
-    #
-    def build_branches_report
-      branches.reject(&:skipped?).each_with_object({}) do |branch, coverage_statistics|
-        coverage_statistics[branch.report_line] ||= []
-        coverage_statistics[branch.report_line] << branch.report
-      end
-    end
-
-    #
-    # Call recursive method that transform our static hash to array of objects
-    # @return [Array]
-    #
-    def build_branches
-      coverage_branch_data = coverage_data.fetch("branches", {})
-      branches = coverage_branch_data.flat_map do |condition, coverage_branches|
-        build_branches_from(condition, coverage_branches)
-      end
-
-      process_skipped_branches(branches)
-    end
-
-    def process_skipped_branches(branches)
-      return branches if no_cov_chunks.empty?
-
-      branches.each do |branch|
-        branch.skipped! if no_cov_chunks.any? { |no_cov_chunk| branch.overlaps_with?(no_cov_chunk) }
-      end
-
-      branches
-    end
-
-    # Since we are dumping to and loading from JSON, and we have arrays as keys those
-    # don't make their way back to us intact e.g. just as a string
-    #
-    # We should probably do something different here, but as it stands these are
-    # our data structures that we write so eval isn't _too_ bad.
-    #
-    # See #801
-    #
-    def restore_ruby_data_structure(structure)
-      # Tests use the real data structures (except for integration tests) so no need to
-      # put them through here.
-      return structure if structure.is_a?(Array)
-
-      # rubocop:disable Security/Eval
-      eval structure
-      # rubocop:enable Security/Eval
-    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_start_line, * = restore_ruby_data_structure(condition)
-
-      branches.map do |branch_data, hit_count|
-        branch_data = restore_ruby_data_structure(branch_data)
-        build_branch(branch_data, hit_count, condition_start_line)
-      end
-    end
-
-    def build_branch(branch_data, hit_count, condition_start_line)
-      type, _id, start_line, _start_col, end_line, _end_col = branch_data
-
-      SourceFile::Branch.new(
-        start_line: start_line,
-        end_line:   end_line,
-        coverage:   hit_count,
-        inline:     start_line == condition_start_line,
-        type:       type
-      )
+    def missed_methods
+      @missed_methods ||= methods.select(&:missed?)
     end
 
-    def line_coverage_statistics
-      {
-        line: CoverageStatistics.new(
-          total_strength: lines_strength,
-          covered:  covered_lines.size,
-          missed:   missed_lines.size
-        )
-      }
+    def methods_coverage_percent
+      Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
+                       "Use `covered_percent(:method)`.")
+      covered_percent(:method)
     end
 
-    def branch_coverage_statistics
-      {
-        branch: CoverageStatistics.new(
-          covered: covered_branches.size,
-          missed:  missed_branches.size
-        )
-      }
+    def not_loaded?
+      !@loaded
     end
   end
 end