cov-loupe 3.0.0

data/spec/option_parsers/env_options_parser_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::OptionParsers::EnvOptionsParser do
+  let(:parser) { described_class.new }
+
+  around do |example|
+    original_value = ENV['COV_LOUPE_OPTS']
+    example.run
+  ensure
+    ENV['COV_LOUPE_OPTS'] = original_value
+  end
+
+  describe '#parse_env_opts' do
+    context 'with valid inputs' do
+      it 'returns empty array when environment variable is not set' do
+        ENV.delete('COV_LOUPE_OPTS')
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'returns empty array when environment variable is empty string' do
+        ENV['COV_LOUPE_OPTS'] = ''
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'returns empty array when environment variable contains only whitespace' do
+        ENV['COV_LOUPE_OPTS'] = '   '
+        expect(parser.parse_env_opts).to eq([])
+      end
+
+      it 'parses simple options correctly' do
+        ENV['COV_LOUPE_OPTS'] = '--error-mode off --format json'
+        expect(parser.parse_env_opts).to eq(['--error-mode', 'off', '--format', 'json'])
+      end
+
+      it 'handles quoted strings with spaces' do
+        ENV['COV_LOUPE_OPTS'] = '--resultset "/path/to/my file.json"'
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/to/my file.json'])
+      end
+
+      it 'handles complex shell escaping scenarios' do
+        ENV['COV_LOUPE_OPTS'] = '--resultset "/path/with spaces/file.json" --error-mode on'
+        expect(parser.parse_env_opts)
+          .to eq(['--resultset', '/path/with spaces/file.json', '--error-mode', 'on'])
+      end
+
+      it 'handles single quotes' do
+        ENV['COV_LOUPE_OPTS'] = "--resultset '/path/with spaces/file.json'"
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/with spaces/file.json'])
+      end
+
+      it 'handles escaped characters' do
+        ENV['COV_LOUPE_OPTS'] = '--resultset /path/with\\ spaces/file.json'
+        expect(parser.parse_env_opts).to eq(['--resultset', '/path/with spaces/file.json'])
+      end
+
+      it 'handles mixed quoting styles' do
+        ENV['COV_LOUPE_OPTS'] = '--option1 "value with spaces" --option2 \'another value\''
+        expect(parser.parse_env_opts).to eq(
+          ['--option1', 'value with spaces', '--option2', 'another value']
+        )
+      end
+    end
+
+    context 'with malformed inputs' do
+      it 'raises ConfigurationError for unmatched double quotes' do
+        ENV['COV_LOUPE_OPTS'] = '--resultset "unterminated string'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(CovLoupe::ConfigurationError, /Invalid COV_LOUPE_OPTS format/)
+      end
+
+      it 'raises ConfigurationError for unmatched single quotes' do
+        ENV['COV_LOUPE_OPTS'] = "--resultset 'unterminated string"
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(CovLoupe::ConfigurationError, /Invalid COV_LOUPE_OPTS format/)
+      end
+
+      it 'raises ConfigurationError with descriptive message' do
+        ENV['COV_LOUPE_OPTS'] = '--option "bad quote'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(CovLoupe::ConfigurationError) do |error|
+          expect(error.message).to include('Invalid COV_LOUPE_OPTS format')
+          expect(error.message).to include('Unmatched') # from Shellwords error
+        end
+      end
+
+      it 'handles multiple quoting errors' do
+        ENV['COV_LOUPE_OPTS'] = '"first "second "third'
+
+        expect do
+          parser.parse_env_opts
+        end.to raise_error(CovLoupe::ConfigurationError, /Invalid COV_LOUPE_OPTS format/)
+      end
+    end
+  end
+
+  describe '#pre_scan_error_mode' do
+    let(:error_mode_normalizer) { parser.send(:method, :normalize_error_mode) }
+
+    context 'when error-mode is found' do
+      it 'extracts error-mode with space separator' do
+        argv = ['--error-mode', 'debug', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:debug)
+      end
+
+      it 'extracts error-mode with equals separator' do
+        argv = ['--error-mode=off', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:off)
+      end
+
+      it 'handles error-mode with equals but empty value' do
+        argv = ['--error-mode=', '--other-option']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        # Empty value after = explicitly returns nil (line 32)
+        expect(result).to be_nil
+      end
+
+      it 'returns first error-mode when multiple are present' do
+        argv = ['--error-mode', 'log', '--error-mode', 'off']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to eq(:log)
+      end
+    end
+
+    context 'when error-mode is not found' do
+      it 'returns nil when no error-mode is present' do
+        argv = ['--other-option', 'value']
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for empty argv' do
+        argv = []
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: error_mode_normalizer)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when handling errors during pre-scan' do
+      it 'returns nil when normalizer raises an error' do
+        faulty_normalizer = ->(_) { raise StandardError, 'Intentional error' }
+        argv = ['--error-mode', 'log']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil when normalizer raises ArgumentError' do
+        faulty_normalizer = ->(_) { raise ArgumentError, 'Bad argument' }
+        argv = ['--error-mode', 'log']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+
+      it 'returns nil when normalizer raises RuntimeError' do
+        faulty_normalizer = ->(_) { raise 'Runtime problem' }
+        argv = ['--error-mode=off']
+
+        result = parser.pre_scan_error_mode(argv, error_mode_normalizer: faulty_normalizer)
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe '#normalize_error_mode (private)' do
+    it 'normalizes "off" to :off' do
+      expect(parser.send(:normalize_error_mode, 'off')).to eq(:off)
+      expect(parser.send(:normalize_error_mode, 'OFF')).to eq(:off)
+      expect(parser.send(:normalize_error_mode, 'Off')).to eq(:off)
+    end
+
+    it 'normalizes "log" to :log' do
+      expect(parser.send(:normalize_error_mode, 'log')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'LOG')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'Log')).to eq(:log)
+    end
+
+    it 'normalizes "debug" to :debug' do
+      expect(parser.send(:normalize_error_mode, 'debug')).to eq(:debug)
+      expect(parser.send(:normalize_error_mode, 'DEBUG')).to eq(:debug)
+    end
+
+    it 'defaults unknown values to :log' do
+      expect(parser.send(:normalize_error_mode, 'unknown')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, 'invalid')).to eq(:log)
+      expect(parser.send(:normalize_error_mode, '')).to eq(:log)
+    end
+
+    it 'handles nil by defaulting to :log' do
+      expect(parser.send(:normalize_error_mode, nil)).to eq(:log)
+    end
+  end
+
+  describe 'custom environment variable name' do
+    it 'uses custom environment variable when specified' do
+      custom_parser = described_class.new(env_var: 'CUSTOM_OPTS')
+      ENV['CUSTOM_OPTS'] = '--error-mode off'
+
+      expect(custom_parser.parse_env_opts).to eq(['--error-mode', 'off'])
+    end
+
+    it 'includes custom env var name in error messages' do
+      custom_parser = described_class.new(env_var: 'MY_CUSTOM_VAR')
+      ENV['MY_CUSTOM_VAR'] = '"bad quote'
+
+      expect do
+        custom_parser.parse_env_opts
+      end.to raise_error(CovLoupe::ConfigurationError, /Invalid MY_CUSTOM_VAR format/)
+    end
+  end
+end

