simplecov-mcp 1.0.1 → 2.0.0

data/spec/cli_format_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI, 'format option' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli(*argv)
+    cli = SimpleCovMcp::CoverageCLI.new
+    output = nil
+    silence_output do |stdout, _stderr|
+      cli.send(:run, argv)
+      output = stdout.string
+    end
+    output
+  end
+
+  describe 'format normalization' do
+    it 'normalizes short format aliases' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'j', 'list')
+      expect(output).to include('"files":', '"percentage":')
+      data = JSON.parse(output)
+      expect(data['files']).to be_an(Array)
+    end
+
+    it 'normalizes table format' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 't', 'list')
+      expect(output).to include('File', '%')  # Table output
+      expect(output).not_to include('"files"')  # Not JSON
+    end
+
+    it 'supports yaml format' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'y', 'list')
+      expect(output).to include('---', 'files:', 'file:')
+    end
+
+    it 'supports awesome_print format' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'a', 'list')
+      # AwesomePrint output contains colored/formatted structure
+      expect(output).to match(/:files|"files"/)
+    end
+  end
+
+  describe 'option order requirements' do
+    it 'works with format option before subcommand' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json', 'list')
+      data = JSON.parse(output)
+      expect(data).to have_key('files')
+    end
+
+    it 'shows helpful error when global option comes after subcommand' do
+      _out, err, status = run_cli_with_status(
+        '--root', root, '--resultset', 'coverage', 'list', '--format', 'json'
+      )
+      expect(status).to eq(1)
+      expect(err).to include(
+        'Global option(s) must come BEFORE the subcommand',
+        'You used: list --format',
+        'Correct: --format list',
+        'Example:'
+      )
+    end
+  end
+
+  describe 'format with different subcommands' do
+    it 'works with totals subcommand' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json', 'totals')
+      data = JSON.parse(output)
+      expect(data).to have_key('lines')
+      expect(data).to have_key('percentage')
+    end
+
+    it 'works with summary subcommand' do
+      output = run_cli('--root', root, '--resultset', 'coverage', '--format', 'json',
+        'summary', 'lib/foo.rb')
+      data = JSON.parse(output)
+      expect(data).to have_key('file')
+      expect(data).to have_key('summary')
+    end
+
+    it 'works with version subcommand' do
+      output = run_cli('--format', 'json', 'version')
+      data = JSON.parse(output)
+      expect(data).to have_key('version')
+      expect(data).to have_key('gem_root')
+    end
+  end
+
+  describe 'comprehensive misplaced option detection' do
+    # Array of test cases: [description, args_array, expected_option_in_error]
+    [
+      # Short-form options
+      ['short -f after list', ['list', '-f', 'json'], '-f'],
+      ['short -r after totals', ['totals', '-r', '.resultset.json'], '-r'],
+      ['short -R after list', ['list', '-R', '/tmp'], '-R'],
+      ['short -o after list', ['list', '-o', 'a'], '-o'],
+      ['short -s after list', ['list', '-s', 'full'], '-s'],
+      ['short -S after list', ['list', '-S', 'error'], '-S'],
+
+      # Long-form options
+      ['--sort-order after list', ['list', '--sort-order', 'ascending'], '--sort-order'],
+      ['--source after list', ['list', '--source', 'full'], '--source'],
+      ['--staleness after totals', ['totals', '--staleness', 'error'], '--staleness'],
+      ['--color after list', ['list', '--color'], '--color'],
+      ['--no-color after list', ['list', '--no-color'], '--no-color'],
+      ['--log-file after list', ['list', '--log-file', '/tmp/test.log'], '--log-file'],
+
+      # Different subcommands
+      ['option after version', ['version', '--format', 'json'], '--format'],
+      ['option after summary', ['summary', 'lib/foo.rb', '--format', 'json'], '--format'],
+      ['option after raw', ['raw', 'lib/foo.rb', '-f', 'json'], '-f'],
+      ['option after detailed', ['detailed', 'lib/foo.rb', '-f', 'json'], '-f'],
+      ['option after uncovered', ['uncovered', 'lib/foo.rb', '--root', '/tmp'], '--root']
+    ].each do |desc, args, option|
+      it "detects #{desc}" do
+        _out, err, status = run_cli_with_status(*args)
+        expect(status).to eq(1)
+        expect(err).to include('Global option(s) must come BEFORE the subcommand')
+        expect(err).to include(option)
+      end
+    end
+  end
+end

