cov-loupe 3.0.0 → 4.0.0.pre

data/spec/cli_source_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  it 'renders uncovered source without error for fixture file' do
-    out, err, status = run_cli_with_status(
-      '--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 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(
-      '--root', root, '--resultset', 'coverage', '--source', 'full', '--no-color',
-      'uncovered', 'lib/foo.rb'
-    )
-    expect(status).to eq(0)
-    expect(err).to eq('')
-    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(
-      '--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')
-    expect(out).to include('66.67%')
-    expect(out).to include('│')  # Table format
-    expect(out).to show_source_table_or_fallback
-  end
-end

data/spec/cli_spec.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-RSpec.describe CovLoupe::CoverageCLI do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  def run_cli(*argv)
-    cli = described_class.new
-    silence_output do |out, _err|
-      begin
-        cli.run(argv.flatten)
-      rescue SystemExit
-        # Ignore exit, just capture output
-      end
-      return out.string
-    end
-  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 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 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 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 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(
-      '--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')
-
-    # Includes counts for total/ok/stale and they are consistent
-    expect(asc['counts']).to include('total', 'ok', 'stale')
-    total = asc['counts']['total']
-    ok = asc['counts']['ok']
-    stale = asc['counts']['stale']
-    expect(total).to eq(asc['files'].length)
-    expect(ok + stale).to eq(total)
-
-    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('--root', root, '--resultset', 'coverage', 'list')
-    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('--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 '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('--format', 'json', '--root', root, '--resultset', 'coverage',
-      '--source', 'full', 'summary', 'lib/foo.rb')
-    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(CovLoupe).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 = CovLoupe.active_log_file
-        run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
-          '--log-file', log_path, 'summary', 'lib/foo.rb')
-        expect(CovLoupe.active_log_file).to eq(original_target)
-      end
-    end
-
-    it 'supports stdout logging within the CLI context' do
-      expect(CovLoupe).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 = CovLoupe.active_log_file
-      run_cli('--format', 'json', '--root', root, '--resultset', 'coverage',
-        '--log-file', 'stdout', 'summary', 'lib/foo.rb')
-      expect(CovLoupe.active_log_file).to eq(original_target)
-    end
-  end
-
-
-
-
-
-  describe 'version command' do
-    it 'prints version as plain text by default' do
-      output = run_cli('version')
-      expect(output).to include('│')  # Table format
-      expect(output).to include(CovLoupe::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('--format', 'json', 'version')
-      data = JSON.parse(output)
-      expect(data).to have_key('version')
-      expect(data['version']).to eq(CovLoupe::VERSION)
-    end
-
-    it 'works with version command and other flags' do
-      output = run_cli('--root', root, 'version')
-      expect(output).to include('│')  # Table format
-      expect(output).to include(CovLoupe::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(CovLoupe::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(CovLoupe::VERSION)
-    end
-  end
-end

data/spec/cli_table_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::CoverageCLI do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  def run_cli(*argv)
-    cli = described_class.new
-    silence_output do |out, _err|
-      cli.run(argv.flatten)
-      return out.string
-    end
-  end
-
-  it 'prints default table when no subcommand is given' do
-    output = run_cli('--root', root, '--resultset', 'coverage')
-
-    # Contains a header row and at least one data row with expected columns
-    expect(output).to include('File')
-    expect(output).to include('Covered')
-    expect(output).to include('Total')
-
-    # Should list fixture files from the demo project
-    expect(output).to include('lib/foo.rb')
-    expect(output).to include('lib/bar.rb')
-  end
-end

data/spec/cli_usage_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-RSpec.describe CovLoupe::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('--root', root, '--resultset', 'coverage', 'summary')
-    expect(status).to eq(1)
-    expect(err).to include('Usage: cov-loupe summary <path>')
-  end
-
-  it 'errors with meaningful message for unknown subcommand' do
-    _out, err, status = run_cli_with_status('--root', root, '--resultset', 'coverage', 'bogus')
-    expect(status).to eq(1)
-    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
-    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)')
-    end
-  end
-
-  it 'list with stale=off prints table and exits 0' do
-    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', 'lib/foo.rb')
-  end
-end

data/spec/commands/base_command_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::Commands::BaseCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-
-  # Create a test command class that exposes protected methods for testing
-  let(:test_command_class) do
-    Class.new(CovLoupe::Commands::BaseCommand) do
-      def execute(args)
-        # Not needed for these tests
-      end
-
-      # Expose protected methods for testing
-      def public_handle_with_path(args, name, &)
-        handle_with_path(args, name, &)
-      end
-    end
-  end
-
-  let(:test_command) { test_command_class.new(cli_context) }
-
-  describe '#handle_with_path' do
-    context 'when Errno::ENOENT is raised' do
-      it 'converts to FileNotFoundError with correct message' do
-        args = ['lib/missing.rb']
-
-        # Stub the block to raise Errno::ENOENT
-        expect do
-          test_command.public_handle_with_path(args, 'test') do |_path|
-            raise Errno::ENOENT, 'No such file or directory'
-          end
-        end.to raise_error(CovLoupe::FileNotFoundError, 'File not found: lib/missing.rb')
-      end
-
-      it 'includes the path from the args in the error message' do
-        args = ['some/other/path.rb']
-
-        expect do
-          test_command.public_handle_with_path(args, 'test') do |_path|
-            raise Errno::ENOENT, 'No such file or directory'
-          end
-        end.to raise_error(CovLoupe::FileNotFoundError, /some\/other\/path\.rb/)
-      end
-    end
-
-    context 'when Errno::EACCES is raised' do
-      it 'converts to FilePermissionError with correct message' do
-        args = ['lib/secret.rb']
-
-        # Stub the block to raise Errno::EACCES
-        expect do
-          test_command.public_handle_with_path(args, 'test') do |_path|
-            raise Errno::EACCES, 'Permission denied'
-          end
-        end.to raise_error(CovLoupe::FilePermissionError, 'Permission denied: lib/secret.rb')
-      end
-
-      it 'includes the path from the args in the error message' do
-        args = ['/root/protected.rb']
-
-        expect do
-          test_command.public_handle_with_path(args, 'test') do |_path|
-            raise Errno::EACCES, 'Permission denied'
-          end
-        end.to raise_error(CovLoupe::FilePermissionError, /\/root\/protected\.rb/)
-      end
-    end
-
-    context 'when no path is provided' do
-      it 'raises UsageError' do
-        args = []
-
-        expect do
-          test_command.public_handle_with_path(args, 'summary') do |_path|
-            # Should not reach here
-          end
-        end.to raise_error(CovLoupe::UsageError, /summary <path>/)
-      end
-    end
-
-    context 'when successful' do
-      it 'yields the path to the block' do
-        args = ['lib/foo.rb']
-        yielded_path = nil
-
-        test_command.public_handle_with_path(args, 'test') do |path|
-          yielded_path = path
-        end
-
-        expect(yielded_path).to eq('lib/foo.rb')
-      end
-
-      it 'shifts the path from args' do
-        args = ['lib/foo.rb', 'extra', 'args']
-
-        test_command.public_handle_with_path(args, 'test') do |_path|
-          # Block execution
-        end
-
-        expect(args).to eq(['extra', 'args'])
-      end
-    end
-  end
-end

data/spec/commands/command_factory_spec.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::Commands::CommandFactory do
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-
-  describe '.create' do
-    context 'with valid command names' do
-      [
-        ['list', CovLoupe::Commands::ListCommand],
-        ['version', CovLoupe::Commands::VersionCommand],
-        ['summary', CovLoupe::Commands::SummaryCommand],
-        ['raw', CovLoupe::Commands::RawCommand],
-        ['uncovered', CovLoupe::Commands::UncoveredCommand],
-        ['detailed', CovLoupe::Commands::DetailedCommand],
-        ['totals', CovLoupe::Commands::TotalsCommand],
-        ['total', CovLoupe::Commands::TotalsCommand] # Alias
-      ].each do |command_name, command_class|
-        it "creates a #{command_class.name.split('::').last} for \"#{command_name}\"" do
-          command = described_class.create(command_name, cli_context)
-          expect(command).to be_a(command_class)
-        end
-      end
-    end
-
-    context 'with unknown command name' do
-      [
-        [
-          'invalid_cmd',
-          'invalid command',
-          /list \| summary <path> \| raw <path> \| uncovered <path>/
-        ],
-        [nil,           'nil command',            nil],
-        ['',            'empty string command',   nil],
-        ['sumary',      'misspelled command',     nil]
-      ].each do |command_name, description, pattern|
-        it "raises UsageError for #{description}" do
-          expect do
-            described_class.create(command_name, cli_context)
-          end.to raise_error(CovLoupe::UsageError, pattern)
-        end
-      end
-    end
-  end
-
-  describe '.available_commands' do
-    it 'returns an array of available command names' do
-      commands = described_class.available_commands
-      expect(commands).to be_an(Array)
-      expect(commands).to contain_exactly('list', 'version', 'summary', 'raw', 'uncovered',
-        'detailed', 'totals', 'total', 'validate')
-    end
-
-    it 'returns the keys from COMMAND_MAP' do
-      expect(described_class.available_commands).to eq(described_class::COMMAND_MAP.keys)
-    end
-  end
-
-  describe 'COMMAND_MAP' do
-    it 'is frozen to prevent modifications' do
-      expect(described_class::COMMAND_MAP).to be_frozen
-    end
-
-    it 'maps command names to command classes' do
-      expect(described_class::COMMAND_MAP['list']).to eq(CovLoupe::Commands::ListCommand)
-      expect(described_class::COMMAND_MAP['version']).to eq(CovLoupe::Commands::VersionCommand)
-      expect(described_class::COMMAND_MAP['summary']).to eq(CovLoupe::Commands::SummaryCommand)
-      expect(described_class::COMMAND_MAP['raw']).to eq(CovLoupe::Commands::RawCommand)
-      expect(described_class::COMMAND_MAP['uncovered']).to eq(CovLoupe::Commands::UncoveredCommand)
-      expect(described_class::COMMAND_MAP['detailed']).to eq(CovLoupe::Commands::DetailedCommand)
-      expect(described_class::COMMAND_MAP['totals']).to eq(CovLoupe::Commands::TotalsCommand)
-      expect(described_class::COMMAND_MAP['total']).to eq(CovLoupe::Commands::TotalsCommand)
-    end
-  end
-end

data/spec/commands/detailed_command_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::DetailedCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-    cli_context.config.source_mode = nil
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints the detailed coverage table' do
-        output = capture_command_output(command, ['lib/foo.rb'])
-
-        expect(output).to include('File: lib/foo.rb', 'Line', 'Covered')
-      end
-    end
-
-    context 'with stale data' do
-      before { stub_staleness_check('L') }
-
-      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
-        { 'file' => 'lib/foo.rb', 'lines' => nil, 'summary' => nil, 'stale' => 'L' }
-    end
-  end
-end

data/spec/commands/list_command_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::ListCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'outputs a formatted table' do
-        output = capture_command_output(command, [])
-
-        expect(output).to include('│', 'lib/foo.rb', 'lib/bar.rb')
-      end
-    end
-
-    it_behaves_like 'a command with formatted output', [], ['files', 'counts']
-  end
-end

data/spec/commands/raw_command_spec.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::RawCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints the raw coverage lines for the requested file' do
-        output = capture_command_output(command, ['lib/foo.rb'])
-
-        expect(output).to include('│', 'lib/foo.rb', 'Line', 'Coverage')
-      end
-    end
-
-    context 'when the file is fully covered' do
-      it 'still prints the raw table' do
-        mock_presenter(
-          CovLoupe::Presenters::CoverageRawPresenter,
-          absolute_payload: {
-            'file' => 'lib/perfect.rb',
-            'lines' => [1, 1, 1],
-            'stale' => false
-          },
-          relative_path: 'lib/perfect.rb'
-        )
-
-        output = capture_command_output(command, ['lib/perfect.rb'])
-
-        expect(output).to include('│', '│    1 │        1 │')
-        expect(output).not_to include('All lines covered!')
-      end
-    end
-
-    context 'with JSON output' do
-      before { cli_context.config.format = :json }
-
-      it 'emits JSON with specific line data' do
-        stub_staleness_check('L') # Needed for stale data
-
-        output = capture_command_output(command, ['lib/foo.rb'])
-
-        payload = JSON.parse(output)
-        expect(payload['file']).to eq('lib/foo.rb')
-        expect(payload['lines']).to be_an(Array)
-        expect(payload['lines'][0]).to eq(1) # specific value
-        expect(payload['lines'][1]).to eq(0) # specific value
-        expect(payload['stale']).to eq('L')
-      end
-    end
-
-    context 'with stale data (other formats)' do
-      before { stub_staleness_check('L') }
-
-      # Use an array for expected_json_keys as we don't need exact value matching for these generic format tests
-      it_behaves_like 'a command with formatted output', ['lib/foo.rb'], ['file', 'lines', 'stale']
-    end
-  end
-end

data/spec/commands/summary_command_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::SummaryCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-    cli_context.config.source_mode = nil
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints a coverage summary line with a relative path' do
-        output = capture_command_output(command, ['lib/foo.rb'])
-
-        expect(output).to include('│', '66.67%', 'lib/foo.rb')
-      end
-    end
-
-    context 'with stale data' do
-      before { stub_staleness_check('L') }
-
-      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
-        { 'file' => 'lib/foo.rb', 'summary' => nil, 'stale' => 'L' }
-    end
-  end
-end