simplecov 1.0.3 → 1.1.0

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

@@ -12,77 +12,75 @@ module SimpleCov
         CRITERION_KEYS = {line: :lines, branch: :branches, method: :methods}.freeze
         private_constant :CRITERION_KEYS
 
-        def initialize(result)
-          @result = result
-          @errors = {}
-        end
-
-        def call
-          format_minimum_overall
-          format_minimum_by_file
-          format_minimum_by_group
-          format_maximum_overall
-          format_maximum_drop
-          @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
 
-      private
+        private
 
-        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_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
-        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 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
 
-        def record_by_file(violation)
-          by_file = bucket(: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, 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 format_minimum_by_group
-          violations = SimpleCov::CoverageViolations.minimum_by_group(@result, SimpleCov.minimum_coverage_by_group)
-          return if violations.empty?
+          def format_minimum_by_group(result, errors)
+            violations = SimpleCov::CoverageViolations.minimum_by_group(result, SimpleCov.minimum_coverage_by_group)
+            return if violations.empty?
 
-          # `bucket` lazily creates the errors key, so only touch it when
-          # there is a violation to record.
-          by_group = bucket(: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)
+            # `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] ||= {} #: Hash[untyped, untyped]
-        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 = {} #: 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_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 : {} #: Hash[Symbol, untyped]
-          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,19 +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`. And
-        # $stderr.puts, not `warn`: a status line should not reach
-        # `Warning.warn` hooks or vanish under `-W0` (see #1225).
-        $stderr.puts output_message(result) unless @silent # rubocop:disable Style/StderrPuts
+        CoverageJSONWriter.write(output_path, self.class.build_hash(result), result)
+        emit_status(result)
       end
 
     private
@@ -43,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,7 +10,7 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            Formatter.instance_for(formatter).format(result)
+            Formatter.format(formatter, result)
           rescue StandardError => e
             warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{(_ = e.backtrace).first})")
             nil

data/lib/simplecov/formatter/simple_formatter.rb

@@ -8,16 +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"
-        # `covered_percent` is nilable across criteria, but line stats are
-        # always measured, so the no-argument call can't return nil here.
-        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

@@ -13,6 +13,11 @@ module SimpleCov
     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
 

data/lib/simplecov/group_names.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Semantic names owned by result processing rather than user configuration.
+  module GroupNames
+    UNGROUPED = "Ungrouped"
+
+  module_function
+
+    # Group names are Hash keys, report labels, and JSON object keys all at
+    # once, so they are normalized to Strings up front: a Symbol spelling
+    # (`group :Controllers`) means the String, and anything else has no
+    # sensible serialized form. Normalizing before `validate!` also keeps
+    # `group :Ungrouped` from slipping past the reservation below.
+    def normalize(group_name)
+      case group_name
+      when String then group_name
+      when Symbol then group_name.to_s
+      else
+        raise SimpleCov::ConfigurationError,
+              "Group names must be Strings, got #{group_name.inspect} (#{group_name.class})"
+      end
+    end
+
+    def validate!(group_names)
+      return group_names unless group_names.include?(UNGROUPED)
+
+      raise SimpleCov::ConfigurationError,
+            "#{UNGROUPED.inspect} is reserved for files that do not match a configured group"
+    end
+  end
+end