simplecov 1.0.0 → 1.1.1

data/lib/simplecov/formatter/json_formatter/errors_formatter.rb

@@ -12,71 +12,75 @@ module SimpleCov
         CRITERION_KEYS = {line: :lines, branch: :branches, method: :methods}.freeze
         private_constant :CRITERION_KEYS
 
-        def initialize(result)
-          @result = result
-          @errors = {}
-        end
+        class << self
+          def call(result)
+            errors = {} #: Hash[Symbol, Hash[untyped, untyped]]
+            format_minimum_overall(result, errors)
+            format_minimum_by_file(result, errors)
+            format_minimum_by_group(result, errors)
+            format_maximum_overall(result, errors)
+            format_maximum_drop(result, errors)
+            errors
+          end
 
-        def call
-          format_minimum_overall
-          format_minimum_by_file
-          format_minimum_by_group
-          format_maximum_overall
-          format_maximum_drop
-          @errors
-        end
+        private
 
-      private
+          def format_minimum_overall(result, errors)
+            SimpleCov::CoverageViolations.minimum_overall(result, SimpleCov.minimum_coverage).each do |violation|
+              bucket(errors, :minimum_coverage)[key_for(violation)] = expected_actual(violation)
+            end
+          end
 
-        def format_minimum_overall
-          SimpleCov::CoverageViolations.minimum_overall(@result, SimpleCov.minimum_coverage).each do |violation|
-            bucket(:minimum_coverage)[key_for(violation)] = expected_actual(violation)
+          def format_minimum_by_file(result, errors)
+            violations = SimpleCov::CoverageViolations.minimum_by_file(
+              result, SimpleCov.minimum_coverage_by_file, SimpleCov.minimum_coverage_by_file_overrides
+            )
+            violations.each { |violation| record_by_file(violation, errors) }
           end
-        end
 
-        def format_minimum_by_file
-          violations = SimpleCov::CoverageViolations.minimum_by_file(
-            @result, SimpleCov.minimum_coverage_by_file, SimpleCov.minimum_coverage_by_file_overrides
-          )
-          violations.each { |violation| record_by_file(violation) }
-        end
+          def record_by_file(violation, errors)
+            by_file = bucket(errors, :minimum_coverage_by_file)
+            file_bucket = by_file[violation.fetch(:project_filename)] ||= {} #: Hash[untyped, untyped]
+            file_bucket[key_for(violation)] = expected_actual(violation)
+          end
 
-        def record_by_file(violation)
-          file_bucket = bucket(:minimum_coverage_by_file)[violation.fetch(:project_filename)] ||= {}
-          file_bucket[key_for(violation)] = expected_actual(violation)
-        end
+          def format_minimum_by_group(result, errors)
+            violations = SimpleCov::CoverageViolations.minimum_by_group(result, SimpleCov.minimum_coverage_by_group)
+            return if violations.empty?
 
-        def format_minimum_by_group
-          violations = SimpleCov::CoverageViolations.minimum_by_group(@result, SimpleCov.minimum_coverage_by_group)
-          violations.each do |violation|
-            group_bucket = bucket(:minimum_coverage_by_group)[violation.fetch(:group_name)] ||= {}
-            group_bucket[key_for(violation)] = expected_actual(violation)
+            # `bucket` lazily creates the errors key, so only touch it when
+            # there is a violation to record.
+            by_group = bucket(errors, :minimum_coverage_by_group)
+            violations.each do |violation|
+              group_bucket = by_group[violation.fetch(:group_name)] ||= {} #: Hash[untyped, untyped]
+              group_bucket[key_for(violation)] = expected_actual(violation)
+            end
           end
-        end
 
