better_coverage 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a4e60897af858e1892d567fe09a3b7db4cd4a68dc00c73dac3ff1ebf02cf6d8
+  data.tar.gz: 7705f3ce784cfdffaec20e3c196851076868b960ee1e314e9ce20fedfddddfe5
+SHA512:
+  metadata.gz: 90c7595e880ffeeddb5a9ed46570dea21b6b7085039aeeff958bd3805ab5af3d5a1388b8333d480d749d1b332c251d26bc9a1753385f6db3883dbd494778dd1f
+  data.tar.gz: f83349baeff5bb74b04037478d3ac8f60f18da104a708b7a5daecf81104905b6ffd89e6c4939a720b17ad53fdfdaf5194c3356a54f0f3ff554e8e26e27f5a17f

data/README.md

@@ -0,0 +1,53 @@
+# better_coverage
+
+**better_coverage** is a Minitest reporter that displays SimpleCov coverage results in Jest/Istanbul's console format with a directory tree structure.
+
+##### Why?
+
+Using better_coverage lets you see coverage in Jest's familiar table format right in your terminal. The reporter organizes files into a directory tree, shows uncovered line ranges (e.g., `5-12,18`), and applies the same color coding as Jest so your Ruby coverage reports look exactly like your JavaScript ones.
+
+## Usage
+
+Add the gem to your `Gemfile`:
+
+```ruby
+gem 'better_coverage'
+```
+
+Then configure in your `test/test_helper.rb`:
+
+```ruby
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest/reporters'
+require 'better_coverage'
+
+Minitest::Reporters.use! [
+  MinitestPlus::BetterCoverage.new
+]
+```
+
+Run your tests:
+
+```bash
+bundle exec rake test
+```
+
+#### Options
+
+```ruby
+MinitestPlus::BetterCoverage.new(
+  max_cols: 120,     # Terminal width (default: 80)
+  skip_empty: true,  # Skip files with no lines (default: false)
+  skip_full: true    # Skip 100% covered files (default: false)
+)
+```
+
+## Contributing
+
+Contributions are welcome! If you find a bug or have suggestions for improvement, please open an issue or submit a pull request.
+
+## License
+
+Apache License 2.0 © 2025 Mridang Agarwalla