data/spec/cli_json_options_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageCLI, 'json format options' do
+  let(:root) { (FIXTURES_DIR / 'project1').to_s }
+
+  def run_cli_output(*argv)
+    cli = SimpleCovMcp::CoverageCLI.new
+    output = nil
+    silence_output do |stdout, _stderr|
+      cli.send(:run, argv)
+      output = stdout.string
+    end
+    output
+  end
+
+  describe 'JSON format options' do
+    it 'produces compact JSON with -f j' do
+      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'j', 'list')
+
+      expect(output.strip.lines.count).to eq(1)
+      data = JSON.parse(output)
+      expect(data['files']).to be_an(Array)
+    end
+
+    it 'produces pretty JSON with -f pretty-json' do
+      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'pretty-json',
+        'list')
+      expect(output.strip.lines.count).to be > 1
+      data = JSON.parse(output)
+      expect(data['files']).to be_an(Array)
+    end
+
+    it 'produces pretty JSON with -f pretty_json (underscore variant)' do
+      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'pretty_json',
+        'list')
+      expect(output.strip.lines.count).to be > 1
+      data = JSON.parse(output)
+      expect(data['files']).to be_an(Array)
+    end
+
+    it 'produces compact JSON with -f json' do
+      output = run_cli_output('--root', root, '--resultset', 'coverage', '-f', 'json', 'list')
+      expect(output.strip.lines.count).to eq(1)
+      data = JSON.parse(output)
+      expect(data['files']).to be_an(Array)
+    end
+  end
+end

data/spec/cli_source_spec.rb

@@ -7,90 +7,38 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
 
   it 'renders uncovered source without error for fixture file' do
     out, err, status = run_cli_with_status(
-      'uncovered', 'lib/foo.rb', '--root', root, '--resultset', 'coverage',
-      '--source=uncovered', '--source-context', '1', '--no-color'
+      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '1',
+      '--no-color', 'uncovered', 'lib/foo.rb'
     )
     expect(status).to eq(0)
     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 include('│')  # Table format
     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'
+      '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
+      'uncovered', 'lib/foo.rb'
     )
     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 include('│')  # Table format
+    expect(out).to include('66.67%')
     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'
+      '--root', root, '--resultset', 'coverage', '--source', 'uncovered', '--context-lines', '1',
+      '--no-color', 'summary', 'lib/foo.rb'
     )
     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 include('66.67%')
+    expect(out).to include('│')  # Table format
     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

@@ -9,48 +9,65 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
   def run_cli(*argv)
     cli = described_class.new
     silence_output do |out, _err|
-      cli.run(argv.flatten)
+      begin
+        cli.run(argv.flatten)
+      rescue SystemExit
+        # Ignore exit, just capture output
+      end
       return out.string
     end
   end
 
-  it 'prints summary as JSON for a file' do
-    output = run_cli('summary', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
-    data = JSON.parse(output)
-    expect(data['file']).to end_with('lib/foo.rb')
-    expect(data['summary']).to include('covered' => 2, 'total' => 3)
-  end
+  describe 'JSON output' do
+    def with_json_output(command, *args)
+      output = run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+        command, *args)
+      yield JSON.parse(output)
+    end
 
-  it 'prints raw lines as JSON' do
-    output = run_cli('raw', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
-    data = JSON.parse(output)
-    expect(data['file']).to end_with('lib/foo.rb')
-    expect(data['lines']).to eq([1, 0, nil, 2])
-  end
+    it 'prints summary as JSON' do
+      with_json_output('summary', 'lib/foo.rb') do |data|
+        expect(data['summary']).to include('covered' => 2)
+      end
+    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 raw as JSON' do
+      with_json_output('raw', 'lib/foo.rb') do |data|
+        expect(data['lines']).to eq([1, 0, nil, 2])
+      end
+    end
 
-  it 'prints uncovered lines as JSON' do
-    output = run_cli('uncovered', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
-    data = JSON.parse(output)
-    expect(data['uncovered']).to eq([2])
-    expect(data['summary']).to include('total' => 3)
+    it 'prints uncovered as JSON' do
+      with_json_output('uncovered', 'lib/foo.rb') do |data|
+        expect(data['uncovered']).to eq([2])
+      end
+    end
+
+    it 'prints detailed as JSON' do
+      with_json_output('detailed', 'lib/foo.rb') do |data|
+        expect(data['lines']).to be_an(Array)
+      end
+    end
+
+    it 'prints totals as JSON' do
+      with_json_output('totals') do |data|
+        expect(data['lines']).to include('total' => 6, 'covered' => 3, 'uncovered' => 3)
+        expect(data['files']).to include('total' => 2)
+        expect(data['files']['ok'] + data['files']['stale']).to eq(data['files']['total'])
+      end
+    end
   end
 
-  it 'prints detailed rows as JSON' do
-    output = run_cli('detailed', 'lib/foo.rb', '--json', '--root', root, '--resultset', 'coverage')
-    data = JSON.parse(output)
-    expect(data['lines']).to be_an(Array)
-    expect(data['lines'].first).to include('line', 'hits', 'covered')
+  it 'prints raw lines as text' do
+    output = run_cli('--root', root, '--resultset', 'coverage', 'raw', 'lib/foo.rb')
+    expect(output).to include('File: lib/foo.rb')
+    expect(output).to include('│')  # Table format
   end
 
   it 'list subcommand with --json outputs JSON with sort order' do
-    output = run_cli('list', '--json', '--root', root, '--resultset', 'coverage', '--sort-order',
-      'a')
+    output = run_cli(
+      '--format', 'json', '--root', root, '--resultset', 'coverage', '--sort-order', 'a', 'list'
+    )
     asc = JSON.parse(output)
     expect(asc['files']).to be_an(Array)
     expect(asc['files'].first['file']).to end_with('lib/bar.rb')
@@ -63,14 +80,15 @@ 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',
-      'd')
+    output = run_cli(
+      '--format', 'json', '--root', root, '--resultset', 'coverage', '--sort-order', 'd', 'list'
+    )
     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')
+    output = run_cli('--root', root, '--resultset', 'coverage', 'list')
     expect(output).to include('File')
     expect(output).to include('lib/foo.rb')
     expect(output).to include('lib/bar.rb')
@@ -79,20 +97,23 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
 
   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)