-        def format_maximum_overall
-          SimpleCov::CoverageViolations.maximum_overall(@result, SimpleCov.maximum_coverage).each do |violation|
-            bucket(:maximum_coverage)[key_for(violation)] = expected_actual(violation)
+          def format_maximum_overall(result, errors)
+            SimpleCov::CoverageViolations.maximum_overall(result, SimpleCov.maximum_coverage).each do |violation|
+              bucket(errors, :maximum_coverage)[key_for(violation)] = expected_actual(violation)
+            end
           end
-        end
 
-        def format_maximum_drop
-          SimpleCov::CoverageViolations.maximum_drop(@result, SimpleCov.maximum_coverage_drop).each do |violation|
-            bucket(:maximum_coverage_drop)[key_for(violation)] =
-              {maximum: violation.fetch(:maximum), actual: violation.fetch(:actual)}
+          def format_maximum_drop(result, errors)
+            SimpleCov::CoverageViolations.maximum_drop(result, SimpleCov.maximum_coverage_drop).each do |violation|
+              bucket(errors, :maximum_coverage_drop)[key_for(violation)] =
+                {maximum: violation.fetch(:maximum), actual: violation.fetch(:actual)}
+            end
           end
-        end
 
-        def bucket(name)
-          @errors[name] ||= {}
-        end
+          def bucket(errors, name)
+            errors[name] ||= {} #: Hash[untyped, untyped]
+          end
 
-        def key_for(violation)
-          CRITERION_KEYS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion)))
-        end
+          def key_for(violation)
+            CRITERION_KEYS.fetch(SimpleCov.coverage_statistics_key(violation.fetch(:criterion)))
+          end
 