data/spec/option_parsers/error_helper_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+OPTION_TESTS = {
+  staleness: {
+    long: '--staleness',
+    short: '-S',
+    pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
+  },
+  source: {
+    long: '--source',
+    short: '-s',
+    pattern: /Valid values for --source: f\[ull\]|u\[ncovered\]/
+  },
+  error_mode: {
+    long: '--error-mode',
+    short: nil,
+    pattern: /Valid values for --error-mode: o\[ff\]|l\[og\]|d\[ebug\]/
+  },
+  sort_order: {
+    long: '--sort-order',
+    short: '-o',
+    pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
+  }
+}.freeze
+
+RSpec.describe CovLoupe::OptionParsers::ErrorHelper do
+  subject(:helper) { described_class.new }
+
+  # Helper method to capture stderr output
+  def capture_stderr
+    captured = StringIO.new
+    original = $stderr
+    $stderr = captured
+    begin
+      yield
+    rescue SystemExit
+      # Ignore exit calls
+    ensure
+      $stderr = original
+    end
+    captured.string
+  end
+
+  # Helper method to test error output matches expected pattern
+  def expect_error_output(error:, argv:, pattern:)
+    expect do
+      helper.handle_option_parser_error(error, argv: argv)
+    rescue SystemExit
+      # Ignore exit call
+    end.to output(pattern).to_stderr
+  end
+
+  describe '#handle_option_parser_error' do
+    context 'with invalid enumerated option values' do
+      OPTION_TESTS.each_value do |config|
+        context "when parsing #{config[:long]} option" do
+          let(:error) { OptionParser::InvalidArgument.new('invalid argument: xyz') }
+
+          it 'suggests valid values for space-separated form with invalid value' do
+            expect_error_output(
+              error: error,
+              argv: [config[:long], 'xyz'],
+              pattern: config[:pattern]
+            )
+          end
+
+          it 'suggests valid values for equal form with invalid value' do
+            expect_error_output(
+              error: error,
+              argv: ["#{config[:long]}=xyz"],
+              pattern: config[:pattern]
+            )
+          end
+
+          if config[:short]
+            it 'suggests valid values for short form with invalid value' do
+              expect_error_output(
+                error: error,
+                argv: [config[:short], 'xyz'],
+                pattern: config[:pattern]
+              )
+            end
+          end
+        end
+      end
+
+      context 'when handling --staleness option edge cases' do
+        it 'suggests valid values when value is missing' do
+          error = OptionParser::InvalidArgument.new('missing argument: --staleness')
+          expect_error_output(
+            error: error,
+            argv: ['--staleness'],
+            pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
+          )
+        end
+
+        it 'suggests valid values when next token looks like an option' do
+          error = OptionParser::InvalidArgument.new('invalid argument: --other')
+          expect_error_output(
+            error: error,
+            argv: ['--staleness', '--other-option'],
+            pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
+          )
+        end
+      end
+    end
+
+    context 'with multiple options in argv' do
+      it 'correctly identifies the problematic option among valid options' do
+        error = OptionParser::InvalidArgument.new('invalid argument: bad')
+        expect_error_output(
+          error: error,
+          argv: ['--resultset', 'coverage', '--staleness', 'bad', '--format', 'json'],
+          pattern: /Valid values for --staleness: o\[ff\]|e\[rror\]/
+        )
+      end
+
+      it 'handles equal form mixed with other options' do
+        error = OptionParser::InvalidArgument.new('invalid argument: invalid')
+        expect_error_output(
+          error: error,
+          argv: ['--format', 'json', '--sort-order=invalid', '--resultset', 'coverage'],
+          pattern: /Valid values for --sort-order: a\[scending\]|d\[escending\]/
+        )
+      end
+    end
+
+    context 'when option is not an enumerated type' do
+      it 'shows generic error message without enum hint' do
+        error = OptionParser::InvalidArgument.new('invalid option: --unknown')
+
+        stderr_output = capture_stderr do
+          helper.handle_option_parser_error(error, argv: ['--unknown'])
+        end
+
+        expect(stderr_output).to match(/Error:.*invalid option.*--unknown/)
+        expect(stderr_output).to match(/Run 'cov-loupe --help'/)
+        expect(stderr_output).not_to match(/Valid values/)
+      end
+    end
+
+    context 'when invalid option matches a subcommand' do
+      it 'suggests using it as a subcommand instead' do
+        error = OptionParser::InvalidOption.new('invalid option: --summary')
+
+        stderr_output = capture_stderr do
+          helper.handle_option_parser_error(error, argv: ['--summary'])
+        end
+
+        # NOTE: The subcommand detection logic isn't fully working as expected
+        # because extract_invalid_option doesn't properly parse the error message
+        expect(stderr_output).to match(/Error:.*--summary/)
+        expect(stderr_output).to match(/Run 'cov-loupe --help'/)
+      end
+    end
+
+    context 'when exiting after invalid option' do
+      it 'exits with status 1' do
+        error = OptionParser::InvalidArgument.new('invalid argument: xyz')
+
+        stderr_output = capture_stderr do
+          expect do
+            helper.handle_option_parser_error(error, argv: ['--staleness', 'xyz'])
+          end.to raise_error(SystemExit) do |e|
+            expect(e.status).to eq(1)
+          end
+        end
+
+        expect(stderr_output).to include('invalid argument: xyz')
+      end
+    end
+
+    context 'when customizing usage hint' do
+      it 'uses custom usage hint when provided' do
+        error = OptionParser::InvalidArgument.new('invalid argument: xyz')
+
+        expect do
+          helper.handle_option_parser_error(error, argv: ['--staleness', 'xyz'],
+            usage_hint: 'Custom hint message')
+        rescue SystemExit
+          # Ignore exit call
+        end.to output(/Custom hint message/).to_stderr
+      end
+    end
+  end
+
+  describe 'when handling edge cases' do
+    it 'handles empty argv gracefully' do
+      error = OptionParser::InvalidArgument.new('some error')
+      expect_error_output(
+        error: error,
+        argv: [],
+        pattern: /Error: invalid argument: some error/
+      )
+    end
+
+    it 'handles argv with only valid options (no problematic enum)' do
+      error = OptionParser::InvalidArgument.new('some error')
+
+      stderr_output = capture_stderr do
+        helper.handle_option_parser_error(error,
+          argv: ['--format', 'json', '--resultset', 'coverage'])
+      end
+
+      expect(stderr_output).to match(/Error: invalid argument: some error/)
+      expect(stderr_output).to match(/Run 'cov-loupe --help'/)
+    end
+
+    it 'does not show enum hint when all enum values are valid' do
+      error = OptionParser::MissingArgument.new('missing argument: --resultset')
+
+      stderr_output = capture_stderr do
+        helper.handle_option_parser_error(error, argv: ['--staleness', 'off', '--resultset'])
+      end
+
+      expect(stderr_output).to match(/Error:.*missing argument.*--resultset/)
+      expect(stderr_output).not_to match(/Valid values/)
+    end
+  end
+end