+    output = run_cli('--root', root, '--resultset', 'coverage', '--tracked-globs',
+      absolute_glob, 'list')
     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])
+  it 'totals subcommand prints a readable summary by default' do
+    output = run_cli('--root', root, '--resultset', 'coverage', 'totals')
+    expect(output).to include('│')  # Table format
+    expect(output).to include('Lines')
+    # expect(output).to include('Average coverage:')  # Not in table 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('--format', 'json', '--root', root, '--resultset', 'coverage',
+      '--source', 'full', 'summary', 'lib/foo.rb')
     data = JSON.parse(output)
     expect(data).to have_key('source')
   end
@@ -108,8 +129,8 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
           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)
+        run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+          '--log-file', log_path, 'summary', 'lib/foo.rb')
         expect(SimpleCovMcp.active_log_file).to eq(original_target)
       end
     end
@@ -122,86 +143,50 @@ RSpec.describe SimpleCovMcp::CoverageCLI do
         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')
+      run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
+        '--log-file', 'stdout', 'summary', 'lib/foo.rb')
       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('│')  # Table format
       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')
+      output = run_cli('--format', 'json', 'version')
       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')
+      output = run_cli('--root', root, 'version')
+      expect(output).to include('│')  # Table format
+      expect(output).to include(SimpleCovMcp::VERSION)
+    end
+  end
+
+  describe 'version option (-v)' do
+    it 'prints the same version info as the version subcommand' do
+      output = run_cli('-v')
+      expect(output).to include('│')  # Table format
       expect(output).to include(SimpleCovMcp::VERSION)
     end
+
+    it 'respects --json when -v is used' do
+      output = run_cli('-v', '--format', 'json')
+      data = JSON.parse(output)
+      expect(data['version']).to eq(SimpleCovMcp::VERSION)
+    end
   end
 end

data/spec/cli_usage_spec.rb

@@ -1,42 +1,42 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tempfile'
 
 RSpec.describe SimpleCovMcp::CoverageCLI do
   let(:root) { (FIXTURES_DIR / 'project1').to_s }
 
   it 'errors with usage when summary path is missing' do
-    _out, err, status = run_cli_with_status('summary', '--root', root, '--resultset', 'coverage')
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'summary')
     expect(status).to eq(1)
     expect(err).to include('Usage: simplecov-mcp summary <path>')
   end
 
   it 'errors with meaningful message for unknown subcommand' do
-    out, err, status = run_cli_with_status('bogus', '--root', root, '--resultset', 'coverage')
+    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'bogus')
     expect(status).to eq(1)
-    expect(err).to include("Unknown subcommand: 'bogus'")
-    expect(err).to include('Valid subcommands:')
+    expect(err).to include("Unknown subcommand: 'bogus'", 'Valid subcommands:')
   end
 
   it 'list honors stale=error and tracked_globs by exiting 1 when project is stale' do
-    tmp = File.join(root, 'lib', 'brand_new_file_for_cli_usage_spec.rb')
-    begin
-      File.write(tmp, "# new file\n")
-      _out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage',
-        '--stale', 'error', '--tracked-globs', 'lib/**/*.rb')
+    Tempfile.create(['brand_new_file_for_cli_usage_spec', '.rb'], File.join(root, 'lib')) do |f|
+      f.write("# new file\n")
+      f.flush
+      _out, err, status = run_cli_with_status(
+        '--root', root, '--resultset', 'coverage', '--staleness', 'error', '--tracked-globs',
+        'lib/**/*.rb', 'list'
+      )
       expect(status).to eq(1)
       expect(err).to include('Coverage data stale (project)')
-    ensure
-      File.delete(tmp) if File.exist?(tmp)
     end
   end
 
   it 'list with stale=off prints table and exits 0' do
-    out, err, status = run_cli_with_status('list', '--root', root, '--resultset', 'coverage',
-      '--stale', 'off')
+    out, err, status = run_cli_with_status(
+      '--root', root, '--resultset', 'coverage', '--staleness', 'off', 'list'
+    )
     expect(status).to eq(0)
     expect(err).to eq('')
-    expect(out).to include('File')
-    expect(out).to include('lib/foo.rb')
+    expect(out).to include('File', 'lib/foo.rb')
   end
 end