simplecov 0.22.0 → 1.0.2

data/lib/simplecov/source_file/ruby_data_parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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.
+    module RubyDataParser
+    module_function
+
+      # Tests use the real data structures (except for integration tests)
+      # so no need to put them through here.
+      def call(structure)
+        return structure if structure.is_a?(Array)
+
+        parse_array_string(structure.to_s)
+      end
+
+      # Parse 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).
+        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
+
+        Array(array_node[1]).map { |element| parse_element(element) }
+      end
+
+      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`
+        else
+          # simplecov:disable — defensive fallback for unexpected Ripper node shapes
+          raise ArgumentError, "unexpected element: #{node.inspect}"
+          # simplecov:enable
+        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
+      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
+      end
+
+      # Undo 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) }
+      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.
+      def quote_inspected_class_segments(str)
+        str.gsub(/#<[^>]*>/) { |segment| %("#{segment.gsub('"', '\\"')}") }
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/skip_chunks.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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`.
+    class SkipChunks
+      @nocov_warned = Set.new
+      class << self
+        attr_reader :nocov_warned
+      end
+
+      def initialize(filename, src)
+        @filename = filename
+        @src = src
+      end
+
+      # `:method` ignores nocov chunks (Ruby's Coverage doesn't tie
+      # method entries to line ranges); `:line` / `:branch` honor both
+      # the nocov chunks and the per-criterion directive ranges.
+      def for(criterion)
+        if criterion == :method
+          directive_chunks.fetch(:method)
+        else
+          nocov_chunks + directive_chunks.fetch(criterion)
+        end
+      end
+
+      # no_cov_chunks is zero indexed to work directly with the array
+      # holding the lines.
+      def nocov_chunks
+        @nocov_chunks ||= build_nocov_chunks
+      end
+
+      def directive_chunks
+        @directive_chunks ||= Directive.disabled_ranges(@src)
+      end
+
+    private
+
+      def build_nocov_chunks
+        no_cov_lines = @src.map.with_index(1).select { |line_src, _index| LinesClassifier.no_cov_line?(line_src) }
+
+        warn_nocov_deprecation(no_cov_lines.first.last) 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.each_slice(2).map do |(_line_src_start, index_start), (_line_src_end, index_end)|
+          index_start..index_end
+        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)
+
+        token = SimpleCov.current_nocov_token
+        warn "#{@filename}:#{first_line_number}: [DEPRECATION] `# :#{token}:` is deprecated and will be removed " \
+             "in a future release. Replace with `# simplecov:disable` / `# simplecov:enable` block comments."
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/source_loader.rb

@@ -0,0 +1,63 @@
+# 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/undef bytes replaced — both for
+    # JRuby compatibility and to keep encoding shenanigans in one place
+    # (see #866).
+    module SourceLoader
+      SHEBANG_REGEX = /\A#!/
+      RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = /\A#\s*(?:-\*-)?\s*(?:en)?coding:\s*(\S+)\s*(?:-\*-)?\s*\z/
+
+    module_function
+
+      def call(filename)
+        lines = [] #: Array[String]
+        # The default encoding is UTF-8
+        File.open(filename, "rb:UTF-8") do |file|
+          current_line = file.gets
+
+          if current_line && shebang?(current_line)
+            lines << current_line
+            current_line = file.gets
+          end
+
+          read_lines(file, lines, current_line)
+        end
+      end
+
+      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
+
+      # Encoding magic comment must be placed at first line except for
+      # 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
+
+      # invalid/undef replace are technically not really necessary but
+      # nice to have and work around a JRuby incompatibility. Setting
+      # these options on `file.set_encoding` doesn't seem to work
+      # properly, so it has to be done here.
+      def ensure_remove_undefs(file_lines)
+        file_lines.each do |line|
+          # simplecov:disable — defensive: only fires for non-UTF-8 source files
+          line.encode!("UTF-8", invalid: :replace, undef: :replace) unless line.encoding == Encoding::UTF_8
+          # simplecov:enable
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/statistics.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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.
+    class Statistics
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        {
+          **line_statistics,
+          **branch_statistics,
+          **method_statistics
+        }
+      end
+
+    private
+
+      def line_statistics
+        sf = @source_file
+        {
+          line: CoverageStatistics.new(
+            total_strength: sf.lines.sum { |line| line.coverage.to_i },
+            covered: sf.covered_lines.size,
+            missed: sf.missed_lines.size,
+            omitted: sf.never_lines.size
+          )
+        }
+      end
+
+      def branch_statistics
+        sf = @source_file
+        # Files added via track_files but never loaded/required have no
+        # branch data. Report 0% instead of misleading 100% (see #902).
+        if sf.not_loaded? && sf.covered_branches.empty? && sf.missed_branches.empty?
+          return {branch: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
+        end
+
+        {branch: CoverageStatistics.new(covered: sf.covered_branches.size, missed: sf.missed_branches.size)}
+      end
+
+      def method_statistics
+        sf = @source_file
+        if sf.not_loaded? && sf.covered_methods.empty? && sf.missed_methods.empty?
+          return {method: CoverageStatistics.new(covered: 0, missed: 0, percent: 0.0)}
+        end
+
+        {method: CoverageStatistics.new(covered: sf.covered_methods.size, missed: sf.missed_methods.size)}
+      end
+    end
+  end
+end

data/lib/simplecov/source_file.rb

@@ -1,46 +1,64 @@
 # 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
+    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
 
-    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
+    # The source code for this file. Aliased as :source.
+    # Intentionally 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
-        }
+    # 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.
+    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
 
@@ -68,7 +86,7 @@ module SimpleCov
 
     # 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
@@ -76,65 +94,60 @@ module SimpleCov
       lines[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
+    # The coverage for this file in percent, for the given criterion (line by
+    # default). Returns 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
 
     def no_lines?
-      lines.length.zero? || (lines.length == never_lines.size)
+      lines.empty? || (lines.length == never_lines.size)
     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?
       total_branches.empty?
     end
 
+    # DEPRECATED: use `covered_percent(:branch)`.
     def branches_coverage_percent
-      coverage_statistics[:branch]&.percent
+      SimpleCov::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]
-    #
+    # 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.
     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 +156,34 @@ 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
+    # Return all methods detected in this source file
+    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
-        )
-      }
+    # DEPRECATED: use `covered_percent(:method)`.
+    def methods_coverage_percent
+      SimpleCov::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
-        )
-      }
+    # Whether this file was added via track_files but never loaded/required.
+    def not_loaded?
+      !@loaded
     end
   end
 end