-        def expected_actual(violation)
-          {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
+          def expected_actual(violation)
+            {expected: violation.fetch(:expected), actual: violation.fetch(:actual)}
+          end
         end
       end
     end

data/lib/simplecov/formatter/json_formatter/result_hash_formatter.rb

@@ -22,105 +22,95 @@ module SimpleCov
         SCHEMA_URL = "https://raw.githubusercontent.com/simplecov-ruby/simplecov/main/schemas/coverage-v#{SCHEMA_VERSION}.schema.json".freeze
         private_constant :SCHEMA_VERSION, :SCHEMA_URL
 
-        def initialize(result, include_source: true)
-          @result = result
-          @include_source = include_source
-        end
-
-        def format
-          {
-            :$schema => SCHEMA_URL,
-            :meta => format_meta,
-            :total => format_coverage_statistics(@result.coverage_statistics),
-            :coverage => format_files,
-            :groups => format_groups,
-            :errors => ErrorsFormatter.new(@result).call
-          }
-        end
+        class << self
+          def format(result, include_source: true)
+            {
+              :$schema => SCHEMA_URL,
+              :meta => format_meta(result),
+              :total => format_coverage_statistics(result.coverage_statistics),
+              :coverage => format_files(result, include_source: include_source),
+              :groups => format_groups(result),
+              :errors => ErrorsFormatter.call(result)
+            }
+          end
 
-      private
+        private
 
-        def format_files
-          @result.files.to_h do |source_file|
-            [source_file.project_filename, SourceFileFormatter.new(source_file, include_source: @include_source).call]
+          def format_files(result, include_source:)
+            result.files.to_h do |source_file|
+              [source_file.project_filename, SourceFileFormatter.call(source_file, include_source: include_source)]
+            end
           end
-        end
 
-        def format_groups
-          @result.groups.to_h do |name, file_list|
-            stats = format_coverage_statistics(file_list.coverage_statistics)
-            [name, stats.merge(files: file_list.map(&:project_filename))]
+          def format_groups(result)
+            result.groups.to_h do |name, file_list|
+              stats = format_coverage_statistics(file_list.coverage_statistics)
+              [name, stats.merge(files: file_list.map(&:project_filename))]
+            end
           end
-        end
-
-        def format_meta
-          {
-            schema_version: SCHEMA_VERSION,
-            simplecov_version: SimpleCov::VERSION,
-            command_name: @result.command_name,
-            project_name: SimpleCov.project_name,
-            timestamp: @result.created_at.iso8601(3),
-            root: SimpleCov.root,
-            commit: git_commit,
-            primary_coverage: SimpleCov.primary_coverage.to_s
-          }.merge!(coverage_flags)
-        end
 
-        # Full git commit SHA of `SimpleCov.root`'s HEAD, or nil when the
-        # project isn't a git checkout or git isn't on PATH. Recorded so tools
-        # can recover the exact source a report was generated against, which
-        # matters most when `source_in_json false` drops the source text from
-        # coverage.json. stderr is captured (not forwarded) so a non-git project
-        # doesn't print git's diagnostics to the build.
-        def git_commit
-          output, status = Open3.capture2e("git", "-C", SimpleCov.root.to_s, "rev-parse", "HEAD")
-          status.success? ? output.strip : nil
-        rescue StandardError
-          nil
-        end
+          def format_meta(result)
+            {
+              schema_version: SCHEMA_VERSION,
+              simplecov_version: SimpleCov::VERSION,
+              command_name: result.command_name,
+              project_name: SimpleCov.project_name,
+              timestamp: result.created_at.iso8601(3),
+              root: SimpleCov.root,
+              commit: git_commit,
+              primary_coverage: SimpleCov.primary_coverage.to_s
+            }.merge!(coverage_flags)
+          end
 
-        def coverage_flags
-          {
-            line_coverage: line_coverage_enabled?,
-            branch_coverage: SimpleCov.branch_coverage?,
-            method_coverage: SimpleCov.method_coverage?
-          }
-        end
+          # Full git commit SHA of `SimpleCov.root`'s HEAD, or nil when the
+          # project isn't a git checkout or git isn't on PATH. Recorded so tools
+          # can recover the exact source a report was generated against, which
+          # matters most when `source_in_json false` drops the source text from
+          # coverage.json. stderr is captured (not forwarded) so a non-git project
+          # doesn't print git's diagnostics to the build.
+          def git_commit
+            output, status = Open3.capture2e("git", "-C", SimpleCov.root.to_s, "rev-parse", "HEAD")
+            status.success? ? output.strip : nil
+          rescue StandardError
+            nil
+          end
 
-        # Mirrors SourceFileFormatter's predicate so meta.line_coverage
-        # tracks exactly which configurations cause the formatter to
-        # emit line stats.
-        def line_coverage_enabled?
-          SimpleCov.coverage_criterion_enabled?(:line) || SimpleCov.coverage_criterion_enabled?(:oneshot_line)
-        end
+          def coverage_flags
+            {
+              line_coverage: SimpleCov.line_coverage?,
+              branch_coverage: SimpleCov.branch_coverage?,
+              method_coverage: SimpleCov.method_coverage?
+            }
+          end
 
-        def format_coverage_statistics(statistics)
-          result = {}
-          result[:lines]    = format_line_statistic(statistics[:line])      if statistics[:line]
-          result[:branches] = format_single_statistic(statistics[:branch])  if statistics[:branch]
-          result[:methods]  = format_single_statistic(statistics[:method])  if statistics[:method]
-          result
-        end
+          def format_coverage_statistics(statistics)
+            result = {} #: Hash[Symbol, untyped]
+            result[:lines]    = format_line_statistic(statistics[:line])      if statistics[:line]
+            result[:branches] = format_single_statistic(statistics[:branch])  if statistics[:branch]
+            result[:methods]  = format_single_statistic(statistics[:method])  if statistics[:method]
+            result
+          end
 
-        def format_line_statistic(stat)
-          {
-            covered: stat.covered,
-            missed: stat.missed,
-            omitted: stat.omitted,
-            total: stat.total,
-            percent: stat.percent,
-            strength: stat.strength
-          }
-        end
+          def format_line_statistic(stat)
+            {
+              covered: stat.covered,
+              missed: stat.missed,
+              omitted: stat.omitted,
+              total: stat.total,
+              percent: stat.percent,
+              strength: stat.strength
+            }
+          end
 
-        def format_single_statistic(stat)
-          {
-            covered: stat.covered,
-            missed: stat.missed,
-            total: stat.total,
-            percent: stat.percent,
-            strength: stat.strength
-          }
+          def format_single_statistic(stat)
+            {
+              covered: stat.covered,
+              missed: stat.missed,
+              total: stat.total,
+              percent: stat.percent,
+              strength: stat.strength
+            }
+          end
         end
       end
     end

data/lib/simplecov/formatter/json_formatter/source_file_formatter.rb

@@ -7,91 +7,85 @@ module SimpleCov
       # in coverage.json: source code plus per-enabled-criterion arrays
       # and totals.
       class SourceFileFormatter
-        def initialize(source_file, include_source: true)
-          @source_file = source_file
-          @include_source = include_source
-        end
-
-        def call
-          result = @include_source ? format_source_code : {}
-          result.merge!(line_coverage_section) if line_coverage_enabled?
-          result.merge!(branch_coverage_section) if SimpleCov.branch_coverage?
-          result.merge!(method_coverage_section) if SimpleCov.method_coverage?
-          result
-        end
+        class << self
+          def call(source_file, include_source: true)
+            result = include_source ? format_source_code(source_file) : {} #: Hash[Symbol, untyped]
+            result.merge!(line_coverage_section(source_file)) if SimpleCov.line_coverage?
+            result.merge!(branch_coverage_section(source_file)) if SimpleCov.branch_coverage?
+            result.merge!(method_coverage_section(source_file)) if SimpleCov.method_coverage?
+            result
+          end
 
-      private
+        private
 
-        # `:oneshot_line` is a synonym for `:line` for stats purposes
-        # (see `SimpleCov.coverage_statistics_key`), so treat either as
-        # "line coverage is on" for the line-block emit decisions.
-        def line_coverage_enabled?
-          SimpleCov.coverage_criterion_enabled?(:line) || SimpleCov.coverage_criterion_enabled?(:oneshot_line)
-        end
-
-        def format_source_code
-          {source: @source_file.lines.map { |line| ensure_utf8(line.src.chomp) }}
-        end
+          # No per-line encoding conversion here: SourceLoader guarantees
+          # every line leaves it as valid UTF-8 (transcoding declared
+          # encodings, scrubbing invalid bytes), and the converter copy
+          # this used to make per line was the single largest allocation
+          # source in formatting a large report.
+          def format_source_code(source_file)
+            {source: source_file.lines.map { |line| line.src.chomp }}
+          end
 
-        def ensure_utf8(str)
-          str.encode("UTF-8", invalid: :replace, undef: :replace)
-        end
+          def line_coverage_section(source_file)
+            covered = source_file.covered_lines.size
+            missed = source_file.missed_lines.size
+            {
+              lines: source_file.lines.map { |line| format_line(line) },
+              lines_covered_percent: source_file.covered_percent,
+              covered_lines: covered,
+              missed_lines: missed,
+              omitted_lines: source_file.never_lines.size,
+              total_lines: covered + missed
+            }
+          end
 
-        def line_coverage_section
-          covered = @source_file.covered_lines.size
-          missed = @source_file.missed_lines.size
-          {
-            lines: @source_file.lines.map { |line| format_line(line) },
-            lines_covered_percent: @source_file.covered_percent,
-            covered_lines: covered,
-            missed_lines: missed,
-            omitted_lines: @source_file.never_lines.size,
-            total_lines: covered + missed
-          }
-        end
+          def branch_coverage_section(source_file)
+            {
+              branches: source_file.branches.map { |branch| format_branch(branch) },
+              branches_covered_percent: source_file.covered_percent(:branch),
+              covered_branches: source_file.covered_branches.size,
+              missed_branches: source_file.missed_branches.size,
+              total_branches: source_file.total_branches.size
+            }
+          end
 
-        def branch_coverage_section
-          {
-            branches: @source_file.branches.map { |branch| format_branch(branch) },
-            branches_covered_percent: @source_file.covered_percent(:branch),
-            covered_branches: @source_file.covered_branches.size,
-            missed_branches: @source_file.missed_branches.size,
-            total_branches: @source_file.total_branches.size
-          }
-        end
+          def method_coverage_section(source_file)
+            covered = source_file.covered_methods.size
+            missed = source_file.missed_methods.size
 
-        def method_coverage_section
-          {
-            methods: @source_file.methods.map { |method| format_method(method) },
-            methods_covered_percent: @source_file.covered_percent(:method),
-            covered_methods: @source_file.covered_methods.size,
-            missed_methods: @source_file.missed_methods.size,
-            total_methods: @source_file.methods.size
-          }
-        end
+            {
+              methods: source_file.methods.map { |method| format_method(method) },
+              methods_covered_percent: source_file.covered_percent(:method),
+              covered_methods: covered,
+              missed_methods: missed,
+              total_methods: covered + missed
+            }
+          end
 
-        def format_line(line)
-          line.skipped? ? "ignored" : line.coverage
-        end
+          def format_line(line)
+            line.skipped? ? "ignored" : line.coverage
+          end
 
-        def format_branch(branch)
-          {
-            type: branch.type,
-            start_line: branch.start_line,
-            end_line: branch.end_line,
-            coverage: format_line(branch),
-            inline: branch.inline?,
-            report_line: branch.report_line
-          }
-        end
+          def format_branch(branch)
+            {
+              type: branch.type,
+              start_line: branch.start_line,
+              end_line: branch.end_line,
+              coverage: format_line(branch),
+              inline: branch.inline?,
+              report_line: branch.report_line
+            }
+          end
 
-        def format_method(method)
-          {
-            name: method.to_s,
-            start_line: method.start_line,
-            end_line: method.end_line,
-            coverage: format_line(method)
-          }
+          def format_method(method)
+            {
+              name: method.to_s,
+              start_line: method.start_line,
+              end_line: method.end_line,
+              coverage: format_line(method)
+            }
+          end
         end
       end
     end

data/lib/simplecov/formatter/json_formatter.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "base"
-require "fileutils"
+require_relative "coverage_json_writer"
 require "json"
-require "time"
 
 module SimpleCov
   module Formatter
@@ -11,7 +10,7 @@ module SimpleCov
     # standalone, alongside the HTML formatter, or by external tools that
     # consume SimpleCov output.
     class JSONFormatter < Base
-      FILENAME = "coverage.json"
+      FILENAME = CoverageJSONWriter::FILENAME
 
       # `include_source:` defaults to `SimpleCov.source_in_json` (true
       # by default) so the historical payload shape is unchanged.
@@ -19,17 +18,12 @@ module SimpleCov
       # setting (the HTML formatter, which feeds the client-side
       # viewer) pass `include_source: true` explicitly.
       def self.build_hash(result, include_source: SimpleCov.source_in_json)
-        ResultHashFormatter.new(result, include_source: include_source).format
+        ResultHashFormatter.format(result, include_source: include_source)
       end
 
       def format(result)
-        FileUtils.mkdir_p(output_path)
-        path = File.join(output_path, FILENAME)
-        warn_if_concurrent_overwrite(path, result)
-        File.write(path, JSON.pretty_generate(self.class.build_hash(result)))
-        # stderr, not stdout: this is a status message, not the program's
-        # output. Keeps the line out of pipelines like `rspec -f json`.
-        warn output_message(result) unless @silent
+        CoverageJSONWriter.write(output_path, self.class.build_hash(result), result)
+        emit_status(result)
       end
 
     private
@@ -41,41 +35,6 @@ module SimpleCov
       def entry_point_filename
         FILENAME
       end
-
-      # Warns when the existing coverage.json has a timestamp newer than this
-      # process's start time — a strong signal that a sibling test process
-      # (e.g., parallel_tests) wrote it while we were running, and that our
-      # write is about to clobber their data.
-      def warn_if_concurrent_overwrite(path, result)
-        start_time = SimpleCov.process_start_time or return
-        existing = existing_meta(path) or return
-        return unless existing[:timestamp] > start_time
-
-        # The HTML formatter also writes coverage.json (it shares the file as
-        # a side artifact), so when both formatters are configured the file we
-        # find was just written by our own run, not a concurrent one. A
-        # matching command_name means the same merged result, so there's
-        # nothing to lose by overwriting. See issue #1171.
-        return if existing[:command_name] == result.command_name
-
-        warn "simplecov: #{path} was written at #{existing[:timestamp].iso8601} — after " \
-             "this process started at #{start_time.iso8601}. Overwriting " \
-             "likely loses coverage data from a concurrent test run. For " \
-             "parallel test setups, use SimpleCov::ResultMerger or run a single " \
-             "collation step after all workers finish."
-      end
-
-      def existing_meta(path)
-        return nil unless File.exist?(path)
-
-        meta = JSON.parse(File.read(path), symbolize_names: true)
-        timestamp = meta.dig(:meta, :timestamp)
-        return nil unless timestamp
-
-        {timestamp: Time.iso8601(timestamp), command_name: meta.dig(:meta, :command_name)}
-      rescue JSON::ParserError, ArgumentError
-        nil
-      end
     end
   end
 end

data/lib/simplecov/formatter/multi_formatter.rb

@@ -10,18 +10,23 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            formatter.new.format(result)
+            Formatter.format(formatter, result)
           rescue StandardError => e
-            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{(_ = e.backtrace).first})")
             nil
           end
         end
       end
 
       def self.new(formatters = nil)
