rspec-tracer 0.9.3 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91a840ac79a148f2203602abe8f3c0d3b2019565532edd3ac04990b7ca7f1035
-  data.tar.gz: 0cd0bd13178616e79730c9f062098f8425964507fddd704f8c8725d2cad33050
+  metadata.gz: 85f9e51c157fec46651a9276dd4b098d4ff749ef07efe66284b8c317b2b4d288
+  data.tar.gz: 676738fc078e588ac51233939274ed7245c9cdf41145dd86a2cdf7ce7068060d
 SHA512:
-  metadata.gz: a98b3e279e71fcab7ceef12ec25998ece1bef3710c00dfed75a760cca7541ec2dad8b599dfdfa154f22b0f9eb9d32be74984b0696535956c831ea2cba6289a05
-  data.tar.gz: 907c29eb6e4ca0b013cf73ad3221a1137ec6ed7a44f493ec005b867a7d6808eaf99ec23c2ec1c35e7cb7c6e045be75eb49ca578162debc2fde8c3c8f786594a6
+  metadata.gz: c30eb3e54a8c19d7ad560cd03e860a12a9c5ead82a55af2b570e6a29737fb9c213a9ece0d0335b7882e8c65e851093e9f78710efe8df10e40fa54f01d2c84e51
+  data.tar.gz: fa0db0dd8257fc3841758fafbae04df2bd0abd64950b524ba3df10aace8a7965c11533d28dd78a51a4bfaf45dbdc34b634d48ccdce5b0c565a59ed3ee02cc7a1

data/CHANGELOG.md

