simplecov-mcp 0.3.0 → 1.0.0

data/spec/cli_enumerated_options_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'CLI enumerated option parsing' do
+  def parse!(argv)
+    cli = SimpleCovMcp::CoverageCLI.new
+    cli.send(:parse_options!, argv.dup)
+    cli
+  end
+
+  describe 'accepts short and long forms' do
+    cases = [
+      { argv: ['--sort-order', 'a', 'list'], accessor: :sort_order, expected: :ascending },
+      { argv: ['--sort-order', 'd', 'list'], accessor: :sort_order, expected: :descending },
+      { argv: ['--sort-order', 'ascending', 'list'], accessor: :sort_order, expected: :ascending },
+      { argv: ['--sort-order', 'descending', 'list'], accessor: :sort_order,
+        expected: :descending },
+
+      { argv: ['--source', 'f', 'summary', 'lib/foo.rb'], accessor: :source_mode, expected: :full },
+      { argv: ['--source=u', 'summary', 'lib/foo.rb'], accessor: :source_mode,
+        expected: :uncovered },
+      { argv: ['--source=full', 'summary', 'lib/foo.rb'], accessor: :source_mode, expected: :full },
+      { argv: ['--source=uncovered', 'summary', 'lib/foo.rb'], accessor: :source_mode,
+        expected: :uncovered },
+
+      { argv: ['-S', 'e', 'list'], accessor: :stale_mode, expected: :error },
+      { argv: ['-S', 'o', 'list'], accessor: :stale_mode, expected: :off },
+
+      { argv: ['--error-mode', 'off', 'list'], accessor: :error_mode, expected: :off },
+      { argv: ['--error-mode', 'on', 'list'], accessor: :error_mode, expected: :on },
+      { argv: ['--error-mode', 't', 'list'], accessor: :error_mode, expected: :trace }
+    ]
+
+    cases.each do |c|
+      it "parses #{c[:argv].join(' ')}" do
+        cli = parse!(c[:argv])
+        expect(cli.config.public_send(c[:accessor])).to eq(c[:expected])
+      end
+    end
+  end
+
+  describe 'rejects invalid values' do
+    invalid_cases = [
+      { argv: ['--sort-order', 'asc', 'list'] },
+      { argv: ['--source=x', 'summary', 'lib/foo.rb'] },
+      { argv: ['-S', 'x', 'list'] },
+      { argv: ['--error-mode', 'bad', 'list'] }
+    ]
+
+    invalid_cases.each do |c|
+      it "exits 1 for #{c[:argv].join(' ')}" do
+        _out, err, status = run_cli_with_status(*c[:argv])
+        expect(status).to eq(1)
+        expect(err).to include('Error:')
+        expect(err).to include('invalid argument')
+      end
+    end
+  end
+
+  describe 'missing value hints' do
+    it 'exits 1 when -S is provided without a value' do
+      _out, err, status = run_cli_with_status('-S', 'list')
+      expect(status).to eq(1)
+      expect(err).to include('invalid argument')
+    end
+  end
+end

data/spec/cli_error_spec.rb

@@ -3,30 +3,16 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
-  let(:root) { (FIXTURES / 'project1').to_s }
-
-  def run_cli_with_status(*argv)
-    cli = described_class.new
-    status = nil
-    out_str = err_str = nil
-    silence_output do |out, err|
-      begin
-        cli.run(argv.flatten)
-        status = 0
-      rescue SystemExit => e
-        status = e.status
-      end
-      out_str = out.string
-      err_str = err.string
-    end
-    [out_str, err_str, status]
-  end
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   it 'shows help and exits 0' do
     out, err, status = run_cli_with_status('--help')
     expect(status).to eq(0)