+        # Normalize eagerly and capture the list in the closure. Array()
+        # is pure for every accepted input shape (nil, single formatter,
+        # array, or another MultiFormatter class), so this is equivalent
+        # to the historical lazy per-instance memoization.
+        formatter_list = Array(formatters)
         Class.new do
           define_method :formatters do
-            @formatters ||= Array(formatters)
+            formatter_list
           end
           include InstanceMethods
         end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -8,14 +8,19 @@ module SimpleCov
     class SimpleFormatter
       # Takes a SimpleCov::Result and generates a string out of it
       def format(result)
-        result.groups.map { |name, files| format_group(name, files) }.join
+        criterion = SimpleCov.coverage_statistics_key(SimpleCov.primary_coverage)
+        result.groups.map { |name, files| format_group(name, files, criterion) }.join
       end
 
     private
 
-      def format_group(name, files)
+      def format_group(name, files, criterion)
         header = "Group: #{name}\n#{'=' * 40}\n"
-        body   = files.map { |file| "#{file.filename} (coverage: #{file.covered_percent.floor(2)}%)\n" }.join
+        # The configured primary criterion is enabled, so every result file
+        # carries its corresponding statistic despite the nilable public API.
+        body = files.map do |file|
+          "#{file.filename} (coverage: #{(_ = file.covered_percent(criterion)).floor(2)}%)\n"
+        end.join
         "#{header}#{body}\n"
       end
     end

data/lib/simplecov/formatter.rb

@@ -6,6 +6,18 @@ module SimpleCov
   # and can be wired up via `SimpleCov.formatter=`.
   # TODO: Documentation on how to build your own formatters
   module Formatter
+    # Formatters can be configured either as classes (instantiated
+    # fresh for every report) or as ready-built instances — the only
+    # way to reach constructor options like
+    # `HTMLFormatter.new(silent: true)`. See #1240.
+    def self.instance_for(formatter)
+      formatter.is_a?(Class) ? formatter.new : formatter
+    end
+
+    # Normalize a class or instance, then dispatch the result to it.
+    def self.format(formatter, result)
+      instance_for(formatter).format(result)
+    end
   end
 end