data/spec/path_relativizer_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::PathRelativizer do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+  let(:relativizer) do
+    described_class.new(
+      root: root,
+      scalar_keys: %w[file file_path],
+      array_keys: %w[newer_files missing_files deleted_files]
+    )
+  end
+
+  describe '#relativize' do
+    it 'converts configured scalar keys to root-relative paths' do
+      payload = { 'file' => File.join(root, 'lib/foo.rb') }
+      result = relativizer.relativize(payload)
+
+      expect(result['file']).to eq('lib/foo.rb')
+      expect(payload['file']).to eq(File.join(root, 'lib/foo.rb'))
+    end
+
+    it 'relativizes arrays for configured keys without mutating originals' do
+      payload = {
+        'newer_files' => [File.join(root, 'lib/foo.rb'), File.join(root, 'lib/bar.rb')]
+      }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['newer_files']).to contain_exactly('lib/foo.rb', 'lib/bar.rb')
+      expect(payload['newer_files']).to all(start_with(root))
+    end
+
+    it 'leaves unconfigured keys untouched' do
+      payload = { 'other' => File.join(root, 'lib/foo.rb') }
+      result = relativizer.relativize(payload)
+
+      expect(result['other']).to eq(payload['other'])
+    end
+
+    it 'ignores paths outside the root' do
+      outside = '/tmp/external.rb'
+      payload = { 'file' => outside }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['file']).to eq(outside)
+    end
+
+    it 'relativizes nested arrays of hashes' do
+      payload = {
+        'files' => [
+          { 'file' => File.join(root, 'lib/foo.rb') },
+          { 'file' => File.join(root, 'lib/bar.rb') }
+        ],
+        'counts' => { 'total' => 2 }
+      }
+
+      result = relativizer.relativize(payload)
+
+      expect(result['files'].map { |h| h['file'] }).to eq(%w[lib/foo.rb lib/bar.rb])
+      expect(result['counts']).to eq('total' => 2)
+    end
+
+    it "handles paths with '..' components" do
+      payload = { 'file' => File.join(root, 'lib/../lib/foo.rb') }
+      result = relativizer.relativize(payload)
+      expect(result['file']).to eq('lib/foo.rb')
+    end
+
+    it 'handles paths with spaces' do
+      file_with_space = File.join(root, 'lib/file with space.rb')
+      FileUtils.touch(file_with_space)
+
+      payload = { 'file' => file_with_space }
+      result = relativizer.relativize(payload)
+      expect(result['file']).to eq('lib/file with space.rb')
+    ensure
+      FileUtils.rm_f(file_with_space)
+    end
+
+    # On Windows, relative_path_from raises ArgumentError for paths on different
+    # drives (e.g., C: vs D:). The rescue block returns the original path.
+    it 'returns original path when relative_path_from raises ArgumentError' do
+      fake_pathname = instance_double(Pathname)
+      allow(fake_pathname).to receive(:relative_path_from)
+        .and_raise(ArgumentError, 'different prefix')
+      allow(Pathname).to receive(:new).and_call_original
+      allow(Pathname).to receive(:new).with(File.absolute_path('lib/foo.rb', root))
+        .and_return(fake_pathname)
+
+      result = relativizer.relativize_path(File.join(root, 'lib/foo.rb'))
+
+      expect(result).to eq(File.join(root, 'lib/foo.rb'))
+    end
+  end
+end