-    expect(out).to include('Usage: simplecov-mcp')
-    expect(err).to eq("")
+    expect(out).to match(/Usage:.*simplecov-mcp/)
+    expect(out).to include('Repository: https://github.com/keithrbennett/simplecov-mcp')
+    expect(out).to match(/Version:.*#{SimpleCovMcp::VERSION}/)
+    expect(out).to include('Subcommands:')
+    expect(err).to eq('')
   end
 
   shared_examples 'maps error to exit 1 with message' do
@@ -64,40 +50,112 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
   end
 
   it 'emits detailed stale coverage info and exits 1' do
-    begin
-      allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(0)
-      _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--stale', 'error')
-      expect(status).to eq(1)
-      expect(err).to include('Coverage data stale:')
-      expect(err).to match(/File\s+- time:/)
-      expect(err).to match('Coverage\s+- time:')
-      expect(err).to match(/Delta\s+- file is [+-]?\d+s newer than coverage/)
-      expect(err).to match('Resultset\s+-')
-    ensure
-    end
+    mock_resultset_with_timestamp(root, VERY_OLD_TIMESTAMP, coverage: {
+      File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
+    })
+
+    _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset',
+      'coverage', '--stale', 'error')
+    expect(status).to eq(1)
+    expect(err).to include('Coverage data stale:')
+    expect(err).to match(/File\s+- time:/)
+    expect(err).to match('Coverage\s+- time:')
+    expect(err).to match(/Delta\s+- file is [+-]?\d+s newer than coverage/)
+    expect(err).to match('Resultset\s+-')
   end
 
   it 'honors --no-strict-staleness to disable checks' do
+    mock_resultset_with_timestamp(root, VERY_OLD_TIMESTAMP, coverage: {
+      File.join(root, 'lib', 'foo.rb') => { 'lines' => [1, 0, 1] }
+    })
+
+    _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset',
+      'coverage', '--stale', 'off')
+    expect(status).to eq(0)
+    expect(err).to eq('')
+  end
+
+  it 'handles source rendering errors gracefully with fallback message' do
+    # Test that source rendering with problematic coverage data doesn't crash
+    # This is a regression test for the "can't convert nil into Integer" crash
+    # that was previously mentioned in comments
+    out, err, status = run_cli_with_status(
+      'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+      '--source=uncovered', '--source-context', '2', '--no-color'
+    )
+
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    expect(out).to match(/File:\s+lib\/foo\.rb/)
+    expect(out).to include('Uncovered lines: 2')
+    expect(out).to show_source_table_or_fallback
+  end
+
+  it 'renders source with full mode without crashing' do
+    # Additional regression test for source rendering with full mode
+    out, err, status = run_cli_with_status(
+      'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+      '--source=full', '--no-color'
+    )
+
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    expect(out).to include('lib/foo.rb')
+    expect(out).to include('66.67%')
+    expect(out).to show_source_table_or_fallback
+  end
+
+  it 'shows fallback message when source file is unreadable' do
+    # Test the fallback path when source files can't be read
+    # Temporarily rename the source file to make it unreadable
+    foo_path = File.join(root, 'lib', 'foo.rb')
+    temp_path = "#{foo_path}.hidden"
+
     begin
-      allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(0)
-      _out, err, status = run_cli_with_status('summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage', '--stale', 'off')
+      File.rename(foo_path, temp_path) if File.exist?(foo_path)
+
+      out, err, status = run_cli_with_status(
+        'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+        '--source=full', '--no-color'
+      )
+
       expect(status).to eq(0)
-      expect(err).to eq("")
+      expect(err).to eq('')
+      expect(out).to include('lib/foo.rb')
+      expect(out).to include('66.67%')
+      expect(out).to include('[source not available]')
     ensure
+      # Restore the file
+      File.rename(temp_path, foo_path) if File.exist?(temp_path)
     end
   end
 
