simplecov 0.22.0 → 1.0.0.rc1

data/lib/simplecov/source_file/line_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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!`.
+    class LineBuilder
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        lines = build_lines
+        mark_skipped(lines, @source_file.skip_chunks_for(:line))
+        lines
+      end
+
+    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.
+      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])
+        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.
+      def mark_skipped(lines, chunks)
+        chunks.each { |chunk| lines[(chunk.begin - 1)..(chunk.end - 1)].each(&:skipped!) }
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/method.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+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
+
+      def initialize(source_file, info, coverage)
+        @source_file = source_file
+        @class_name, @method_name, @start_line, @start_col, @end_line, @end_col = info
+        @coverage = coverage
+      end
+
+      def covered?
+        !skipped? && coverage.positive?
+      end
+
+      def skipped?
+        return @skipped if defined?(@skipped)
+
+        @skipped = lines.all?(&:skipped?)
+      end
+
+      # Flag the method as skipped directly, without going through its lines.
+      def skipped!
+        @skipped = true
+      end
+
+      def missed?
+        !skipped? && coverage.zero?
+      end
+
+      def lines
+        @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
+
+        start_line <= line_range.end && end_line >= line_range.begin
+      end
+
+      def to_s
+        "#{class_name}##{method_name}"
+      end
+    end
+  end
+end

data/lib/simplecov/source_file/method_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+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)
+        @source_file = source_file
+      end
+
+      def call
+        methods = @source_file.coverage_data.fetch("methods", {}).filter_map do |info, hit_count|
+          info = RubyDataParser.call(info)
+          next if eval_generated_to_ignore?(info)
+
+          SourceFile::Method.new(@source_file, info, hit_count)
+        end
+
+        process_skipped(methods)
+      end
+
+    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.
+      def eval_generated_to_ignore?(info)
+        return false unless SimpleCov.ignored_method?(:eval_generated)
+
+        positions = @source_file.real_source_positions
+        # simplecov:disable branch — nil branch fires only when Prism is unavailable
+        return false unless positions
+
+        # simplecov:enable branch
+
+        _class_name, name, start_line, * = info
+        !positions[: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
+end

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,77 @@
+# frozen_string_literal: true
+
+require "set"
+
+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 = []
+        # 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
+
+      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