data/spec/presenters/coverage_detailed_presenter_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe CovLoupe::Presenters::CoverageDetailedPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :detailed_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [
+        { 'line' => 1, 'hits' => 1, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false }
+      ],
+      'summary' => { 'covered' => 1, 'total' => 2, 'percentage' => 50.0 }
+    },
+    stale: 'L',
+    expected_keys: ['lines', 'summary']
+end

data/spec/presenters/coverage_raw_presenter_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe CovLoupe::Presenters::CoverageRawPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :raw_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'lines' => [1, 0, nil, 2]
+    },
+    stale: 'L',
+    expected_keys: ['lines']
+end

data/spec/presenters/coverage_summary_presenter_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe CovLoupe::Presenters::CoverageSummaryPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :summary_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'summary' => { 'covered' => 8, 'total' => 10, 'percentage' => 80.0 }
+    },
+    stale: false,
+    expected_keys: ['summary']
+end

data/spec/presenters/coverage_uncovered_presenter_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../shared_examples/coverage_presenter_examples'
+
+RSpec.describe CovLoupe::Presenters::CoverageUncoveredPresenter do
+  it_behaves_like 'a coverage presenter',
+    model_method: :uncovered_for,
+    payload: {
+      'file' => '/abs/path/lib/foo.rb',
+      'uncovered' => [2, 4],
+      'summary' => { 'covered' => 2, 'total' => 4, 'percentage' => 50.0 }
+    },
+    stale: 'M',
+    expected_keys: ['uncovered', 'summary']
+end