-  # Note on text-mode source rendering tests:
-  # - "Text-mode source" refers to the plain-text source view (no ANSI colors)
-  #   when passing --source or --source=uncovered (checkmarks/dots, line nums).
-  # - Direct tests are omitted here because behavior depends on how paths are
-  #   resolved (relative vs absolute) in combination with --root/--resultset
-  #   and whether the source file is readable. In uncovered mode, we observed
-  #   a crash ("can't convert nil into Integer") when coverage arrays include
-  #   nils or don’t line up with file lines. JSON paths avoid this formatting
-  #   nuance and are already covered elsewhere.
-  # - Once the uncovered+source crash is guarded (treat out-of-range/nil hits
-  #   defensively and only format integers where expected), we can add a
-  #   regression: run `uncovered` with --source=uncovered against the fixtures
-  #   and assert exit status 0 and rendered source.
+  describe 'invalid option handling' do
+    it 'suggests subcommand for --subcommand-like option' do
+      _out, err, status = run_cli_with_status('--summary')
+      expect(status).to eq(1)
+      expect(err).to include(
+        "Error: '--summary' is not a valid option. Did you mean the 'summary' subcommand?"
+      )
+      expect(err).to include('Try: simplecov-mcp summary [args]')
+    end
+
+    it 'reports invalid enum value for --opt=value' do
+      _out, err, status = run_cli_with_status('list', '--stale=bogus')
+      expect(status).to eq(1)
+      expect(err).to include('invalid argument: --stale=bogus')
+    end
+
+    it 'reports invalid enum value for --opt value' do
+      _out, err, status = run_cli_with_status('list', '--stale', 'bogus')
+      expect(status).to eq(1)
+      expect(err).to include('invalid argument: bogus')
+    end
+
+    it 'handles generic invalid options' do
+      _out, err, status = run_cli_with_status('--no-such-option')
+      expect(status).to eq(1)
+      expect(err).to include('Error: invalid option: --no-such-option')
+    end
+  end
 end

data/spec/cli_source_spec.rb

@@ -3,24 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
-  let(:root) { (FIXTURES / 'project1').to_s }
-
-  def run_cli_with_status(*argv)
-    cli = described_class.new
-    status = nil
-    out_str = err_str = nil
-    silence_output do |out, err|
-      begin
-        cli.run(argv.flatten)
-        status = 0
-      rescue SystemExit => e
-        status = e.status
-      end
-      out_str = out.string
-      err_str = err.string
-    end
-    [out_str, err_str, status]
-  end
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   it 'renders uncovered source without error for fixture file' do
     out, err, status = run_cli_with_status(
@@ -28,10 +11,86 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
       '--source=uncovered', '--source-context', '1', '--no-color'
     )
     expect(status).to eq(0)
-    expect(err).to eq("")
-    expect(out).to include('File: lib/foo.rb')
-    expect(out).to include('Uncovered lines: 2')
-    # Accept either rendered source table or fallback message
-    expect(out).to satisfy { |s| s.include?('Line') || s.include?('[source not available]') }
+    expect(err).to eq('')
+    expect(out).to match(/File:\s+lib\/foo\.rb/)
+    expect(out).to match(/Uncovered lines:\s*2\b/)
+    expect(out).to show_source_table_or_fallback
+  end
+
+  it 'renders full source for uncovered command without brittle spacing' do
+    out, err, status = run_cli_with_status(
+      'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+      '--source=full', '--no-color'
+    )
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    # Summary line with flexible spacing
+    expect(out).to match(/Summary:\s*\d+\.\d{2}%\s*\d+\/\d+/)
+    expect(out).to show_source_table_or_fallback
+  end
+
+  it 'renders source for summary with uncovered mode without crashing' do
+    out, err, status = run_cli_with_status(
+      'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+      '--source=uncovered', '--source-context', '1', '--no-color'
+    )
+    expect(status).to eq(0)
+    expect(err).to eq('')
+    expect(out).to include('lib/foo.rb')
+    # Presence of percentage and counts, spacing-agnostic
+    expect(out).to match(/66\.67%/)
+    expect(out).to match(/\b2\/3\b/)
+    expect(out).to show_source_table_or_fallback
+  end
+
+  context 'source option without equals sign' do
+    it 'parses --source uncovered correctly (space-separated argument)' do
+      out, err, status = run_cli_with_status(
+        'summary', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+        '--source', 'uncovered', '--source-context', '1', '--no-color'
+      )
+      expect(status).to eq(0)
+      expect(err).to eq('')
+      expect(out).to include('lib/foo.rb')
+      expect(out).to match(/66\.67%/)
+      expect(out).to match(/\b2\/3\b/)
+      expect(out).to show_source_table_or_fallback
+    end
+
+    it 'parses -s full correctly (short form with space-separated argument)' do
+      out, err, status = run_cli_with_status(
+        'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
+        '-s', 'full', '--no-color'
+      )
+      expect(status).to eq(0)
+      expect(err).to eq('')
+      expect(out).to match(/Summary:\s*\d+\.\d{2}%\s*\d+\/\d+/)
+      expect(out).to show_source_table_or_fallback
+    end
+
+    it 'handles --source uncovered in default report (no subcommand)' do
+      out, err, status = run_cli_with_status(
+        '--root', root, '--resultset', 'coverage',
+        '--source', 'uncovered', '--no-color'
+      )
+      expect(status).to eq(0)
+      expect(err).to eq('')
+      expect(out).to match(/66\.67%/)
+      # Default report doesn't show source tables, that's OK - just check it parses correctly
+      expect(out).not_to include('Unknown subcommand')
+    end
+
+    it 'does not misinterpret following token as subcommand when using --source' do
+      # This test specifically addresses the bug where --source uncovered
+      # was interpreting 'uncovered' as a subcommand
+      out, err, status = run_cli_with_status(
+        '--root', root, '--resultset', 'coverage',
+        '--source', 'uncovered'
+      )
+      expect(status).to eq(0)
+      expect(err).to eq('')
+      expect(out).not_to include('Unknown subcommand')
+      expect(out).to match(/66\.67%/)
+    end
   end
 end