@@ -1,3 +1,100 @@
+## [1.0.1] - 2026-04-24
+
+Long-tail maintenance release. Backports high-impact crash and correctness
+fixes from 1.1.x / 1.2.x onto the v1.0.0 foundation so users on Ruby 2.5 -
+3.0 who can't upgrade can still pick them up via `gem 'rspec-tracer', '~> 1.0'`.
+
+### Fixed
+
+- `Cache#cached_examples_coverage` returns `{}` (not `nil`) when `last_run.json`
+  is present but `examples_coverage.json` is missing, preventing a
+  NoMethodError on the next consumer. (B1, from v1.1.0)
+- `Runner#generate_missed_coverage` tolerates a nil cached coverage map and
+  nil per-line strength entries. (B2, from v1.1.0)
+- `Runner#register_file_dependency` / `#register_example_file_dependency`
+  skip gracefully when `SourceFile.from_path` / `.from_name` resolves to
+  nil (e.g. gem-generated examples whose path is absent at runtime),
+  instead of crashing. (B3, from v1.1.0)
+- `CoverageReporter#merge_coverage` treats a nil existing line-coverage
+  entry as 0 when summing skipped-test contributions. (B4, from v1.1.0)
+- `parallel_tests`-mode merge-worker election no longer deadlocks under
+  slow CI: the elected worker is now picked via
+  `::ParallelTests.first_process?` (immutable at spawn) instead of the
+  lock-file max TEST_ENV_NUMBER (racy on slow runners). (from v1.1.1)
+- Pin `encoding: 'UTF-8'` on every legacy `File.read` / `File.write` JSON
+  I/O site so shells with `LANG=` unset no longer crash the tracer on
+  multibyte spec descriptions. Cache (11), report_writer (12), and nine
+  other lib/ call sites covered. (from v1.1.2)
+- `SourceFile.from_path` computes the file digest via `File.binread`, hashing
+  raw bytes regardless of Encoding.default_external. (from v1.1.2)
+- `SourceFile.file_path` returns an absolute-external path unchanged when
+  the referenced file exists on disk (e.g. shared examples from vendored
+  gems at `/opt/bundle/gems/...`), preventing silent drop of dependency
+  registration. The guard is narrow — `start_with?('/') &&
+  !start_with?(root) && File.file?(path)` — so stripped-root cache forms
+  like `/spec/foo.rb` continue through the existing expand_path branch and
+  cache `file_name` keys stay byte-identical to v1.0.0. (C1, from v1.2.0)
+- `RemoteCache::Aws#upload_dir` error message corrected from
+  "Failed to download files from" to "Failed to upload files from". (C3,
+  from v1.2.0)
+- `RemoteCache::Validator::ValidationError` declared as a proper
+  `StandardError` subclass inside `Validator`; previously the
+  `TEST_SUITE_ID ^ TEST_SUITES` XOR-guard raised a `NameError:
+  uninitialized constant` instead of the intended validation error.
+  (from v1.2.0)
+- `enviornment` → `environment` typo in the same XOR-guard raise message.
+  (from v1.2.0)
+- `RemoteCache::Validator`'s single-suite `@cached_files_regex` anchored
+  with a trailing `$` so files with extensions beyond `.json` (e.g.
+  `.json.backup`) no longer match as cache files. (from v1.2.0)
+- `RemoteCache::Repo#initialize` guards `ENV['GIT_BRANCH']` for nil
+  before calling `.chomp`; previously a `NoMethodError: undefined
+  method 'chomp' for nil:NilClass` crashed the init path and masked
+  the intended `RepoError` message when `GIT_BRANCH` was not set in
+  the environment. (from v1.1.0 PR #51)
+- `RemoteCache::Repo#download_branch_refs` uses `FileUtils.rm_f`
+  (not `File.rm_f`) to clean up a partial `branch_refs.json` on a
+  failed AWS download. `File.rm_f` is undefined — `rm_f` is a
+  FileUtils method — so the failing-download branch would crash with
+  `NoMethodError` instead of cleaning up and logging. (from v1.1.0
+  PR #65)
+
+### Note on exclusions
+
+The following items from 1.1.x / 1.2.0 are intentionally NOT in this
+release to preserve the 1.0.0 cache-format contract and Ruby 2.5+ floor:
+
+- Default-filter expansion (1.1.0 — adds `/lib/rspec_tracer/`,
+  `/usr/local/lib/ruby/`, etc. to the default filters). Changing the
+  default filter set shifts the files present in `all_files.json` for
+  most users, which would invalidate existing caches on upgrade.
+- `USE_TEST_SUITE_ID_CACHE` opt-in ENV flag (1.2.0). This is a new
+  feature, not a bug fix; users who want it can upgrade to 1.2.x.
+- The 1.1+ configuration DSL refactor (anonymous block forwarding,
+  alias_method wrapping, ENV.fetch normalizations). These are
+  Ruby-3.1-exclusive in places and orthogonal to the crash-fix scope.
+
+### Ruby support
+
+Gemspec `required_ruby_version` unchanged at `>= 2.5.0`. CI gates
+Ruby 2.5 - 4.0 inclusive on `ubuntu-latest`.
+
+## [1.0.0] - 2021-10-21
+
+### Added
+
+- [JRuby](https://github.com/jruby/jruby) support
+- [Parallel Tests](https://github.com/grosser/parallel_tests) support
+
+### Breaking Changes
+
+The first run on this version will not use any cache on the CI because the number
+of files changed from eight to eleven, so there will be no appropriate cache to use.
+
+## [0.9.3] - 2021-10-03
+
+Generate reports ignoring duplicate examples (#42)
+
 ## [0.9.2] - 2021-09-30
 
 ### Fixed

data/README.md

@@ -1,5 +1,6 @@
 ![](./readme_files/rspec_tracer.png)
 
+[![Discord](https://badgen.net/badge/icon/discord?icon=discord&label)](https://discord.gg/H2G9yWeuRZ)
 [![Maintainability](https://api.codeclimate.com/v1/badges/eabce2757839c08d8f8d/maintainability)](https://codeclimate.com/github/avmnu-sng/rspec-tracer/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/eabce2757839c08d8f8d/test_coverage)](https://codeclimate.com/github/avmnu-sng/rspec-tracer/test_coverage)
 [![Gem Version](https://badge.fury.io/rb/rspec-tracer.svg)](https://badge.fury.io/rb/rspec-tracer)
@@ -34,6 +35,8 @@ installed.
 
 * [Demo](#demo)
 * [Getting Started](#getting-started)
+  * [Working with JRuby](#working-with-jruby)
+  * [Working with Parallel Tests](#working-with-parallel-tests)
 * [Configuring CI Caching](#configuring-ci-caching)
 * [Advanced Configuration](#advanced-configuration)
 * [Filters](#filters)
@@ -135,6 +138,28 @@ any of the application code.**
 3. After running your tests, open `rspec_tracer_report/index.html` in the browser
 of your choice.
 
+### Working with JRuby
+
+It is recommend to use **JRuby 9.2.10.0+**. Also, configure it with **`JRUBY_OPTS="--debug -X+O"`**
+or have the `.jrubyrc` file:
+
+```ruby
+debug.fullTrace=true
+objectspace.enabled=true
+```
+
+### Working with Parallel Tests
+
+The Rspec tracer, by default, supports working with [parallel_tests](https://github.com/grosser/parallel_tests/)
+gem. It maintains a lock file `/tmp/parallel_tests.lock` to identify the last
+running process. Usually, you are not required to do anything special unless you
+interrupt the execution in between and the process did not complete correctly.
+In such a case, you must delete the lock file before the next run.
+
+```sh
+rm -f /tmp/parallel_tests.lock && bundle exec parallel_rspec
+```
+
 ## Configuring CI Caching
 
 To enable RSpec Tracer to share cache between different builds on CI, update the
@@ -228,11 +253,11 @@ variables:
   ```
 - **`RSPEC_TRACER_COVERAGE_DIR`** to update the default coverage directory (`rspec_tracer_coverage`).
   ```sh
-  export RSPEC_TRACER_CACHE_DIR=/tmp/rspec_tracer_coverage
+  export RSPEC_TRACER_COVERAGE_DIR=/tmp/rspec_tracer_coverage
   ```
 - **`RSPEC_TRACER_REPORT_DIR`** to update the default html reports directory (`rspec_tracer_report`).
   ```sh
-  export RSPEC_TRACER_CACHE_DIR=/tmp/rspec_tracer_report
+  export RSPEC_TRACER_REPORT_DIR=/tmp/rspec_tracer_report
   ```
 
 These settings are available through environment variables because the rake tasks

data/lib/rspec_tracer/cache.rb

@@ -2,137 +2,175 @@
 
 module RSpecTracer
   class Cache
-    attr_reader :all_examples, :interrupted_examples, :flaky_examples, :failed_examples,
-                :pending_examples, :all_files, :dependency, :run_id
+    attr_reader :all_examples, :duplicate_examples, :interrupted_examples,
+                :flaky_examples, :failed_examples, :pending_examples, :skipped_examples,
+                :all_files, :dependency, :examples_coverage, :run_id
 
     def initialize
-      @run_id = last_run_id
-      @cache_dir = File.join(RSpecTracer.cache_path, @run_id) if @run_id
-
       @cached = false
 
       @all_examples = {}
+      @duplicate_examples = {}
       @interrupted_examples = Set.new
       @flaky_examples = Set.new
       @failed_examples = Set.new
       @pending_examples = Set.new
       @all_files = {}
       @dependency = Hash.new { |hash, key| hash[key] = Set.new }
+      @examples_coverage = {}
     end
 
     def load_cache_for_run
-      return if @run_id.nil? || @cached
+      return if @cached
+
+      cache_path = RSpecTracer.cache_path
+      cache_path = File.dirname(cache_path) if RSpecTracer.parallel_tests?
+      run_id = last_run_id(cache_path)
+
+      return if run_id.nil?
 
       starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      cache_dir = File.join(cache_path, run_id)
 
-      load_all_examples_cache
-      load_flaky_examples_cache
-      load_failed_examples_cache
-      load_pending_examples_cache
-      load_all_files_cache
-      load_dependency_cache
+      load_all_examples_cache(cache_dir)
+      load_duplicate_examples_cache(cache_dir)
+      load_interrupted_examples_cache(cache_dir)
+      load_flaky_examples_cache(cache_dir)
+      load_failed_examples_cache(cache_dir)
+      load_pending_examples_cache(cache_dir)
+      load_all_files_cache(cache_dir)
+      load_dependency_cache(cache_dir)
 
       ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       @cached = true
 
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
 
-      puts "RSpec tracer loaded cache from #{@cache_dir} (took #{elpased})"
+      puts "RSpec tracer loaded cache from #{cache_dir} (took #{elapsed})"
     end
 
     def cached_examples_coverage
-      return @examples_coverage if defined?(@examples_coverage)
-      return @examples_coverage = {} if @run_id.nil?
+      return @examples_coverage if @examples_coverage_loaded
+
+      @examples_coverage_loaded = true
+
+      cache_path = RSpecTracer.cache_path
+      cache_path = File.dirname(cache_path) if RSpecTracer.parallel_tests?
+      run_id = last_run_id(cache_path)
+
+      return @examples_coverage if run_id.nil?
 
       starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      coverage = load_examples_coverage_cache
+      cache_dir = File.join(cache_path, run_id)
+      load_examples_coverage_cache(cache_dir)
       ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elpased = RSpecTracer::TimeFormatter.format_time(ending - starting)
+      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
 
-      puts "RSpec tracer loaded cached examples coverage (took #{elpased})" if RSpecTracer.verbose?
+      puts "RSpec tracer loaded cached examples coverage (took #{elapsed})" if RSpecTracer.verbose?
 
-      coverage
+      @examples_coverage
     end
 
     private
 
-    def last_run_id
-      file_name = File.join(RSpecTracer.cache_path, 'last_run.json')
+    def last_run_id(cache_dir)
+      file_name = File.join(cache_dir, 'last_run.json')
 
       return unless File.file?(file_name)
 
-      JSON.parse(File.read(file_name))['run_id']
+      JSON.parse(File.read(file_name, encoding: 'UTF-8'))['run_id']
     end
 
-    def load_all_examples_cache
-      file_name = File.join(@cache_dir, 'all_examples.json')
+    def load_all_examples_cache(cache_dir, discard_run_reason: true)
+      file_name = File.join(cache_dir, 'all_examples.json')
 
       return unless File.file?(file_name)
 
-      @all_examples = JSON.parse(File.read(file_name)).transform_values do |examples|
+      @all_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).transform_values do |examples|
         examples.transform_keys(&:to_sym)
       end
 
       @all_examples.each_value do |example|
-        if example.key?(:execution_result)
-          example[:execution_result].transform_keys!(&:to_sym)
-        else
-          @interrupted_examples << example[:example_id]
-        end
+        example[:execution_result].transform_keys!(&:to_sym) if example.key?(:execution_result)
+        example[:run_reason] = nil if discard_run_reason
+      end
+    end
+
+    def load_duplicate_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'duplicate_examples.json')
+
+      return unless File.file?(file_name)
 
-        example[:run_reason] = nil
+      @duplicate_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).transform_values do |examples|
+        examples.map { |example| example.transform_keys(&:to_sym) }
       end
     end
 
-    def load_flaky_examples_cache
-      file_name = File.join(@cache_dir, 'flaky_examples.json')
+    def load_interrupted_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'interrupted_examples.json')
+
+      return unless File.file?(file_name)
+
+      @interrupted_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).to_set
+    end
+
+    def load_flaky_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'flaky_examples.json')
+
+      return unless File.file?(file_name)
+
+      @flaky_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).to_set
+    end
+
+    def load_failed_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'failed_examples.json')
 
       return unless File.file?(file_name)
 
-      @flaky_examples = JSON.parse(File.read(file_name)).to_set
+      @failed_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).to_set
     end
 
-    def load_failed_examples_cache
-      file_name = File.join(@cache_dir, 'failed_examples.json')
+    def load_pending_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'pending_examples.json')
 
       return unless File.file?(file_name)
 
-      @failed_examples = JSON.parse(File.read(file_name)).to_set
+      @pending_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).to_set
     end
 
-    def load_pending_examples_cache
-      file_name = File.join(@cache_dir, 'pending_examples.json')
+    def load_skipped_examples_cache(cache_dir)
+      file_name = File.join(cache_dir, 'skipped_examples.json')
 
       return unless File.file?(file_name)
 
-      @pending_examples = JSON.parse(File.read(file_name)).to_set
+      @skipped_examples = JSON.parse(File.read(file_name, encoding: 'UTF-8')).to_set
     end
 
-    def load_all_files_cache
-      file_name = File.join(@cache_dir, 'all_files.json')
+    def load_all_files_cache(cache_dir)
+      file_name = File.join(cache_dir, 'all_files.json')
 
       return unless File.file?(file_name)
 
-      @all_files = JSON.parse(File.read(file_name)).transform_values do |files|
+      @all_files = JSON.parse(File.read(file_name, encoding: 'UTF-8')).transform_values do |files|
         files.transform_keys(&:to_sym)
       end
     end
 
-    def load_dependency_cache
-      file_name = File.join(@cache_dir, 'dependency.json')
+    def load_dependency_cache(cache_dir)
+      file_name = File.join(cache_dir, 'dependency.json')
 
       return unless File.file?(file_name)
 
-      @dependency = JSON.parse(File.read(file_name)).transform_values(&:to_set)
+      @dependency = JSON.parse(File.read(file_name, encoding: 'UTF-8')).transform_values(&:to_set)
     end
 
-    def load_examples_coverage_cache
-      file_name = File.join(@cache_dir, 'examples_coverage.json')
+    def load_examples_coverage_cache(cache_dir)
+      file_name = File.join(cache_dir, 'examples_coverage.json')
 
       return unless File.file?(file_name)
 
-      @examples_coverage = JSON.parse(File.read(file_name))
+      @examples_coverage = JSON.parse(File.read(file_name, encoding: 'UTF-8'))
     end
   end
 end

data/lib/rspec_tracer/configuration.rb

@@ -25,13 +25,14 @@ module RSpecTracer
     end
 
     def cache_dir
-      @cache_dir ||= (ENV['RSPEC_TRACER_CACHE_DIR'] || DEFAULT_CACHE_DIR)
+      @cache_dir ||= ENV['RSPEC_TRACER_CACHE_DIR'] || DEFAULT_CACHE_DIR
     end
 
     def cache_path
       @cache_path ||= begin
         cache_path = File.expand_path(cache_dir, root)
-        cache_path = File.join(cache_path, ENV['TEST_SUITE_ID'].to_s)
+        cache_path = File.join(cache_path, ENV['TEST_SUITE_ID'].to_s) if ENV['TEST_SUITE_ID']
+        cache_path = File.join(cache_path, parallel_tests_id) if RSpecTracer.parallel_tests?
 
         FileUtils.mkdir_p(cache_path)
 
@@ -40,13 +41,14 @@ module RSpecTracer
     end
 
     def report_dir
-      @report_dir ||= (ENV['RSPEC_TRACER_REPORT_DIR'] || DEFAULT_REPORT_DIR)
+      @report_dir ||= ENV['RSPEC_TRACER_REPORT_DIR'] || DEFAULT_REPORT_DIR
     end
 
     def report_path
       @report_path ||= begin
         report_path = File.expand_path(report_dir, root)
-        report_path = File.join(report_path, ENV['TEST_SUITE_ID'].to_s)
+        report_path = File.join(report_path, ENV['TEST_SUITE_ID'].to_s) if ENV['TEST_SUITE_ID']
+        report_path = File.join(report_path, parallel_tests_id) if RSpecTracer.parallel_tests?
 
         FileUtils.mkdir_p(report_path)
 
@@ -55,13 +57,14 @@ module RSpecTracer
     end
 
     def coverage_dir
-      @coverage_dir ||= (ENV['RSPEC_TRACER_COVERAGE_DIR'] || DEFAULT_COVERAGE_DIR)
+      @coverage_dir ||= ENV['RSPEC_TRACER_COVERAGE_DIR'] || DEFAULT_COVERAGE_DIR
     end
 
     def coverage_path
       @coverage_path ||= begin
         coverage_path = File.expand_path(coverage_dir, root)
-        coverage_path = File.join(coverage_path, ENV['TEST_SUITE_ID'].to_s)
+        coverage_path = File.join(coverage_path, ENV['TEST_SUITE_ID'].to_s) if ENV['TEST_SUITE_ID']
+        coverage_path = File.join(coverage_path, parallel_tests_id) if RSpecTracer.parallel_tests?
 
         FileUtils.mkdir_p(coverage_path)
 
@@ -93,6 +96,10 @@ module RSpecTracer
       @coverage_filters ||= []
     end
 
+    def parallel_tests_lock_file
+      '/tmp/parallel_tests.lock'
+    end
+
     def verbose?
       @verbose ||= (ENV.fetch('RSPEC_TRACER_VERBOSE', 'false') == 'true')
     end
@@ -103,12 +110,12 @@ module RSpecTracer
 
     private
 
-    def test_suite_id
-      suite_id = ENV.fetch('TEST_SUITE_ID', '')
-
-      return if suite_id.empty?
-
-      suite_id
+    def parallel_tests_id
+      if ParallelTests.first_process?
+        'parallel_tests_1'
+      else
+        "parallel_tests_#{ENV.fetch('TEST_ENV_NUMBER', nil)}"
+      end
     end
 
     def at_exit(&block)

data/lib/rspec_tracer/coverage_merger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  class CoverageMerger
+    attr_reader :coverage
+
+    def initialize
+      @coverage = {}
+    end
+
+    def merge(reports_dir)
+      return if RSpecTracer.simplecov?
+
+      reports_dir.each do |report_dir|
+        next unless File.directory?(report_dir)
+
+        cache_coverage = JSON.parse(File.read("#{report_dir}/coverage.json",
+                                              encoding: 'UTF-8'))['RSpecTracer']['coverage']
+
+        cache_coverage.each_pair do |file_name, line_coverage|
+          unless @coverage.key?(file_name)
+            @coverage[file_name] = line_coverage
+
+            next
+          end
+
+          merge_line_coverage(file_name, line_coverage)
+        end
+      end
+    end
+
+    private
+
+    def merge_line_coverage(file_name, line_coverage)
+      line_coverage.each_with_index do |strength, line_number|
+        next unless strength && @coverage[file_name][line_number]
+
+        @coverage[file_name][line_number] += strength
+      end
+    end
+  end
+end

data/lib/rspec_tracer/coverage_reporter.rb

@@ -72,7 +72,8 @@ module RSpecTracer
                             end
 
         line_coverage.each_pair do |line_number, strength|
-          line_coverage_dup[line_number.to_i] += strength
+          index = line_number.to_i
+          line_coverage_dup[index] = (line_coverage_dup[index] || 0) + strength
         end
 
         @coverage[file_path] = line_coverage_dup.freeze
@@ -88,8 +89,6 @@ module RSpecTracer
       all_files.each do |file_path|
         @coverage[file_path] ||= line_stub(file_path).freeze
       end
-
-      generate_final_coverage_stat
     end
 
     private
@@ -131,31 +130,6 @@ module RSpecTracer
       all_files.sort
     end
 
-    def generate_final_coverage_stat
-      total_loc = 0
-      covered_loc = 0
-
-      @coverage.each_pair do |_file_path, line_coverage|
-        line_coverage.each do |strength|
-          next if strength.nil?
-
-          total_loc += 1
-          covered_loc += 1 if strength.positive?
-        end
-      end
-
-      @coverage_stat = {
-        total_lines: total_loc,
-        covered_lines: covered_loc,
-        missed_lines: total_loc - covered_loc,
-        covered_percent: 0.0
-      }
-
-      return if total_loc.zero?
-
-      @coverage_stat[:covered_percent] = (100.0 * covered_loc / total_loc).round(2)
-    end
-
     def peek_coverage
       data = ::Coverage.peek_result.select do |file_path, _|
         file_path.start_with?(RSpecTracer.root)
@@ -167,8 +141,17 @@ module RSpecTracer
     end
 
     def line_stub(file_path)
+      case RUBY_ENGINE
+      when 'ruby'
+        ruby_line_stub(file_path)
+      when 'jruby'
+        jruby_line_stub(file_path)
+      end
+    end
+
+    def ruby_line_stub(file_path)
       lines = File.foreach(file_path).map { nil }
-      iseqs = [RubyVM::InstructionSequence.compile_file(file_path)]
+      iseqs = [::RubyVM::InstructionSequence.compile_file(file_path)]
 
       until iseqs.empty?
         iseq = iseqs.pop
@@ -179,5 +162,26 @@ module RSpecTracer
 
       lines
     end
+
+    def jruby_line_stub(file_path)
+      lines = File.foreach(file_path).map { nil }
+      root_node = ::JRuby.parse(File.read(file_path, encoding: 'UTF-8'))
+
+      visitor = org.jruby.ast.visitor.NodeVisitor.impl do |_name, node|
+        if node.newline?
+          if node.respond_to?(:position)
+            lines[node.position.line] = 0
+          else
+            lines[node.line] = 0
+          end
+        end
+
+        node.child_nodes.each { |child| child&.accept(visitor) }
+      end
+
+      root_node.accept(visitor)
+
+      lines
+    end
   end
 end

data/lib/rspec_tracer/coverage_writer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  class CoverageWriter
+    def initialize(file_name, reporter)
+      @file_name = file_name
+      @reporter = reporter
+    end
+
+    def write_report
+      report = {
+        RSpecTracer: {
+          coverage: @reporter.coverage,
+          timestamp: Time.now.utc.to_i
+        }
+      }
+
+      File.write(@file_name, JSON.pretty_generate(report), encoding: 'UTF-8')
+    end
+
+    def print_stats(elapsed_time)
+      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      total, covered, percent = coverage_stats
+
+      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      elapsed = RSpecTracer::TimeFormatter.format_time((ending - starting) + elapsed_time)
+
+      puts <<-STATS.strip.gsub(/\s+/, ' ')
+        Coverage report generated for RSpecTracer to #{@file_name}.
+        #{covered} / #{total} LOC (#{percent}%) covered (took #{elapsed})
+      STATS
+    end
+
+    private
+
+    def coverage_stats
+      total_loc = 0
+      covered_loc = 0
+      covered_percent = 0.0
+
+      @reporter.coverage.each_pair do |_file_path, line_coverage|
+        line_coverage.each do |strength|
+          next if strength.nil?
+
+          total_loc += 1
+          covered_loc += 1 if strength.positive?
+        end
+      end
+
+      return [total_loc, covered_loc, covered_percent] if total_loc.zero?
+
+      covered_percent = (100.0 * covered_loc / total_loc).round(2)
+
+      [total_loc, covered_loc, covered_percent]
+    end
+  end
+end