simplecov 1.0.2 → 1.1.0

data/lib/simplecov/formatter/html_formatter.rb

@@ -3,47 +3,56 @@
 require "fileutils"
 require "json"
 require_relative "base"
+require_relative "../atomic_file"
+require_relative "../coverage_json"
 require_relative "json_formatter"
 
 module SimpleCov
   module Formatter
-    # Generates an HTML coverage report by writing a coverage_data.js file
-    # alongside pre-compiled static assets (index.html, application.js/css).
-    # Uses JSONFormatter.build_hash to serialize the result, then writes both
-    # coverage.json and coverage_data.js from the same in-memory hash.
+    # Generates a single self-contained HTML coverage report. The compiled
+    # template (public/index.html) already carries the viewer app's JS and
+    # CSS inline; format substitutes the coverage JSON at the data marker
+    # and writes one index.html, so the report can be mailed, uploaded as
+    # a single CI artifact, or opened from anywhere without sibling files.
+    # A coverage.json is written alongside from the same in-memory hash.
     class HTMLFormatter < Base
-      DATA_FILENAME = "coverage_data.js"
+      # Placeholder in the compiled template where the report's data goes.
+      DATA_MARKER = "<!-- SIMPLECOV_COVERAGE_DATA -->"
 
-      def format(result)
-        # `coverage_data.js` feeds the client-side viewer, which renders
-        # source from the embedded array — it always needs `source`,
-        # regardless of `SimpleCov.source_in_json`. The side-file
-        # `coverage.json` honors the setting so downstream tools that
-        # read source from disk can opt into a smaller payload. When
-        # the setting is at its default (true), the two files share a
-        # single serialization.
-        FileUtils.mkdir_p(output_path)
-        viewer_json = JSON.pretty_generate(JSONFormatter.build_hash(result, include_source: true))
-        coverage_json = SimpleCov.source_in_json ? viewer_json : JSON.pretty_generate(JSONFormatter.build_hash(result))
-
-        atomic_write(File.join(output_path, JSONFormatter::FILENAME), coverage_json)
-        atomic_write(File.join(output_path, DATA_FILENAME), "window.SIMPLECOV_DATA = #{viewer_json};\n")
+      # The sibling files a 1.0.0 through 1.0.3 report wrote next to
+      # index.html. They are stale the moment a single-file report lands
+      # on top of them — `simplecov serve` would happily keep serving the
+      # old coverage_data.js — so formatting removes the known names.
+      LEGACY_REPORT_FILES = %w[
+        coverage_data.js application.js application.css
+        favicon_green.png favicon_red.png favicon_yellow.png
+      ].freeze
 
-        copy_static_assets
-        # 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
+      def format(result)
+        # The inlined report data feeds the client-side viewer, which
+        # renders source from the embedded array — it always needs
+        # `source`, regardless of `SimpleCov.source_in_json`. The
+        # side-file `coverage.json` honors the setting so downstream
+        # tools that read source from disk can opt into a smaller
+        # payload. The embedded copy is serialized compactly (pretty
+        # printing puts every element of every per-line coverage array
+        # on its own indented line, roughly doubling the payload);
+        # coverage.json stays pretty-printed for human readers.
+        viewer_hash = JSONFormatter.build_hash(result, include_source: true)
+        json_hash = SimpleCov.source_in_json ? viewer_hash : source_less_hash(viewer_hash)
+        write_report_files(json_hash, viewer_hash, result)
+        emit_status(result)
       end
 
       # Generate HTML from a pre-existing coverage.json file without
       # needing a live SimpleCov::Result or even a running test suite.
+      # The round-trip through parse/generate compacts the (typically
+      # pretty-printed) input and rejects invalid JSON here rather than
+      # embedding it and failing at view time.
       def format_from_json(json_path, output_dir)
-        FileUtils.mkdir_p(output_dir)
-        json = File.read(json_path)
-        atomic_write(File.join(output_dir, DATA_FILENAME), "window.SIMPLECOV_DATA = #{json};\n")
-        copy_static_assets(output_dir)
+        data = ViewerDataValidator.call(SimpleCov::CoverageJSON.load(json_path))
+        json = JSON.generate(data)
+        AtomicFile.write(File.join(output_dir, "index.html"), render_report(json), binary: true)
       end
 
     private
@@ -52,27 +61,36 @@ module SimpleCov
         "index.html"
       end
 
-      def copy_static_assets(dest_dir = output_path)
-        Dir[File.join(public_dir, "*")].each do |src|
-          atomic_write(File.join(dest_dir, File.basename(src)), File.binread(src))
-        end
+      def source_less_hash(hash)
+        coverage = hash.fetch(:coverage).transform_values { |file| file.except(:source) }
+        hash.merge(coverage: coverage)
       end
 
-      # Write `content` at `dest` via a uniquely-named temp file in the
-      # same directory, then `File.rename` onto the final path. rename is
-      # atomic and overwrite-safe, so:
-      # - parallel writers can't race on an unlink-then-write window, and
-      # - read-only existing files (e.g. assets shipped at 0444 from
-      #   /nix/store) are replaced cleanly instead of triggering EACCES
-      #   from opening the existing path for writing.
-      def atomic_write(dest, content)
-        temp = "#{dest}.#{Process.pid}.#{rand(2**32).to_s(36)}"
-        begin
-          File.binwrite(temp, content)
-          File.rename(temp, dest)
-        ensure
-          FileUtils.rm_f(temp)
+      def write_report_files(json_hash, viewer_hash, result)
+        CoverageJSONWriter.write(output_path, json_hash, result)
+        AtomicFile.write(File.join(output_path, "index.html"), render_report(JSON.generate(viewer_hash)), binary: true)
+        FileUtils.rm_f(LEGACY_REPORT_FILES.map { |name| File.join(output_path, name) })
+      end
+
+      # Substitute the coverage JSON into the compiled template. `<` is
+      # escaped as \u003c — valid JSON, since `<` can only occur inside
+      # strings — so embedded source text containing "</script>" or
+      # "<!--" cannot terminate the surrounding <script> element. Block
+      # forms keep gsub/sub from interpreting backslashes in the JSON as
+      # replacement-string back-references.
+      def render_report(json)
+        # UTF-8 explicitly, not the locale's `Encoding.default_external`:
+        # the JSON payload is UTF-8, and substituting it into a template
+        # tagged US-ASCII (or a Windows code page) raises
+        # Encoding::CompatibilityError the moment either side carries a
+        # non-ASCII character.
+        template = File.read(File.join(public_dir, "index.html"), encoding: Encoding::UTF_8)
+        unless template.include?(DATA_MARKER)
+          raise "SimpleCov's HTML template is missing its #{DATA_MARKER.inspect} marker"
         end
+
+        data_script = "<script>window.SIMPLECOV_DATA = #{json.gsub('<') { '\u003c' }};</script>"
+        template.sub(DATA_MARKER) { data_script }
       end
 
       def public_dir
@@ -83,3 +101,5 @@ module SimpleCov
     end
   end
 end
+
+require_relative "html_formatter/viewer_data_validator"

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