data/spec/cli_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tempfile'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
-  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   def run_cli(*argv)
     cli = described_class.new
@@ -27,6 +28,12 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     expect(data['lines']).to eq([1, 0, nil, 2])
   end
 
+  it 'prints raw lines as text' do
+    output = run_cli('raw', 'lib/foo.rb', '--root', root, '--resultset', 'coverage')
+    expect(output).to include('File: lib/foo.rb')
+    expect(output).to include('[1, 0, nil, 2]')
+  end
+
   it 'prints uncovered lines as JSON' do
     output = run_cli('uncovered', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
     data = JSON.parse(output)
@@ -41,8 +48,9 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     expect(data['lines'].first).to include('line', 'hits', 'covered')
   end
 
-  it 'lists all files as JSON with sort order' do
-    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order', 'ascending')
+  it 'list subcommand with --json outputs JSON with sort order' do
+    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order',
+      'a')
     asc = JSON.parse(output)
     expect(asc['files']).to be_an(Array)
     expect(asc['files'].first['file']).to end_with('lib/bar.rb')
@@ -55,18 +63,145 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
     expect(total).to eq(asc['files'].length)
     expect(ok + stale).to eq(total)
 
-    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order', 'descending')
+    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order',
+      'd')
     desc = JSON.parse(output)
     expect(desc['files'].first['file']).to end_with('lib/foo.rb')
   end
 
+  it 'list subcommand outputs formatted table' do
+    output = run_cli('list', '--root', root, '--resultset', 'coverage')
+    expect(output).to include('File')
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+    expect(output).to match(/Files: total \d+/)
+  end
+
+  it 'list subcommand retains rows when using an absolute tracked glob' do
+    absolute_glob = File.join(root, 'lib', '**', '*.rb')
+    output = run_cli('list', '--root', root, '--resultset', 'coverage', '--tracked-globs',
+      absolute_glob)
+    expect(output).not_to include('No coverage data found')
+    expect(output).to include('lib/foo.rb')
+    expect(output).to include('lib/bar.rb')
+  end
+
   it 'exposes expected subcommands via constant' do
     expect(described_class::SUBCOMMANDS).to eq(%w[list summary raw uncovered detailed version])
   end
 
   it 'can include source in JSON payload (nil if file missing)' do
-    output = run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage', '--source')
+    output = run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage',
+      '--source')
     data = JSON.parse(output)
     expect(data).to have_key('source')
   end