data/lib/better_coverage.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'minitest/reporters'
+
+module MinitestPlus
+  # Jest-style coverage reporter for Minitest
+  # Displays SimpleCov coverage data in Jest's console format
+  class BetterCoverage < Minitest::Reporters::BaseReporter # rubocop:disable Metrics/ClassLength
+    NAME_COL = 4
+    PCT_COLS = 7
+    MISSING_COL = 17
+    TAB_SIZE = 1
+    DELIM = ' | '
+
+    def initialize(options = {})
+      super({})
+      @max_cols = options[:max_cols] || 80
+      @skip_empty = options[:skip_empty] || false
+      @skip_full = options[:skip_full] || false
+    end
+
+    def report
+      super
+      return unless defined?(SimpleCov)
+
+      result = SimpleCov.result
+      return unless result
+
+      print_coverage_table(result)
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def print_coverage_table(result)
+      files = result.files.sort_by(&:filename)
+      return if files.empty?
+
+      tree = build_tree(files)
+      name_width = [NAME_COL, calculate_max_width(tree, 0)].max
+      missing_width = MISSING_COL
+
+      if @max_cols.positive?
+        # Only 3 columns now: File | % Lines | Uncovered
+        pct_cols = DELIM.length + PCT_COLS + DELIM.length
+        max_remaining = @max_cols - (pct_cols + MISSING_COL)
+
+        name_width = max_remaining if name_width > max_remaining
+      end
+
+      puts
+      puts make_line(name_width, missing_width)
+      puts table_header(name_width, missing_width)
+      puts make_line(name_width, missing_width)
+      print_tree(tree, name_width, missing_width, 0)
+
+      total_pct = result.covered_percent
+      summary_row = summary_line(total_pct, name_width, missing_width)
+      puts make_line(name_width, missing_width)
+      puts summary_row
+      puts make_line(name_width, missing_width)
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def build_tree(files) # rubocop:disable Metrics/MethodLength
+      tree = {}
+
+      files.each do |file|
+        path = relative_path(file.filename)
+        parts = path.split('/')
+
+        current = tree
+        parts.each_with_index do |part, idx|
+          if idx == parts.length - 1
+            current[part] = { file: file }
+          else
+            current[part] ||= {}
+            current = current[part]
+          end
+        end
+      end
+
+      tree
+    end
+
+    def calculate_max_width(tree, depth)
+      max = 0
+      tree.each do |name, node|
+        width = (TAB_SIZE * depth) + name.length
+        max = width if width > max
+
+        next unless node[:file].nil?
+
+        child_max = calculate_max_width(node, depth + 1)
+        max = child_max if child_max > max
+      end
+      max
+    end
+
+    def print_tree(tree, name_width, missing_width, depth) # rubocop:disable Metrics/MethodLength
+      tree.keys.sort.each do |name|
+        node = tree[name]
+
+        if node[:file]
+          row = file_row(node[:file], name, name_width, missing_width, depth)
+          puts row unless row.empty?
+        else
+          row = dir_row(name, node, name_width, missing_width, depth)
+          puts row unless row.empty?
+          print_tree(node, name_width, missing_width, depth + 1)
+        end
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def dir_row(name, node, name_width, missing_width, depth)
+      files = collect_files(node)
+      return '' if files.empty?
+      return '' if @skip_empty && files.all? { |f| f.lines.empty? }
+
+      # Calculate average coverage across all files
+      pct = files.sum(&:covered_percent) / files.size
+
+      return '' if @skip_full && pct == 100.0 # rubocop:disable Lint/FloatComparison
+
+      elements = [
+        colorize_by_coverage(fill(name, name_width, tabs: depth), pct),
+        colorize_by_coverage(fill(pct.round(2), PCT_COLS, right: true), pct),
+        fill('', missing_width)
+      ]
+
+      "#{elements.join(DELIM)} "
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+    def collect_files(node)
+      files = []
+      node.each_value do |value|
+        if value[:file]
+          files << value[:file]
+        else
+          files.concat(collect_files(value))
+        end
+      end
+      files
+    end
+
+    def file_row(file, name, name_width, missing_width, depth)
+      return '' if @skip_empty && file.lines.empty?
+
+      pct_lines = file.covered_percent.round(2)
+      return '' if @skip_full && pct_lines == 100.0 # rubocop:disable Lint/FloatComparison
+
+      elements = [
+        colorize_by_coverage(fill(name, name_width, tabs: depth), pct_lines),
+        colorize_by_coverage(fill(pct_lines, PCT_COLS, right: true), pct_lines),
+        colorize_uncovered(fill(uncovered_lines(file), missing_width), pct_lines)
+      ]
+
+      "#{elements.join(DELIM)} "
+    end
+
+    def summary_line(total_pct, name_width, missing_width)
+      total_pct_rounded = total_pct.round(2)
+
+      elements = [
+        colorize_by_coverage(fill('All files', name_width), total_pct),
+        colorize_by_coverage(fill(total_pct_rounded, PCT_COLS, right: true), total_pct),
+        fill('', missing_width)
+      ]
+
+      "#{elements.join(DELIM)} "
+    end
+
+    def relative_path(filename)
+      filename.sub("#{SimpleCov.root}/", '')
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def uncovered_lines(file)
+      covered_lines = file.lines.reject(&:skipped?).map do |line|
+        [line.line_number, line.covered? || line.never?]
+      end
+
+      new_range = true
+      ranges = covered_lines.each_with_object([]) do |(line, hit), acum|
+        if hit
+          new_range = true
+        elsif new_range
+          acum.push([line])
+          new_range = false
+        else
+          acum.last[1] = line
+        end
+      end
+
+      ranges.map do |range|
+        range.length == 1 ? range[0].to_s : "#{range[0]}-#{range[1]}"
+      end.join(',')
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    def fill(text, width, right: false, tabs: 0) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      text = text.to_s
+      leading_spaces = tabs * TAB_SIZE
+      remaining = width - leading_spaces
+      leader = ' ' * leading_spaces
+
+      return leader if remaining <= 0
+
+      if remaining >= text.length
+        fill_str = ' ' * (remaining - text.length)
+        leader + (right ? fill_str + text : text + fill_str)
+      else
+        fill_str = '...'
+        length = remaining - fill_str.length
+        text = text[-length..] || text
+        leader + fill_str + text
+      end
+    end
+
+    def make_line(name_width, missing_width)
+      elements = [
+        '-' * name_width,
+        '-' * PCT_COLS,
+        '-' * missing_width
+      ]
+      "#{elements.join(DELIM.gsub(' ', '-'))}-"
+    end
+
+    def table_header(name_width, missing_width)
+      elements = [
+        fill('File', name_width),
+        fill('% Lines', PCT_COLS, right: true),
+        fill('Uncovered Line #s', missing_width)
+      ]
+      "#{elements.join(DELIM)} "
+    end
+
+    def colorize_by_coverage(text, pct)
+      case pct
+      when 80..100 then green(text)
+      when 50...80 then yellow(text)
+      else red(text)
+      end
+    end
+
+    def colorize_uncovered(text, pct)
+      pct == 100 ? text : red(text)
+    end
+
+    def green(text)
+      "\e[32m#{text}\e[0m"
+    end
+
+    def yellow(text)
+      "\e[33m#{text}\e[0m"
+    end
+
+    def red(text)
+      "\e[31m#{text}\e[0m"
+    end
+  end
+end

data/lib/minitest_plus/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MinitestPlus
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: better_coverage
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mridang Agarwalla
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Minitest reporter displaying SimpleCov coverage in Jest/Istanbul format
+  with directory tree
+email:
+- mridang.agarwalla@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/better_coverage.rb
+- lib/minitest_plus/version.rb
+homepage: https://github.com/mridang/minitest-reporters
+licenses:
+- Apache-2.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Jest-style coverage reporter for Minitest
+test_files: []