+
+  describe 'log file configuration' do
+    it 'passes --log-file path into the CLI execution context' do
+      Dir.mktmpdir do |dir|
+        log_path = File.join(dir, 'custom.log')
+        expect(SimpleCovMcp).to receive(:create_context)
+          .and_wrap_original do |m, error_handler:, log_target:, mode:|
+          # Ensure CLI forwards the requested log path into the context without changing other fields.
+          expect(log_target).to eq(log_path)
+          m.call(error_handler: error_handler, log_target: log_target, mode: mode)
+        end
+        original_target = SimpleCovMcp.active_log_file
+        run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage',
+          '--log-file', log_path)
+        expect(SimpleCovMcp.active_log_file).to eq(original_target)
+      end
+    end
+
+    it 'supports stdout logging within the CLI context' do
+      expect(SimpleCovMcp).to receive(:create_context)
+        .and_wrap_original do |m, error_handler:, log_target:, mode:|
+        # For stdout logging, verify the context is still constructed with the expected value.
+        expect(log_target).to eq('stdout')
+        m.call(error_handler: error_handler, log_target: log_target, mode: mode)
+      end
+      original_target = SimpleCovMcp.active_log_file
+      run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage',
+        '--log-file', 'stdout')
+      expect(SimpleCovMcp.active_log_file).to eq(original_target)
+    end
+  end
+
+  describe '#load_success_predicate' do
+    let(:cli) { described_class.new }
+
+    def with_temp_predicate(content)
+      Tempfile.create(['predicate', '.rb']) do |file|
+        file.write(content)
+        file.flush
+        yield file.path
+      end
+    end
+
+    it 'loads a callable predicate from file' do
+      with_temp_predicate("->(model) { model }\n") do |path|
+        predicate = cli.send(:load_success_predicate, path)
+        expect(predicate).to respond_to(:call)
+        expect(predicate.call(:ok)).to eq(:ok)
+      end
+    end
+
+    it 'raises when file does not return callable' do
+      with_temp_predicate(":not_callable\n") do |path|
+        expect { cli.send(:load_success_predicate, path) }
+          .to raise_error(RuntimeError, include('Success predicate must be callable'))
+      end
+    end
+
+    it 'wraps syntax errors with friendly message' do
+      with_temp_predicate("->(model) {\n") do |path|
+        expect { cli.send(:load_success_predicate, path) }
+          .to raise_error(RuntimeError, include('Syntax error in success predicate file'))
+      end
+    end
+  end
+
+  describe '#extract_subcommand!' do
+    let(:cli) { described_class.new }
+
+    around do |example|
+      original = ENV['SIMPLECOV_MCP_OPTS']
+      example.run
+    ensure
+      ENV['SIMPLECOV_MCP_OPTS'] = original
+    end
+
+    it 'picks up subcommands that appear after env-provided options' do
+      ENV['SIMPLECOV_MCP_OPTS'] = '--resultset coverage'
+      argv = cli.send(:parse_env_opts) + ['summary', 'lib/foo.rb']
+
+      expect do
+        cli.send(:extract_subcommand!, argv)
+      end.to change { cli.instance_variable_get(:@cmd) }.from(nil).to('summary')
+    end
+  end
+
+  describe 'version command' do
+    it 'prints version as plain text by default' do
+      output = run_cli('version')
+      expect(output).to include('SimpleCovMcp version')
+      expect(output).to include(SimpleCovMcp::VERSION)
+      expect(output).not_to include('{')
+      expect(output).not_to include('}')
+    end
+
+    it 'prints version as JSON when --json flag is used' do
+      output = run_cli('version', '--json')
+      data = JSON.parse(output)
+      expect(data).to have_key('version')
+      expect(data['version']).to eq(SimpleCovMcp::VERSION)
+    end
+
+    it 'works with version command and other flags' do
+      output = run_cli('version', '--root', root)
+      expect(output).to include('SimpleCovMcp version')
+      expect(output).to include(SimpleCovMcp::VERSION)
+    end
+  end
 end